Update upstream OpenTelemetry agent dependencies to 2.22.0

gradle/libs.versions.toml

@@ -11,11 +11,11 @@ opentelemetryProto = "1.3.2-alpha"
 
 # otel agent, we rely on the '*-alpha' and get the non-alpha dependencies transitively
 # updated from upstream agent with gradle/update-upstream.sh
-opentelemetryJavaagentAlpha = "2.21.0-alpha"
+opentelemetryJavaagentAlpha = "2.22.0-alpha"
 
 # otel contrib
 # updated from upstream agent with gradle/update-upstream.sh
-opentelemetryContribAlpha = "1.51.0-alpha"
+opentelemetryContribAlpha = "1.52.0-alpha"
 
 # otel semconv
 # updated from upstream agent with gradle/update-upstream.sh

internal-logging/src/main/java/co/elastic/otel/logging/ElasticLoggingCustomizer.java

@@ -60,7 +60,9 @@ public void init(EarlyInitAgentConfig earlyConfig) {
   }
 
   @Override
-  public void onStartupSuccess() {}
+  public void onStartupSuccess() {
+    Slf4jInternalLogger.initializationComplete = true;
+  }
 
   @SuppressWarnings("CallToPrintStackTrace")
   @Override

internal-logging/src/main/java/co/elastic/otel/logging/Slf4jInternalLogger.java

@@ -25,37 +25,65 @@
 
 /** Internal logger implementation that delegates to SLF4J */
 public class Slf4jInternalLogger implements InternalLogger {
-  private final Logger logger;
+  private final String name;
+  private volatile Logger logger;
+  static volatile boolean initializationComplete = false;
 
   private Slf4jInternalLogger(String name) {
-    this.logger = LoggerFactory.getLogger(name);
+    this.name = name;
   }
 
   public static InternalLogger create(String name) {
     return new Slf4jInternalLogger(name);
   }
 
+  private Logger getLogger() {
+    if (logger == null) {
+      synchronized (this) {
+        if (logger == null) {
+          logger = LoggerFactory.getLogger(name);
+        }
+      }
+    }
+    return logger;
+  }
+
   @Override
   public boolean isLoggable(Level level) {
+    if (!initializationComplete) {
+      // During startup, only log INFO and above to avoid noise and match typical default behavior
+      return level != Level.TRACE && level != Level.DEBUG;
+    }
     switch (level) {
       case TRACE:
-        return logger.isTraceEnabled();
+        return getLogger().isTraceEnabled();
       case DEBUG:
-        return logger.isDebugEnabled();
+        return getLogger().isDebugEnabled();
       case INFO:
-        return logger.isInfoEnabled();
+        return getLogger().isInfoEnabled();
       case WARN:
-        return logger.isWarnEnabled();
+        return getLogger().isWarnEnabled();
       case ERROR:
-        return logger.isErrorEnabled();
+        return getLogger().isErrorEnabled();
       default:
         throw new IllegalArgumentException("Unsupported level: " + level);
     }
   }
 
   @Override
   public void log(Level level, String s, @Nullable Throwable throwable) {
-    logger.atLevel(toSlf4jLevel(level)).setCause(throwable).log(s);
+    if (!initializationComplete) {
+      if (isLoggable(level)) {
+        // Fallback logging to System.out during startup to avoid ClassCircularityError
+        // Mimic a simple log format: [Thread] LEVEL LoggerName - Message
+        System.out.printf("[%s] %s %s - %s%n", Thread.currentThread().getName(), level, name, s);
+        if (throwable != null) {
+          throwable.printStackTrace(System.out);
+        }
+      }
+      return;
+    }
+    getLogger().atLevel(toSlf4jLevel(level)).setCause(throwable).log(s);
   }
 
   private static org.slf4j.event.Level toSlf4jLevel(Level level) {
@@ -77,6 +105,6 @@ private static org.slf4j.event.Level toSlf4jLevel(Level level) {
 
   @Override
   public String name() {
-    return logger.getName();
+    return name;
   }
 }