title: @Loggable Annotation only works for some methods
body: <p>I have the following interface: </p>
  
  <pre><code>/**
   * Annotation for methods, whose execution should be logged.
   */
  @Retention(RetentionPolicy.RUNTIME)
  @Target({ElementType.METHOD, ElementType.TYPE})
  public @interface Loggable {
  
      /**
       * Log severity level of 'before' and 'after' log statements.
       */
      enum Level {
          DEBUG,
          INFO,
          WARN,
          ERROR
      }
  
      /**
       * Defines the severity which should be used when logging the method arguments.
       */
      Level level() default Level.FATAL;
  }
  </code></pre>
  
  <p>I also have the following class: </p>
  
  <pre><code>/**
   * Class for logging input and output parameters of any method with annotation @Loggable.
   */
  @Aspect
  public final class LoggingAspect {
      private final Logger log = LoggerFactory.getLogger(getClass());
  
      /**
       * @param jp - ProceedingJointPoint
       * @param loggable - Loggable
       * @return returns the next executable point to proceed in target
       * @throws Throwable - throws exception when proceeding with joint point
       */
      @Around("execution(* *(..)) &amp;&amp; @annotation(loggable)")
      public Object loggingAroundMethod(@Nonnull final ProceedingJoinPoint jp,
                                        @Nonnull final Loggable loggable) throws Throwable {
          final String signature = jp.getTarget().getClass().getName() + '.' + jp.getSignature().getName();
          final List&lt;Object&gt; arguments = Arrays.asList(jp.getArgs());
  
          final Object result;
          try {
              doLog(loggable.level(), "[BEFORE] {}{}", signature, arguments);
              result = jp.proceed();
              doLog(loggable.level(), "[AFTER] {}{} result={}", signature, arguments, result);
          } catch (Exception e) {
              log.error("[AFTER] {}{} exception={}", signature, arguments, e);
              throw e;
          }
  
          return result;
      }
  
          /**
           * Logs the message with appropriate log level.
           * @param level - level to log
           * @param format - format for logging
           * @param arguments - arguments for logging
           */
          private void doLog(@Nonnull final Loggable.Level level, @Nonnull final String format, final Object... arguments) {
              switch (level) {
                  case DEBUG:
                      log.debug(format, arguments);
                      return;
  
                  case INFO:
                      log.info(format, arguments);
                      return;
  
                  case WARN:
                      log.warn(format, arguments);
                      return;
  
                  case ERROR:
                      break;
  
                  default:
                      log.error("Unable to appropriately handle given log level={}", level);
              }
              log.error(format, arguments);
          }
      }
  </code></pre>
  
  <p>And here is my XML: </p>
  
  <pre><code>&lt;?xml version="1.0" encoding="UTF-8"?&gt;
  &lt;beans xmlns="http://www.springframework.org/schema/beans"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns:aop="http://www.springframework.org/schema/aop"
         xsi:schemaLocation="http://www.springframework.org/schema/beans
                             http://www.springframework.org/schema/beans/spring-beans.xsd
                             http://www.springframework.org/schema/aop
                             http://www.springframework.org/schema/aop/spring-aop-2.5.xsd"
         default-autowire="no"&gt;
      &lt;aop:aspectj-autoproxy proxy-target-class="true"/&gt;
      &lt;bean class="path.to.my.package.LoggingAspect" /&gt;
  &lt;/beans&gt;
  </code></pre>
  
  <p>Now, when I add the @Loggable annotation to an existing method that is being called elsewhere in my program, everything shows up correctly in my logs as expected. The working annotations with method looks something like this: </p>
  
  <pre><code>@Loggable
  public boolean testString(String test) {
    return test.equals("foo"); 
  } 
  </code></pre>
  
  <p>However, when I try to add the annotation to a helper method rather than the method that is already being called in my program, no logs show up. So now the code that doesn't work looks something like this: </p>
  
  <pre><code>public boolean testString(String test) {
    return testStringHelper(test);  
  } 
  
  @Loggable
  public boolean testStringHelper(String test) {
    return test.equals("foo"); 
  }
  </code></pre>
  
  <p>Can anyone offer insight into why the first scenario works, but the second scenario with the helper method doesn't? As an aside, the helper methods are all public. Also, if I add a regular log statement inside the helper method, it does show up in my logs. It's just the annotation that doesn't work with the helper method for some reason. </p>