add initial logback-access-jetty-12 instrumentation

.fossa.yml

@@ -658,6 +658,9 @@ targets:
     - type: gradle
       path: ./
       target: ':instrumentation:log4j:log4j-mdc-1.2:javaagent'
+    - type: gradle
+      path: ./
+      target: ':instrumentation:logback:logback-access-jetty-12.0:javaagent'
     - type: gradle
       path: ./
       target: ':instrumentation:logback:logback-appender-1.0:javaagent'

instrumentation/logback/logback-access-jetty-12.0/javaagent/build.gradle.kts

@@ -0,0 +1,47 @@
+plugins {
+  id("otel.javaagent-instrumentation")
+}
+
+muzzle {
+  pass {
+    group.set("ch.qos.logback.access")
+    module.set("jetty12")
+    versions.set("[2.0.0,)")
+    assertInverse.set(true)
+  }
+}
+
+dependencies {
+  compileOnly("ch.qos.logback.access:jetty12") {
+    version {
+      strictly("2.0.0")
+    }
+  }
+  compileOnly("ch.qos.logback.access:logback-access-common:2.0.4")
+  compileOnly("org.slf4j:slf4j-api") {
+    version {
+      strictly("1.5.8")
+    }
+  }
+
+  if (findProperty("testLatestDeps") as Boolean) {
+    testImplementation("ch.qos.logback.access:jetty12:latest.release")
+  } else {
+    testImplementation("ch.qos.logback.access:jetty12") {
+      version {
+        strictly("2.0.0")
+      }
+    }
+    testImplementation("org.slf4j:slf4j-api") {
+      version {
+        strictly("1.7.36")
+      }
+    }
+  }
+
+  compileOnly(project(":javaagent-bootstrap"))
+}
+
+otelJava {
+  minJavaVersionSupported.set(JavaVersion.VERSION_17)
+}

instrumentation/logback/logback-access-jetty-12.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/logback/access/jetty/v12_0/AccessEventMapper.java

@@ -0,0 +1,61 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.logback.access.jetty.v12_0;
+
+import ch.qos.logback.access.common.spi.IAccessEvent;
+import io.opentelemetry.api.logs.LogRecordBuilder;
+import io.opentelemetry.api.logs.LoggerProvider;
+import io.opentelemetry.api.logs.Severity;
+import io.opentelemetry.semconv.ClientAttributes;
+import io.opentelemetry.semconv.HttpAttributes;
+import io.opentelemetry.semconv.ServerAttributes;
+import io.opentelemetry.semconv.UrlAttributes;
+import io.opentelemetry.semconv.UserAgentAttributes;
+import java.net.URI;
+import java.net.URISyntaxException;
+
+public class AccessEventMapper {
+
+  public static final String ACCESS_EVENT_NAME = "access-event";
+
+  @SuppressWarnings({"MethodCanBeStatic", "EmptyCatch"})
+  // MethodCanBeStatic: This method should eventually refer to configs in this class. So it should
+  // not be static.
+  // EmptyCatch: for parsing URI, the input itself is actually one URI, so there is low chance the
+  // exception would be thrown. Even when it actually happened, there is not much we can do here.
+  private void mapLoggingEvent(LogRecordBuilder builder, IAccessEvent accessEvent) {
+    URI uri = null;
+    try {
+      uri = new URI(accessEvent.getRequest().getRequestURL().toString());
+    } catch (URISyntaxException ignored) {
+    }
+
+    builder
+        .setSeverity(Severity.UNDEFINED_SEVERITY_NUMBER)
+        .setEventName(ACCESS_EVENT_NAME)
+        .setAttribute(HttpAttributes.HTTP_REQUEST_METHOD, accessEvent.getMethod())
+        .setAttribute(
+            HttpAttributes.HTTP_RESPONSE_STATUS_CODE, Long.valueOf(accessEvent.getStatusCode()))
+        .setAttribute(ClientAttributes.CLIENT_ADDRESS, accessEvent.getRemoteAddr())
+        .setAttribute(ServerAttributes.SERVER_ADDRESS, accessEvent.getServerName())
+        .setAttribute(
+            UserAgentAttributes.USER_AGENT_ORIGINAL,
+            accessEvent.getRequestHeader("HTTP User-Agent"));
+    if (uri != null) {
+      builder
+          .setAttribute(UrlAttributes.URL_PATH, uri.getPath())
+          .setAttribute(UrlAttributes.URL_SCHEME, uri.getScheme());
+    }
+  }
+
+  public void emit(LoggerProvider loggerProvider, IAccessEvent event) {
+    String instrumentationName = "ROOT";
+    LogRecordBuilder builder =
+        loggerProvider.loggerBuilder(instrumentationName).build().logRecordBuilder();
+    mapLoggingEvent(builder, event);
+    builder.emit();
+  }
+}

instrumentation/logback/logback-access-jetty-12.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/logback/access/jetty/v12_0/LogbackAccessInstrumentation.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.logback.access.jetty.v12_0;
+
+import static io.opentelemetry.javaagent.instrumentation.logback.access.jetty.v12_0.LogbackAccessSingletons.mapper;
+import static net.bytebuddy.matcher.ElementMatchers.isMethod;
+import static net.bytebuddy.matcher.ElementMatchers.isPublic;
+import static net.bytebuddy.matcher.ElementMatchers.named;
+import static net.bytebuddy.matcher.ElementMatchers.takesArguments;
+
+import ch.qos.logback.access.common.spi.IAccessEvent;
+import io.opentelemetry.api.GlobalOpenTelemetry;
+import io.opentelemetry.api.logs.LoggerProvider;
+import io.opentelemetry.javaagent.bootstrap.CallDepth;
+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 LogbackAccessInstrumentation implements TypeInstrumentation {
+  @Override
+  public ElementMatcher<TypeDescription> typeMatcher() {
+    return named("ch.qos.logback.core.spi.AppenderAttachableImpl");
+  }
+
+  @Override
+  public void transform(TypeTransformer transformer) {
+    transformer.applyAdviceToMethod(
+        isMethod().and(isPublic()).and(named("appendLoopOnAppenders")).and(takesArguments(1)),
+        LogbackAccessInstrumentation.class.getName() + "$CallAppendersAdvice");
+  }
+
+  @SuppressWarnings("unused")
+  public static class CallAppendersAdvice {
+
+    @Advice.OnMethodEnter(suppress = Throwable.class)
+    public static void methodEnter(
+        @Advice.Argument(0) Object o, @Advice.Local("otelCallDepth") CallDepth callDepth) {
+      if (o instanceof IAccessEvent event) {
+        // need to track call depth across all loggers in order to avoid double capture when one
+        // logging framework delegates to another
+        callDepth = CallDepth.forClass(LoggerProvider.class);
+        if (callDepth.getAndIncrement() == 0) {
+          mapper().emit(GlobalOpenTelemetry.get().getLogsBridge(), event);
+        }
+      }
+    }
+
+    @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class)
+    public static void methodExit(@Advice.Local("otelCallDepth") CallDepth callDepth) {
+      callDepth.decrementAndGet();
+    }
+  }
+}

instrumentation/logback/logback-access-jetty-12.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/logback/access/jetty/v12_0/LogbackAccessInstrumentationModule.java

@@ -0,0 +1,25 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.logback.access.jetty.v12_0;
+
+import static java.util.Collections.singletonList;
+
+import com.google.auto.service.AutoService;
+import io.opentelemetry.javaagent.extension.instrumentation.InstrumentationModule;
+import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation;
+import java.util.List;
+
+@AutoService(InstrumentationModule.class)
+public class LogbackAccessInstrumentationModule extends InstrumentationModule {
+  public LogbackAccessInstrumentationModule() {
+    super("logback-access-jetty", "logback-access-jetty-12.0");
+  }
+
+  @Override
+  public List<TypeInstrumentation> typeInstrumentations() {
+    return singletonList(new LogbackAccessInstrumentation());
+  }
+}

instrumentation/logback/logback-access-jetty-12.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/logback/access/jetty/v12_0/LogbackAccessSingletons.java

@@ -0,0 +1,20 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.logback.access.jetty.v12_0;
+
+public class LogbackAccessSingletons {
+  private static final AccessEventMapper mapper;
+
+  static {
+    mapper = new AccessEventMapper();
+  }
+
+  public static AccessEventMapper mapper() {
+    return mapper;
+  }
+
+  private LogbackAccessSingletons() {}
+}

instrumentation/logback/logback-access-jetty-12.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/logback/access/jetty/v12_0/JettyServer.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.logback.access.jetty.v12_0;
+
+import ch.qos.logback.access.jetty.RequestLogImpl;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import org.eclipse.jetty.http.HttpFields;
+import org.eclipse.jetty.http.HttpHeader;
+import org.eclipse.jetty.server.Handler;
+import org.eclipse.jetty.server.Request;
+import org.eclipse.jetty.server.Response;
+import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.util.Callback;
+
+public class JettyServer {
+  protected final RequestLogImpl requestLogImpl;
+  protected Handler handler = new BasicHandler();
+  private final int port;
+  Server server;
+  protected String url;
+
+  public JettyServer(RequestLogImpl impl, int port) {
+    requestLogImpl = impl;
+    this.port = port;
+    url = "http://localhost:" + port + "/";
+  }
+
+  public String getName() {
+    return "Jetty Test Setup";
+  }
+
+  public String getUrl() {
+    return url;
+  }
+
+  public void start() throws Exception {
+    server = new Server(port);
+
+    server.setRequestLog(requestLogImpl);
+    configureRequestLogImpl();
+
+    server.setHandler(getRequestHandler());
+    server.start();
+  }
+
+  public void stop() throws Exception {
+    server.stop();
+    server = null;
+  }
+
+  protected void configureRequestLogImpl() {
+    requestLogImpl.start();
+  }
+
+  protected Handler getRequestHandler() {
+    return handler;
+  }
+
+  static class BasicHandler extends Handler.Wrapper {
+
+    @Override
+    public boolean handle(Request request, Response response, Callback callback) throws Exception {
+      HttpFields.Mutable responseHeaders = response.getHeaders();
+      responseHeaders.put(HttpHeader.CONTENT_TYPE, "text/plain; charset=UTF-8");
+
+      byte[] bytes = "hello world".getBytes(StandardCharsets.UTF_8);
+
+      ByteBuffer content = ByteBuffer.wrap(bytes);
+      response.write(true, content, callback);
+      return true;
+    }
+  }
+}

instrumentation/logback/logback-access-jetty-12.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/logback/access/jetty/v12_0/TestAccessLogWithJetty.java

@@ -0,0 +1,82 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.logback.access.jetty.v12_0;
+
+import static io.opentelemetry.javaagent.instrumentation.logback.access.jetty.v12_0.AccessEventMapper.ACCESS_EVENT_NAME;
+import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import ch.qos.logback.access.common.spi.Util;
+import ch.qos.logback.access.jetty.RequestLogImpl;
+import ch.qos.logback.core.testUtil.RandomUtil;
+import io.opentelemetry.api.logs.Severity;
+import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
+import io.opentelemetry.semconv.ClientAttributes;
+import io.opentelemetry.semconv.HttpAttributes;
+import io.opentelemetry.semconv.ServerAttributes;
+import io.opentelemetry.semconv.UrlAttributes;
+import io.opentelemetry.semconv.UserAgentAttributes;
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+class TestAccessLogWithJetty {
+
+  static RequestLogImpl requestLogImpl = new RequestLogImpl();
+  static JettyServer jettyFixture;
+  static String jettyFixtureUrlStr;
+
+  static final int RANDOM_SERVER_PORT = RandomUtil.getRandomServerPort();
+
+  @BeforeEach
+  public void startServer() throws Exception {
+    requestLogImpl = new RequestLogImpl();
+    jettyFixture = new JettyServer(requestLogImpl, RANDOM_SERVER_PORT);
+    jettyFixture.start();
+    jettyFixtureUrlStr = jettyFixture.getUrl();
+  }
+
+  @AfterEach
+  public void stopServer() throws Exception {
+    if (jettyFixture != null) {
+      jettyFixture.stop();
+    }
+  }
+
+  @RegisterExtension
+  private static final AgentInstrumentationExtension testing =
+      AgentInstrumentationExtension.create();
+
+  @Test
+  void testT() throws IOException {
+    String path = "12312321";
+    URL url = new URL("http://localhost:" + RANDOM_SERVER_PORT + "/" + path);
+    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
+    connection.setDoInput(true);
+
+    String result = Util.readToString(connection.getInputStream());
+
+    assertEquals("hello world", result);
+
+    testing.waitAndAssertLogRecords(
+        logRecord ->
+            logRecord
+                .hasEventName(ACCESS_EVENT_NAME)
+                .hasSeverity(Severity.UNDEFINED_SEVERITY_NUMBER)
+                .hasAttributesSatisfyingExactly(
+                    equalTo(HttpAttributes.HTTP_REQUEST_METHOD, "GET"),
+                    equalTo(HttpAttributes.HTTP_RESPONSE_STATUS_CODE, Long.valueOf(200)),
+                    equalTo(ClientAttributes.CLIENT_ADDRESS, "127.0.0.1"),
+                    equalTo(ServerAttributes.SERVER_ADDRESS, "localhost"),
+                    equalTo(UserAgentAttributes.USER_AGENT_ORIGINAL, "-"),
+                    equalTo(UrlAttributes.URL_PATH, "/" + path),
+                    equalTo(UrlAttributes.URL_SCHEME, "http")));
+  }
+}

settings.gradle.kts

@@ -390,6 +390,7 @@ include(":instrumentation:log4j:log4j-context-data:log4j-context-data-2.17:javaa
 include(":instrumentation:log4j:log4j-context-data:log4j-context-data-2.17:library-autoconfigure")
 include(":instrumentation:log4j:log4j-context-data:log4j-context-data-common:testing")
 include(":instrumentation:log4j:log4j-mdc-1.2:javaagent")
+include(":instrumentation:logback:logback-access-jetty-12.0:javaagent")
 include(":instrumentation:logback:logback-appender-1.0:javaagent")
 include(":instrumentation:logback:logback-appender-1.0:library")
 include(":instrumentation:logback:logback-mdc-1.0:javaagent")