使用Kanela的@Loggable方法检测

如何解决使用Kanela的@Loggable方法检测

我想以与https://aspects.jcabi.com/apidocs-0.22.6/com/jcabi/aspects/Loggable.html相同的想法在我们的应用程序中设置可记录工具由于我的团队无论如何都将使用Kamon和Kanela在我们的代码库中传播上下文，因此如果由同一个代理执行所有检测工作，对我们而言将更加简单。

所以我想我会自己动手做，并在我们的单声道仓库中启动一个新项目，以拥有一个可记录kamon的模块。我查看了kamon-annotation和kamon-annotation-api代码，以获取有关如何执行此操作的灵感。我发现的唯一文档（http://kamon-io.github.io/kanela/interceptors.html）并不是很有用，并且我对ByteBudy的了解几乎为零...但是开始时使用cameleon编码就足够了：）

我到达了一个看起来不错的地方，可以编译，但是在运行时，没有日志，并且代码似乎也没有执行。代码中的断点从未到过，但可能是正常的，我不确定该类是否在检测后实际实例化，或者代码是否在其他类中内联复制。

任何关于如何设置项目的建议（不要双关语），或者缺少任何建议，将不胜感激。我想这与我的build.sbt或conf文件有关，但是我暂时还停留在...

build.sbt

// scala_common project contains the @com.company.logging.Loggable annotation declaration

// java project (but compiled as scala ?) 
// nothing in the assembly,because no Main to be executed
lazy val loggable = (project in file("common/scala-kamon-loggable"))
    .enablePlugins(JavaAgent)
    .assembly("","scala-kamon-loggable.jar")
    .dependsOn(scala_common)
    .settings(
      javaAgents := Seq("io.kamon"              %  "kanela-agent"    % "1.0.7" % "runtime")
    )
    .settings(
      libraryDependencies ++= Seq(
        "io.kamon"              %% "kamon-core" % "2.1.4","io.kamon"              %% "kamon-annotation" % "2.1.4"
      )
    )

// the main I execute to test
lazy val logging_poc = (project in file("applications/logging-poc"))
    .assembly("com.company.logging.Poc","logging-poc.jar")
    .dependsOn(scala_common,loggable)
    .settings(
      libraryDependencies ++= Seq(
        "io.kamon" %% "kamon-core" % "2.1.4","io.kamon" %% "kamon-scala-future" % "2.1.4","io.kamon" %% "kamon-logback" % "2.1.4"
      )
    )

scala-common

com.company.logging.Loggable

import java.lang.annotation.*;

/**
 * When instrumentation is activated,log all entry / return / throw of the annotated method
 */
@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Loggable {}

scala-kamon-loggable

reference.conf

kanela.modules {
  loggable {
    enabled = true
    name = "Loggable Annotation Instrumentation"
    description = "Provides an annotation to create tracing Logs of annotated methods"

    instrumentations = [
      "com.company.logging.Instrumentation"
    ]
  }
}

com.company.logging.Instrumentation

public final class Instrumentation extends InstrumentationBuilder {

  private static final String Loggable = "com.company.logging.Loggable";

  public Instrumentation() {
    onTypesWithMethodsAnnotatedWith(Loggable)
        .advise(isAnnotatedWith(named(Loggable)),LoggableAdvisor.class);

  }
}

com.company.logging.advisor.LoggableAdvisor

public final class LoggableAdvisor {

  public final static ExecutionContext CallingThreadEC = CallingThreadExecutionContext$.MODULE$;

  @Advice.OnMethodEnter()
  public static void onEnter(
      @Advice.This(optional = true) Object obj,@Advice.Origin Class<?> clazz,@Advice.Origin Method method,@Advice.Origin("#t") String className,@Advice.Origin("#m") String methodName,@Advice.Origin("#s") String signatureName,@Advice.AllArguments Object[] allArguments
  ) {
// I'd put a Logger after,for now,just for testing instrumentation,println is enough
    System.out.println("INSIDE INSTRUMENTATION");
  }
}

logging_poc

application.conf

kamon {
  trace {
    tick-interval = 2 seconds
    sampler = "always"
  }
  enabled: true
}

com.company.logging.Poc

object Poc extends App with LazyLogging {

  val config = ConfigFactory.load()
  if (config.getBoolean("kamon.enabled")) {
    Kamon.loadModules()
  }

  import scala.concurrent.ExecutionContext.Implicits.global
  @com.company.logging.Loggable
  def asyncLog(param: Integer): Future[String] = {
    Kamon.runWithSpan(Kamon.spanBuilder("Level 3").start(),finishSpan = true) {
      Future {
        blocking {
            assert(param < 5,"Param is too big")
            Thread.sleep(param * 1000)
            logger.info(s"Some info logs ! ($param)")
            "Ok"          
        }
      }
    }
  }

  Await.ready( asyncLog(0),Duration.Inf)
  Await.ready(Kamon.stopModules(),Duration.Inf)
}

这是我在控制台中获得的跟踪（其他检测工作，如我们在MDC中看到的SpanId）。我本来希望在“某些信息日志！”之前得到“ INSIDE INSTRUMENTATION”行。

 _  __                _        ______
| |/ /               | |       \ \ \ \
| ' / __ _ _ __   ___| | __ _   \ \ \ \
|  < / _` | '_ \ / _ \ |/ _` |   ) ) ) )
| . \ (_| | | | |  __/ | (_| |  / / / /
|_|\_\__,_|_| |_|\___|_|\__,_| /_/_/_/
                              
==============================
Running with Kanela,the Kamon Instrumentation Agent ::

scala-execution-context-global-18 10:53:14.582 [INFO ] com.company.logging.Poc$ - Some info logs ! (0) - MDC[kamonSpanId=0b64e07a7ec37656,kamonTraceId=c347442849cccd86,kamonSpanName=Level 3]

Process finished with exit code 0

使用Kanela的@Loggable方法检测

如何解决使用Kanela的@Loggable方法检测

相关推荐