Convert all logging statements from slf4j to jul - part 1 (open-telem…

…etry#5628)

* Convert all logging statements from slf4j to jul - part 1

* fix tests

* use placeholders

* fixed all comments, added static imports for Level

conventions/src/main/kotlin/otel.javaagent-testing.gradle.kts

@@ -11,7 +11,6 @@ evaluationDependsOn(":testing:agent-for-testing")
 dependencies {
   annotationProcessor("com.google.auto.service:auto-service")
   compileOnly("com.google.auto.service:auto-service")
-  compileOnly("org.slf4j:slf4j-api")
 
   testImplementation("org.testcontainers:testcontainers")
 }

instrumentation-api-annotation-support/build.gradle.kts

@@ -13,8 +13,6 @@ dependencies {
   api("io.opentelemetry:opentelemetry-api")
   api("io.opentelemetry:opentelemetry-semconv")
 
-  implementation("org.slf4j:slf4j-api")
-
   compileOnly("com.google.auto.value:auto-value-annotations")
   annotationProcessor("com.google.auto.value:auto-value")
 

instrumentation-api/build.gradle.kts

@@ -17,8 +17,6 @@ dependencies {
   api("io.opentelemetry:opentelemetry-api")
   api("io.opentelemetry:opentelemetry-semconv")
 
-  implementation("org.slf4j:slf4j-api")
-
   compileOnly("com.google.auto.value:auto-value-annotations")
   annotationProcessor("com.google.auto.value:auto-value")
 

instrumentation-api/src/main/java/io/opentelemetry/instrumentation/api/config/Config.java

@@ -6,14 +6,14 @@
 package io.opentelemetry.instrumentation.api.config;
 
 import static java.util.Objects.requireNonNull;
+import static java.util.logging.Level.FINE;
 
 import com.google.auto.value.AutoValue;
 import java.time.Duration;
 import java.util.List;
 import java.util.Map;
+import java.util.logging.Logger;
 import javax.annotation.Nullable;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 /**
  * Represents the global agent configuration consisting of system properties, environment variables,
@@ -28,7 +28,7 @@
  */
 @AutoValue
 public abstract class Config {
-  private static final Logger logger = LoggerFactory.getLogger(Config.class);
+  private static final Logger logger = Logger.getLogger(Config.class.getName());
 
   // lazy initialized, so that javaagent can set it, and library instrumentation can fall back and
   // read system properties
@@ -53,7 +53,7 @@ static Config create(Map<String, String> allProperties) {
    */
   public static void internalInitializeConfig(Config config) {
     if (instance != null) {
-      logger.warn("Config#INSTANCE was already set earlier");
+      logger.warning("Config#INSTANCE was already set earlier");
       return;
     }
     instance = requireNonNull(config);
@@ -166,7 +166,9 @@ private <T> T safeGetTypedProperty(String name, ConfigValueParser<T> parser, T d
       T value = getTypedProperty(name, parser);
       return value == null ? defaultValue : value;
     } catch (RuntimeException t) {
-      logger.debug("Error occurred during parsing: {}", t.getMessage(), t);
+      if (logger.isLoggable(FINE)) {
+        logger.log(FINE, "Error occurred during parsing: " + t.getMessage(), t);
+      }
       return defaultValue;
     }
   }

instrumentation-api/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientMetrics.java

@@ -6,6 +6,7 @@
 package io.opentelemetry.instrumentation.api.instrumenter.http;
 
 import static io.opentelemetry.instrumentation.api.instrumenter.http.TemporaryMetricsView.applyClientDurationView;
+import static java.util.logging.Level.FINE;
 
 import com.google.auto.value.AutoValue;
 import io.opentelemetry.api.common.Attributes;
@@ -17,8 +18,7 @@
 import io.opentelemetry.instrumentation.api.instrumenter.RequestListener;
 import io.opentelemetry.instrumentation.api.instrumenter.RequestMetrics;
 import java.util.concurrent.TimeUnit;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import java.util.logging.Logger;
 
 /**
  * {@link RequestListener} which keeps track of <a
@@ -33,7 +33,7 @@ public final class HttpClientMetrics implements RequestListener {
   private static final ContextKey<State> HTTP_CLIENT_REQUEST_METRICS_STATE =
       ContextKey.named("http-client-request-metrics-state");
 
-  private static final Logger logger = LoggerFactory.getLogger(HttpClientMetrics.class);
+  private static final Logger logger = Logger.getLogger(HttpClientMetrics.class.getName());
 
   /**
    * Returns a {@link RequestMetrics} which can be used to enable recording of {@link
@@ -67,8 +67,10 @@ public Context start(Context context, Attributes startAttributes, long startNano
   public void end(Context context, Attributes endAttributes, long endNanos) {
     State state = context.get(HTTP_CLIENT_REQUEST_METRICS_STATE);
     if (state == null) {
-      logger.debug(
-          "No state present when ending context {}. Cannot record HTTP request metrics.", context);
+      logger.log(
+          FINE,
+          "No state present when ending context {0}. Cannot record HTTP request metrics.",
+          context);
       return;
     }
     duration.record(

instrumentation-api/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpServerMetrics.java

@@ -7,6 +7,7 @@
 
 import static io.opentelemetry.instrumentation.api.instrumenter.http.TemporaryMetricsView.applyActiveRequestsView;
 import static io.opentelemetry.instrumentation.api.instrumenter.http.TemporaryMetricsView.applyServerDurationView;
+import static java.util.logging.Level.FINE;
 
 import com.google.auto.value.AutoValue;
 import io.opentelemetry.api.common.Attributes;
@@ -19,8 +20,7 @@
 import io.opentelemetry.instrumentation.api.instrumenter.RequestListener;
 import io.opentelemetry.instrumentation.api.instrumenter.RequestMetrics;
 import java.util.concurrent.TimeUnit;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import java.util.logging.Logger;
 
 /**
  * {@link RequestListener} which keeps track of <a
@@ -35,7 +35,7 @@ public final class HttpServerMetrics implements RequestListener {
   private static final ContextKey<State> HTTP_SERVER_REQUEST_METRICS_STATE =
       ContextKey.named("http-server-request-metrics-state");
 
-  private static final Logger logger = LoggerFactory.getLogger(HttpServerMetrics.class);
+  private static final Logger logger = Logger.getLogger(HttpServerMetrics.class.getName());
 
   /**
    * Returns a {@link RequestMetrics} which can be used to enable recording of {@link
@@ -79,8 +79,10 @@ public Context start(Context context, Attributes startAttributes, long startNano
   public void end(Context context, Attributes endAttributes, long endNanos) {
     State state = context.get(HTTP_SERVER_REQUEST_METRICS_STATE);
     if (state == null) {
-      logger.debug(
-          "No state present when ending context {}. Cannot reset HTTP request metrics.", context);
+      logger.log(
+          FINE,
+          "No state present when ending context {0}. Cannot record HTTP request metrics.",
+          context);
       return;
     }
     activeRequests.add(-1, applyActiveRequestsView(state.startAttributes()));

instrumentation-api/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/rpc/RpcClientMetrics.java

@@ -6,6 +6,7 @@
 package io.opentelemetry.instrumentation.api.instrumenter.rpc;
 
 import static io.opentelemetry.instrumentation.api.instrumenter.rpc.MetricsView.applyClientView;
+import static java.util.logging.Level.FINE;
 
 import com.google.auto.value.AutoValue;
 import io.opentelemetry.api.common.Attributes;
@@ -17,8 +18,7 @@
 import io.opentelemetry.instrumentation.api.instrumenter.RequestListener;
 import io.opentelemetry.instrumentation.api.instrumenter.RequestMetrics;
 import java.util.concurrent.TimeUnit;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import java.util.logging.Logger;
 
 /**
  * {@link RequestListener} which keeps track of <a
@@ -33,7 +33,7 @@ public final class RpcClientMetrics implements RequestListener {
   private static final ContextKey<RpcClientMetrics.State> RPC_CLIENT_REQUEST_METRICS_STATE =
       ContextKey.named("rpc-client-request-metrics-state");
 
-  private static final Logger logger = LoggerFactory.getLogger(RpcClientMetrics.class);
+  private static final Logger logger = Logger.getLogger(RpcClientMetrics.class.getName());
 
   private final DoubleHistogram clientDurationHistogram;
 
@@ -67,8 +67,10 @@ public Context start(Context context, Attributes startAttributes, long startNano
   public void end(Context context, Attributes endAttributes, long endNanos) {
     State state = context.get(RPC_CLIENT_REQUEST_METRICS_STATE);
     if (state == null) {
-      logger.debug(
-          "No state present when ending context {}. Cannot record RPC request metrics.", context);
+      logger.log(
+          FINE,
+          "No state present when ending context {0}. Cannot record RPC request metrics.",
+          context);
       return;
     }
     clientDurationHistogram.record(

instrumentation-api/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/rpc/RpcServerMetrics.java

@@ -6,6 +6,7 @@
 package io.opentelemetry.instrumentation.api.instrumenter.rpc;
 
 import static io.opentelemetry.instrumentation.api.instrumenter.rpc.MetricsView.applyServerView;
+import static java.util.logging.Level.FINE;
 
 import com.google.auto.value.AutoValue;
 import io.opentelemetry.api.common.Attributes;
@@ -17,8 +18,7 @@
 import io.opentelemetry.instrumentation.api.instrumenter.RequestListener;
 import io.opentelemetry.instrumentation.api.instrumenter.RequestMetrics;
 import java.util.concurrent.TimeUnit;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import java.util.logging.Logger;
 
 /**
  * {@link RequestListener} which keeps track of <a
@@ -33,7 +33,7 @@ public final class RpcServerMetrics implements RequestListener {
   private static final ContextKey<RpcServerMetrics.State> RPC_SERVER_REQUEST_METRICS_STATE =
       ContextKey.named("rpc-server-request-metrics-state");
 
-  private static final Logger logger = LoggerFactory.getLogger(RpcServerMetrics.class);
+  private static final Logger logger = Logger.getLogger(RpcServerMetrics.class.getName());
 
   private final DoubleHistogram serverDurationHistogram;
 
@@ -67,8 +67,10 @@ public Context start(Context context, Attributes startAttributes, long startNano
   public void end(Context context, Attributes endAttributes, long endNanos) {
     State state = context.get(RPC_SERVER_REQUEST_METRICS_STATE);
     if (state == null) {
-      logger.debug(
-          "No state present when ending context {}. Cannot record RPC request metrics.", context);
+      logger.log(
+          FINE,
+          "No state present when ending context {0}. Cannot record RPC request metrics.",
+          context);
       return;
     }
     serverDurationHistogram.record(

instrumentation-api/src/main/java/io/opentelemetry/instrumentation/api/internal/ContextPropagationDebug.java

@@ -5,23 +5,24 @@
 
 package io.opentelemetry.instrumentation.api.internal;
 
+import static java.util.logging.Level.SEVERE;
+
 import io.opentelemetry.api.trace.Span;
 import io.opentelemetry.context.Context;
 import io.opentelemetry.context.ContextKey;
 import io.opentelemetry.instrumentation.api.config.Config;
 import java.util.Iterator;
 import java.util.List;
 import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.logging.Logger;
 import javax.annotation.Nullable;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 /**
  * This class is internal and is hence not for public use. Its APIs are unstable and can change at
  * any time.
  */
 public final class ContextPropagationDebug {
-  private static final Logger logger = LoggerFactory.getLogger(ContextPropagationDebug.class);
+  private static final Logger logger = Logger.getLogger(ContextPropagationDebug.class.getName());
 
   // locations where the context was propagated to another thread (tracking multiple steps is
   // helpful in akka where there is so much recursive async spawning of new work)
@@ -71,10 +72,10 @@ public static void debugContextLeakIfEnabled() {
 
     Context current = Context.current();
     if (current != Context.root()) {
-      logger.error("Unexpected non-root current context found when extracting remote context!");
+      logger.severe("Unexpected non-root current context found when extracting remote context!");
       Span currentSpan = Span.fromContextOrNull(current);
       if (currentSpan != null) {
-        logger.error("It contains this span: {}", currentSpan);
+        logger.log(SEVERE, "It contains this span: {0}", currentSpan);
       }
 
       debugContextPropagation(current);
@@ -121,7 +122,7 @@ private static void debugContextPropagation(Context context) {
           sb.append("\nwhich was propagated from:");
         }
       }
-      logger.error("a context leak was detected. it was propagated from:{}", sb);
+      logger.log(SEVERE, "a context leak was detected. it was propagated from: {0}", sb);
     }
   }
 

instrumentation-api/src/main/java/io/opentelemetry/instrumentation/api/internal/RuntimeVirtualFieldSupplier.java

@@ -7,17 +7,17 @@
 
 import io.opentelemetry.instrumentation.api.cache.Cache;
 import io.opentelemetry.instrumentation.api.field.VirtualField;
+import java.util.logging.Logger;
 import javax.annotation.Nullable;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 /**
  * This class is internal and is hence not for public use. Its APIs are unstable and can change at
  * any time.
  */
 public final class RuntimeVirtualFieldSupplier {
 
-  private static final Logger logger = LoggerFactory.getLogger(RuntimeVirtualFieldSupplier.class);
+  private static final Logger logger =
+      Logger.getLogger(RuntimeVirtualFieldSupplier.class.getName());
 
   /**
    * This class is internal and is hence not for public use. Its APIs are unstable and can change at
@@ -34,7 +34,7 @@ public interface VirtualFieldSupplier {
   public static void set(VirtualFieldSupplier virtualFieldSupplier) {
     // only overwrite the default, cache-based supplier
     if (instance != DEFAULT) {
-      logger.warn(
+      logger.warning(
           "Runtime VirtualField supplier has already been set up, further set() calls are ignored");
       return;
     }

instrumentation-api/src/main/java/io/opentelemetry/instrumentation/api/internal/SupportabilityMetrics.java

@@ -13,23 +13,22 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Consumer;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import java.util.logging.Logger;
 
 /**
  * This class is internal and is hence not for public use. Its APIs are unstable and can change at
  * any time.
  */
 public final class SupportabilityMetrics {
-  private static final Logger logger = LoggerFactory.getLogger(SupportabilityMetrics.class);
+  private static final Logger logger = Logger.getLogger(SupportabilityMetrics.class.getName());
   private final boolean agentDebugEnabled;
   private final Consumer<String> reporter;
 
   private final ConcurrentMap<String, KindCounters> suppressionCounters = new ConcurrentHashMap<>();
   private final ConcurrentMap<String, AtomicLong> counters = new ConcurrentHashMap<>();
 
   private static final SupportabilityMetrics INSTANCE =
-      new SupportabilityMetrics(Config.get(), logger::debug).start();
+      new SupportabilityMetrics(Config.get(), logger::fine).start();
 
   public static SupportabilityMetrics instance() {
     return INSTANCE;

instrumentation-api/src/main/java/io/opentelemetry/instrumentation/api/log/LoggingContextConstants.java

@@ -10,8 +10,6 @@
 /**
  * This class contains several constants used in logging libraries' Mapped Diagnostic Context
  * instrumentations.
- *
- * @see org.slf4j.MDC
  */
 public final class LoggingContextConstants {
   /**

instrumentation/apache-camel-2.20/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/apachecamel/ActiveContextManager.java

@@ -24,20 +24,20 @@
 package io.opentelemetry.javaagent.instrumentation.apachecamel;
 
 import static io.opentelemetry.javaagent.instrumentation.apachecamel.CamelSingletons.instrumenter;
+import static java.util.logging.Level.FINE;
 
 import io.opentelemetry.context.Context;
 import io.opentelemetry.context.Scope;
+import java.util.logging.Logger;
 import javax.annotation.Nullable;
 import org.apache.camel.Exchange;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 /** Utility class for managing active contexts as a stack associated with an exchange. */
 class ActiveContextManager {
 
   private static final String ACTIVE_CONTEXT_PROPERTY = "OpenTelemetry.activeContext";
 
-  private static final Logger logger = LoggerFactory.getLogger(ActiveContextManager.class);
+  private static final Logger logger = Logger.getLogger(ActiveContextManager.class.getName());
 
   private ActiveContextManager() {}
 
@@ -53,7 +53,7 @@ public static void activate(Context context, CamelRequest request) {
     ContextWithScope parent = exchange.getProperty(ACTIVE_CONTEXT_PROPERTY, ContextWithScope.class);
     ContextWithScope contextWithScope = ContextWithScope.activate(parent, context, request);
     exchange.setProperty(ACTIVE_CONTEXT_PROPERTY, contextWithScope);
-    logger.debug("Activated a span: {}", contextWithScope);
+    logger.log(FINE, "Activated a span: {0}", contextWithScope);
   }
 
   /**
@@ -70,7 +70,7 @@ public static Context deactivate(Exchange exchange) {
     if (contextWithScope != null) {
       contextWithScope.deactivate(exchange.getException());
       exchange.setProperty(ACTIVE_CONTEXT_PROPERTY, contextWithScope.getParent());
-      logger.debug("Deactivated span: {}", contextWithScope);
+      logger.log(FINE, "Deactivated span: {0}", contextWithScope);
       return contextWithScope.context;
     }