Add support for JFinal

.fossa.yml

@@ -187,6 +187,9 @@ targets:
     - type: gradle
       path: ./
       target: ':instrumentation:jdbc:library'
+    - type: gradle
+      path: ./
+      target: ':instrumentation:jfinal-3.6:javaagent'
     - type: gradle
       path: ./
       target: ':instrumentation:jmx-metrics:javaagent'

instrumentation/jfinal-3.6/javaagent/build.gradle.kts

@@ -0,0 +1,29 @@
+plugins {
+  id("otel.javaagent-instrumentation")
+}
+
+muzzle {
+  pass {
+    group.set("com.jfinal")
+    module.set("jfinal")
+    versions.set("[3.6,)")
+    assertInverse.set(true)
+  }
+}
+
+otelJava {
+  // jfinal doesn't work with Java 9+
+  maxJavaVersionForTests.set(JavaVersion.VERSION_1_8)
+}
+
+dependencies {
+  library("com.jfinal:jfinal:3.6")
+  testLibrary("com.jfinal:jetty-server:2019.3")
+  testInstrumentation(project(":instrumentation:jetty:jetty-8.0:javaagent"))
+  testInstrumentation(project(":instrumentation:jetty:jetty-11.0:javaagent"))
+  testInstrumentation(project(":instrumentation:jetty:jetty-common:javaagent"))
+}
+
+tasks.withType<Test>().configureEach {
+  jvmArgs("-Dotel.instrumentation.common.experimental.controller-telemetry.enabled=true")
+}

instrumentation/jfinal-3.6/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jfinal/v3_6/ActionHandlerInstrumentation.java

@@ -0,0 +1,90 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.jfinal.v3_6;
+
+import static io.opentelemetry.javaagent.bootstrap.Java8BytecodeBridge.currentContext;
+import static io.opentelemetry.javaagent.extension.matcher.AgentElementMatchers.hasClassesNamed;
+import static io.opentelemetry.javaagent.instrumentation.jfinal.v3_6.JFinalSingletons.instrumenter;
+import static net.bytebuddy.matcher.ElementMatchers.named;
+import static net.bytebuddy.matcher.ElementMatchers.takesArgument;
+import static net.bytebuddy.matcher.ElementMatchers.takesArguments;
+
+import io.opentelemetry.context.Context;
+import io.opentelemetry.context.Scope;
+import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation;
+import io.opentelemetry.javaagent.extension.instrumentation.TypeTransformer;
+import javax.annotation.Nullable;
+import net.bytebuddy.asm.Advice;
+import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.matcher.ElementMatcher;
+
+public class ActionHandlerInstrumentation implements TypeInstrumentation {
+  @Override
+  public ElementMatcher<ClassLoader> classLoaderOptimization() {
+    return hasClassesNamed("com.jfinal.core.ActionHandler");
+  }
+
+  @Override
+  public ElementMatcher<TypeDescription> typeMatcher() {
+    return named("com.jfinal.core.ActionHandler");
+  }
+
+  @Override
+  public void transform(TypeTransformer transformer) {
+    transformer.applyAdviceToMethod(
+        named("handle")
+            .and(
+                takesArguments(4)
+                    .and(takesArgument(0, String.class))
+                    .and(takesArgument(1, named("javax.servlet.http.HttpServletRequest")))
+                    .and(takesArgument(2, named("javax.servlet.http.HttpServletResponse")))
+                    .and(takesArgument(3, boolean[].class))),
+        this.getClass().getName() + "$HandleAdvice");
+  }
+
+  @SuppressWarnings("unused")
+  public static class HandleAdvice {
+
+    public static class AdviceScope {
+      private final Context context;
+      private final Scope scope;
+
+      public AdviceScope(Context context, Scope scope) {
+        this.context = context;
+        this.scope = scope;
+      }
+
+      @Nullable
+      public static AdviceScope start(Context parentContext) {
+        if (!instrumenter().shouldStart(parentContext, null)) {
+          return null;
+        }
+
+        Context context = instrumenter().start(parentContext, null);
+        return new AdviceScope(context, context.makeCurrent());
+      }
+
+      public void end(@Nullable Throwable throwable) {
+        scope.close();
+        instrumenter().end(context, null, null, throwable);
+      }
+    }
+
+    @Advice.OnMethodEnter(suppress = Throwable.class)
+    public static AdviceScope onEnter() {
+      return AdviceScope.start(currentContext());
+    }
+
+    @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class)
+    public static void stopTraceOnResponse(
+        @Advice.Thrown @Nullable Throwable throwable,
+        @Advice.Enter @Nullable AdviceScope actionScope) {
+      if (actionScope != null) {
+        actionScope.end(throwable);
+      }
+    }
+  }
+}

instrumentation/jfinal-3.6/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jfinal/v3_6/ActionMappingInstrumentation.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.jfinal.v3_6;
+
+import static io.opentelemetry.javaagent.extension.matcher.AgentElementMatchers.hasClassesNamed;
+import static net.bytebuddy.matcher.ElementMatchers.named;
+
+import com.jfinal.core.Action;
+import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation;
+import io.opentelemetry.javaagent.extension.instrumentation.TypeTransformer;
+import net.bytebuddy.asm.Advice;
+import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.matcher.ElementMatcher;
+
+public class ActionMappingInstrumentation implements TypeInstrumentation {
+  @Override
+  public ElementMatcher<ClassLoader> classLoaderOptimization() {
+    return hasClassesNamed("com.jfinal.core.ActionMapping");
+  }
+
+  @Override
+  public ElementMatcher<TypeDescription> typeMatcher() {
+    return named("com.jfinal.core.ActionMapping");
+  }
+
+  @Override
+  public void transform(TypeTransformer transformer) {
+    transformer.applyAdviceToMethod(
+        named("getAction"), this.getClass().getName() + "$GetActionAdvice");
+  }
+
+  @SuppressWarnings("unused")
+  public static class GetActionAdvice {
+
+    @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class)
+    public static void exitGetAction(@Advice.Return Action action) {
+      JFinalSingletons.updateSpan(action);
+    }
+  }
+}

instrumentation/jfinal-3.6/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jfinal/v3_6/JFinalInstrumentationModule.java

@@ -0,0 +1,32 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.jfinal.v3_6;
+
+import static io.opentelemetry.javaagent.extension.matcher.AgentElementMatchers.hasClassesNamed;
+
+import com.google.auto.service.AutoService;
+import io.opentelemetry.javaagent.extension.instrumentation.InstrumentationModule;
+import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation;
+import java.util.Arrays;
+import java.util.List;
+import net.bytebuddy.matcher.ElementMatcher;
+
+@AutoService(InstrumentationModule.class)
+public class JFinalInstrumentationModule extends InstrumentationModule {
+  public JFinalInstrumentationModule() {
+    super("jfinal", "jfinal-3.6");
+  }
+
+  @Override
+  public ElementMatcher.Junction<ClassLoader> classLoaderMatcher() {
+    return hasClassesNamed("com.jfinal.core.ActionMapping");
+  }
+
+  @Override
+  public List<TypeInstrumentation> typeInstrumentations() {
+    return Arrays.asList(new ActionMappingInstrumentation(), new ActionHandlerInstrumentation());
+  }
+}

instrumentation/jfinal-3.6/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jfinal/v3_6/JFinalSingletons.java

@@ -0,0 +1,64 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.jfinal.v3_6;
+
+import com.jfinal.core.Action;
+import com.jfinal.render.JsonRender;
+import io.opentelemetry.api.GlobalOpenTelemetry;
+import io.opentelemetry.context.Context;
+import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter;
+import io.opentelemetry.instrumentation.api.semconv.http.HttpServerRoute;
+import io.opentelemetry.instrumentation.api.semconv.http.HttpServerRouteSource;
+import io.opentelemetry.javaagent.bootstrap.internal.ExperimentalConfig;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+public final class JFinalSingletons {
+
+  private static final Logger logger = Logger.getLogger(JFinalSingletons.class.getName());
+
+  private static final String SPAN_NAME = "jfinal.handle";
+  private static final Instrumenter<Void, Void> INSTRUMENTER =
+      Instrumenter.<Void, Void>builder(
+              GlobalOpenTelemetry.get(), "io.opentelemetry.jfinal-3.6", s -> SPAN_NAME)
+          .setEnabled(ExperimentalConfig.get().controllerTelemetryEnabled())
+          .buildInstrumenter();
+
+  static {
+    // see https://github.com/open-telemetry/opentelemetry-java-instrumentation/issues/11465
+    excludeOtAttrs();
+  }
+
+  public static Instrumenter<Void, Void> instrumenter() {
+    return INSTRUMENTER;
+  }
+
+  public static void updateSpan(Action action) {
+    if (action == null) {
+      return;
+    }
+    String route = action.getActionKey();
+    if (route == null) {
+      return;
+    }
+    Context context = Context.current();
+    HttpServerRoute.update(context, HttpServerRouteSource.CONTROLLER, route);
+  }
+
+  private static void excludeOtAttrs() {
+    try {
+      JsonRender.addExcludedAttrs(
+          "io.opentelemetry.javaagent.instrumentation.servlet.ServletHelper.AsyncListenerResponse",
+          "io.opentelemetry.javaagent.instrumentation.servlet.ServletHelper.Context",
+          "trace_id",
+          "span_id");
+    } catch (Throwable t) {
+      logger.log(Level.INFO, "exclude failed", t);
+    }
+  }
+
+  private JFinalSingletons() {}
+}

instrumentation/jfinal-3.6/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/jfinal/JFinalTest.java

@@ -0,0 +1,107 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.jfinal;
+
+import static io.opentelemetry.api.trace.SpanKind.INTERNAL;
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.NOT_FOUND;
+import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.REDIRECT;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.jfinal.core.JFinalFilter;
+import io.opentelemetry.api.common.Attributes;
+import io.opentelemetry.api.trace.SpanKind;
+import io.opentelemetry.instrumentation.api.internal.HttpConstants;
+import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
+import io.opentelemetry.instrumentation.testing.junit.http.AbstractHttpServerTest;
+import io.opentelemetry.instrumentation.testing.junit.http.HttpServerInstrumentationExtension;
+import io.opentelemetry.instrumentation.testing.junit.http.HttpServerTestOptions;
+import io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint;
+import io.opentelemetry.sdk.testing.assertj.SpanDataAssert;
+import java.util.EnumSet;
+import javax.servlet.DispatcherType;
+import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.servlet.FilterHolder;
+import org.eclipse.jetty.servlet.ServletContextHandler;
+import org.eclipse.jetty.servlet.ServletHandler;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+public class JFinalTest extends AbstractHttpServerTest<Server> {
+
+  @RegisterExtension
+  static final InstrumentationExtension testing = HttpServerInstrumentationExtension.forAgent();
+
+  @Override
+  protected void configure(HttpServerTestOptions options) {
+    // In the redirection scenario, the current test case fails to pass.
+    // Modifying the logic of AbstractHttpServerTest to address this would
+    // entail significant risk; therefore, we will temporarily skip validation
+    // for this scenario.
+    //
+    // actual span relationship:          expecting span relationship
+    // GET /redirect                      GET /redirect
+    // |---jfinal.handle                  |---jfinal.handle
+    //      |---controller                     |---controller
+    //      |---Response.sendRedirect                |---Response.sendRedirect
+    //
+    options.setTestRedirect(false);
+    options.setHasHandlerSpan(unused -> true);
+    options.setExpectedHttpRoute(
+        (endpoint, method) -> {
+          if (endpoint == ServerEndpoint.PATH_PARAM) {
+            return "/path/123/param";
+          }
+          if (HttpConstants._OTHER.equals(method)) {
+            return endpoint.getPath();
+          }
+          if (NOT_FOUND.equals(endpoint)) {
+            return "/*";
+          }
+          return expectedHttpRoute(endpoint, method);
+        });
+  }
+
+  @Override
+  protected Server setupServer() throws Exception {
+    Server server = new Server(port);
+
+    ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
+    context.setContextPath("/");
+    ServletHandler handler = new ServletHandler();
+
+    FilterHolder fh =
+        handler.addFilterWithMapping(
+            JFinalFilter.class.getName(), "/*", EnumSet.of(DispatcherType.REQUEST));
+    fh.setInitParameter("configClass", TestConfig.class.getName());
+
+    context.addFilter(fh, "/*", EnumSet.of(DispatcherType.REQUEST));
+    context.insertHandler(handler);
+    server.setHandler(context);
+    server.start();
+    return server;
+  }
+
+  @Override
+  protected void stopServer(Server server) throws Exception {
+    server.stop();
+  }
+
+  @Override
+  protected SpanDataAssert assertResponseSpan(
+      SpanDataAssert span, String method, ServerEndpoint endpoint) {
+    if (endpoint == REDIRECT) {
+      span.satisfies(spanData -> assertThat(spanData.getName()).endsWith(".sendRedirect"));
+    }
+    span.hasKind(SpanKind.INTERNAL).hasAttributesSatisfying(Attributes::isEmpty);
+    return span;
+  }
+
+  @Override
+  public SpanDataAssert assertHandlerSpan(
+      SpanDataAssert span, String method, ServerEndpoint endpoint) {
+    span.hasName("jfinal.handle").hasKind(INTERNAL);
+    return span;
+  }
+}