Netflix/Hystrix · error · IllegalStateException

'https://github.com/Netflix/Hystrix/issues/1458' - no valid…

Error message

'https://github.com/Netflix/Hystrix/issues/1458' - no valid annotation found for: 
{}

What it means

The aspect resolved the intercepted Method but found neither @HystrixCommand nor @HystrixCollapser on it via reflection. This is the guard added for Netflix/Hystrix issue #1458: with certain weaving setups (notably AspectJ compile-time weaving, interface-based proxies, or multiple AOP frameworks layering proxies), the Method object obtained from the join point belongs to a class where the annotation is not visible, and Javanica cannot decide which pipeline to build.

Solutions

Put the annotation directly on the concrete class method, not only on an interface declaration.
Simplify/clarify AOP setup: prefer either runtime Spring AOP or compile-time weaving, not proxies stacking both, and check aspect order so HystrixCommandAspect sees the real target.
Upgrade hystrix-javanica to the latest 1.5.x, where several #1458 proxy-resolution fixes landed.
As a diagnostic, print method.isAnnotationPresent(...) for both annotations from a breakpoint inside the aspect to see which Method object is being inspected.

Example fix

// before (annotation only on interface)
interface UserService {
    @HystrixCommand
    User getUser(String id);
}
class UserServiceImpl implements UserService {
    public User getUser(String id) { ... }   // triggers error under some proxy setups
}

// after
interface UserService {
    User getUser(String id);
}
class UserServiceImpl implements UserService {
    @HystrixCommand
    public User getUser(String id) { ... }
}

Defensive patterns

Strategy: try-catch

Validate before calling

// In a smoke test through the actual Spring/proxied bean:
// boolean ok = false;
// try { userService.getUser("1"); ok = true; }
// catch (IllegalStateException e) { if (e.getMessage().contains("issues/1458")) fail("annotation not visible to aspect: " + e.getMessage()); }

Try / catch

try { proxiedBean.call(); } catch (IllegalStateException e) { if (e.getMessage().contains("no valid annotation found")) { log.error("Hystrix annotation not visible on {} — check AOP weaving/interface annotations", method); throw; } throw e; } — always rethrow; this is wiring, not runtime data.

Prevention

Put @HystrixCommand/@HystrixCollapser on concrete class methods, never only on interfaces.
Exercise every annotated method once in a @SpringBootTest canary so proxy/annotation visibility problems surface in CI, not production.
Avoid stacking Spring AOP proxies and AspectJ compile-time weaving on the same beans; pin one strategy project-wide.

When it happens

Trigger: Annotation declared on an interface method while the aspect resolves the implementation method (or vice versa) through an extra proxy layer; method-level annotations combined with another aspect ordering HystrixCommandAspect outermost so the join point target loses the annotation; compile-time weaving (isCompileWeaving) resolving the ajc-generated method without runtime-visible annotations; an annotation-free method somehow matching the pointcut via meta-annotation bridging.

Common situations: Spring apps mixing Spring AOP and AspectJ weaving; upgrading hystrix-javanica versions where proxy resolution changed; putting @HystrixCommand only on the interface; using annotation aliases or custom meta-annotations the pointcut does not recognize.

Related errors

AI-assisted analysis of Netflix/Hystrix@5ce3bc58c3 (2026-08-14). Data as JSON: /api/errors/5f8d68baaa61d114. Report an issue: GitHub.

Appendix: source

Thrown at hystrix-contrib/hystrix-javanica/src/main/java/com/netflix/hystrix/contrib/javanica/aop/aspectj/HystrixCommandAspect.java:293

                            .observableExecutionMode(hystrixCommand.observableExecutionMode())
                            .executionType(executionType)
                            .observable(ExecutionType.OBSERVABLE == executionType)
                            .build();
        }
    }

    private enum HystrixPointcutType {
        COMMAND,
        COLLAPSER;

        static HystrixPointcutType of(Method method) {
            if (method.isAnnotationPresent(HystrixCommand.class)) {
                return COMMAND;
            } else if (method.isAnnotationPresent(HystrixCollapser.class)) {
                return COLLAPSER;
            } else {
                String methodInfo = getMethodInfo(method);
                throw new IllegalStateException("'https://github.com/Netflix/Hystrix/issues/1458' - no valid annotation found for: \n" + methodInfo);
            }
        }
    }

    private static Method getAjcMethodFromTarget(JoinPoint joinPoint) {
        return getAjcMethodAroundAdvice(joinPoint.getTarget().getClass(), (MethodSignature) joinPoint.getSignature());
    }


    private static Class<?> getFirstGenericParameter(Type type) {
        return getFirstGenericParameter(type, 1);
    }

    private static Class<?> getFirstGenericParameter(final Type type, final int nestedDepth) {
        int cDepth = 0;
        Type tType = type;

        for (int cDept = 0; cDept < nestedDepth; cDept++) {

View on GitHub (pinned to 5ce3bc58c3)