Sketch out slf4j bridge

Author: jack-berg

dependencyManagement/build.gradle.kts

@@ -5,7 +5,7 @@ plugins {
 data class DependencySet(val group: String, val version: String, val modules: List<String>)
 
 // this line is managed by .github/scripts/update-sdk-version.sh
-val otelSdkVersion = "1.57.0"
+val otelSdkVersion = "1.58.0-SNAPSHOT"
 val otelContribVersion = "1.52.0-alpha"
 val otelSdkAlphaVersion = otelSdkVersion.replaceFirst("(-SNAPSHOT)?$".toRegex(), "-alpha$1")
 

instrumentation/internal/internal-slf4j-bridge/bootstrap/build.gradle.kts

@@ -0,0 +1,7 @@
+plugins {
+  id("otel.javaagent-bootstrap")
+}
+
+dependencies {
+  compileOnly(project(":javaagent-bootstrap"))
+}

instrumentation/internal/internal-slf4j-bridge/bootstrap/src/main/java/io/opentelemetry/javaagent/bootstrap/logging/Slf4jBridgeInstaller.java

@@ -0,0 +1,17 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.bootstrap.logging;
+
+import io.opentelemetry.javaagent.Slf4jLogRecorder;
+import io.opentelemetry.javaagent.bootstrap.Slf4jBridgeLogRecorderHolder;
+
+public class Slf4jBridgeInstaller {
+  private Slf4jBridgeInstaller() {}
+
+  public static void installSlf4jLogger(Slf4jLogRecorder slf4JLogRecorder) {
+    Slf4jBridgeLogRecorderHolder.initialize(slf4JLogRecorder);
+  }
+}

instrumentation/internal/internal-slf4j-bridge/bootstrap/src/main/java/io/opentelemetry/javaagent/bootstrap/logging/Slf4jBridgeInstallerFlags.java

@@ -0,0 +1,15 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.bootstrap.logging;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public final class Slf4jBridgeInstallerFlags {
+
+  private Slf4jBridgeInstallerFlags() {}
+
+  public static final AtomicBoolean IS_INSTALLED = new AtomicBoolean(false);
+}

instrumentation/internal/internal-slf4j-bridge/javaagent/build.gradle.kts

@@ -0,0 +1,26 @@
+plugins {
+  id("otel.javaagent-instrumentation")
+}
+
+muzzle {
+  pass {
+    group.set("org.slf4j")
+    module.set("slf4j-api")
+    versions.set("[2.0.0,)")
+    assertInverse.set(true)
+  }
+}
+
+val latestDepTest = findProperty("testLatestDeps") as Boolean
+dependencies {
+  bootstrap(project(":instrumentation:internal:internal-slf4j-bridge:bootstrap"))
+
+  compileOnly(project(":javaagent-bootstrap"))
+
+  compileOnly("org.slf4j:slf4j-api") {
+    version {
+      // 2.0.0 introduced fluent API
+      strictly("2.0.0")
+    }
+  }
+}

instrumentation/internal/internal-slf4j-bridge/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/internal/slf4jbridge/LoggerFactoryInstrumentation.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.internal.slf4jbridge;
+
+import static net.bytebuddy.matcher.ElementMatchers.named;
+import static net.bytebuddy.matcher.ElementMatchers.takesArguments;
+
+import io.opentelemetry.javaagent.bootstrap.logging.Slf4jBridgeInstallerFlags;
+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 LoggerFactoryInstrumentation implements TypeInstrumentation {
+
+  @Override
+  public ElementMatcher<TypeDescription> typeMatcher() {
+    return named("org.slf4j.LoggerFactory");
+  }
+
+  @Override
+  public void transform(TypeTransformer transformer) {
+    // once a call to getILoggerFactory() exits we can be certain that slf4j is properly initialized
+    transformer.applyAdviceToMethod(
+        named("getILoggerFactory").and(takesArguments(0)),
+        this.getClass().getName() + "$GetLoggerFactoryAdvice");
+  }
+
+  @SuppressWarnings("unused")
+  public static class GetLoggerFactoryAdvice {
+
+    @Advice.OnMethodExit(suppress = Throwable.class)
+    public static void onExit() {
+      if (Slf4jBridgeInstallerFlags.IS_INSTALLED.compareAndSet(false, true)) {
+        Slf4jLogRecorderImpl.install();
+      }
+    }
+  }
+}

instrumentation/internal/internal-slf4j-bridge/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/internal/slf4jbridge/Slf4jBridgeIgnoredTypesConfigurer.java

@@ -0,0 +1,20 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.internal.slf4jbridge;
+
+import com.google.auto.service.AutoService;
+import io.opentelemetry.javaagent.extension.ignore.IgnoredTypesBuilder;
+import io.opentelemetry.javaagent.extension.ignore.IgnoredTypesConfigurer;
+import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties;
+
+@AutoService(IgnoredTypesConfigurer.class)
+public final class Slf4jBridgeIgnoredTypesConfigurer implements IgnoredTypesConfigurer {
+
+  @Override
+  public void configure(IgnoredTypesBuilder builder, ConfigProperties config) {
+    builder.allowClass("org.slf4j.LoggerFactory");
+  }
+}

instrumentation/internal/internal-slf4j-bridge/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/internal/slf4jbridge/Slf4jBridgeInstrumentationModule.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.internal.slf4jbridge;
+
+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 Slf4jBridgeInstrumentationModule extends InstrumentationModule {
+
+  public Slf4jBridgeInstrumentationModule() {
+    super("internal-slf4j-bridge");
+  }
+
+  @Override
+  public List<TypeInstrumentation> typeInstrumentations() {
+    return singletonList(new LoggerFactoryInstrumentation());
+  }
+}

instrumentation/internal/internal-slf4j-bridge/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/internal/slf4jbridge/Slf4jLogRecorderImpl.java

@@ -0,0 +1,110 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.internal.slf4jbridge;
+
+import io.opentelemetry.api.common.Attributes;
+import io.opentelemetry.api.common.Value;
+import io.opentelemetry.api.logs.LoggerProvider;
+import io.opentelemetry.api.logs.Severity;
+import io.opentelemetry.context.Context;
+import io.opentelemetry.javaagent.Slf4jLogRecorder;
+import io.opentelemetry.javaagent.bootstrap.CallDepth;
+import javax.annotation.Nullable;
+import io.opentelemetry.javaagent.bootstrap.logging.Slf4jBridgeInstaller;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.slf4j.event.Level;
+import org.slf4j.spi.LoggingEventBuilder;
+
+public final class Slf4jLogRecorderImpl implements Slf4jLogRecorder {
+
+  private Slf4jLogRecorderImpl() {}
+
+  public static void install() {
+    Slf4jBridgeInstaller.installSlf4jLogger(new Slf4jLogRecorderImpl());
+  }
+
+  @Override
+  public void record(
+      Context context,
+      String scopeName,
+      @Nullable String eventName,
+      @Nullable Value<?> bodyValue,
+      Attributes attributes,
+      Severity severity) {
+    CallDepth callDepth = CallDepth.forClass(LoggerProvider.class);
+    try {
+      if (callDepth.getAndIncrement() > 0) {
+        return;
+      }
+      recordToSlf4j(scopeName, eventName, bodyValue, attributes, severity);
+    } finally {
+      callDepth.decrementAndGet();
+    }
+  }
+
+  @SuppressWarnings("CheckReturnValue")
+  public static void recordToSlf4j(
+      String scopeName,
+      @Nullable String eventName,
+      @Nullable Value<?> bodyValue,
+      Attributes attributes,
+      Severity severity) {
+    Logger logger = LoggerFactory.getLogger(scopeName);
+    Level level = toSlf4jLevel(severity);
+    if (!logger.isEnabledForLevel(level)) {
+      return;
+    }
+    LoggingEventBuilder builder = logger.atLevel(level);
+    if (bodyValue != null) {
+      builder.setMessage(bodyValue.asString());
+    }
+    attributes.forEach((key, value) -> builder.addKeyValue(key.getKey(), value));
+
+    // append event_name last to take priority over attributes
+    if (eventName != null) {
+      builder.addKeyValue("event_name", eventName);
+    }
+    builder.log();
+  }
+
+  private static Level toSlf4jLevel(Severity severity) {
+    switch (severity) {
+      case TRACE:
+      case TRACE2:
+      case TRACE3:
+      case TRACE4:
+        return Level.TRACE;
+      case DEBUG:
+      case DEBUG2:
+      case DEBUG3:
+      case DEBUG4:
+        return Level.DEBUG;
+      case INFO:
+      case INFO2:
+      case INFO3:
+      case INFO4:
+        return Level.INFO;
+      case WARN:
+      case WARN2:
+      case WARN3:
+      case WARN4:
+        return Level.WARN;
+      case ERROR:
+      case ERROR2:
+      case ERROR3:
+      case ERROR4:
+      case FATAL:
+      case FATAL2:
+      case FATAL3:
+      case FATAL4:
+        return Level.ERROR;
+      case UNDEFINED_SEVERITY_NUMBER:
+        return Level.INFO;
+    }
+    throw new IllegalArgumentException("Unknown severity: " + severity);
+  }
+}

instrumentation/internal/internal-slf4j-bridge/metadata.yaml

@@ -0,0 +1 @@
+classification: internal