fix: use synchronized instead of atomic refs in bridge

Author: daniel-mohedano

dd-java-agent/agent-bootstrap/src/main/java/datadog/trace/bootstrap/Agent.java

@@ -632,7 +632,6 @@ public void execute() {
       }
 
       maybeStartAppSec(scoClass, sco);
-      // start civisibility before debugger to enable Failed Test Replay correctly in headless mode
       maybeStartCiVisibility(instrumentation, scoClass, sco);
       maybeStartLLMObs(instrumentation, scoClass, sco);
       // start debugger before remote config to subscribe to it before starting to poll

internal-api/src/main/java/datadog/trace/api/debugger/DebuggerConfigBridge.java

@@ -1,85 +1,71 @@
 package datadog.trace.api.debugger;
 
 import datadog.trace.api.Config;
-import java.util.concurrent.atomic.AtomicReference;
 import javax.annotation.Nonnull;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 public final class DebuggerConfigBridge {
   private static final Logger LOGGER = LoggerFactory.getLogger(DebuggerConfigBridge.class);
 
-  private static final AtomicReference<DebuggerConfigUpdate> DEFERRED_UPDATE =
-      new AtomicReference<>();
+  private static DebuggerConfigUpdate DEFERRED_UPDATE;
+  private static volatile DebuggerConfigUpdater UPDATER;
 
-  private static final AtomicReference<DebuggerConfigUpdater> UPDATER = new AtomicReference<>();
-
-  public static void updateConfig(DebuggerConfigUpdate update) {
+  public static synchronized void updateConfig(DebuggerConfigUpdate update) {
     if (!update.hasUpdates()) {
       LOGGER.debug("No config update detected, skipping");
       return;
     }
-    DebuggerConfigUpdater updater = UPDATER.get();
-    if (updater != null) {
+    if (UPDATER != null) {
       LOGGER.debug("DebuggerConfigUpdater available, performing update: {}", update);
-      updater.updateConfig(update);
+      UPDATER.updateConfig(update);
     } else {
       LOGGER.debug("DebuggerConfigUpdater not available, deferring update");
-      DEFERRED_UPDATE.updateAndGet(existing -> DebuggerConfigUpdate.coalesce(existing, update));
+      DEFERRED_UPDATE = DebuggerConfigUpdate.coalesce(DEFERRED_UPDATE, update);
     }
   }
 
-  public static void setUpdater(@Nonnull DebuggerConfigUpdater updater) {
-    DebuggerConfigUpdater oldUpdater = UPDATER.getAndSet(updater);
-    if (oldUpdater == null) {
-      LOGGER.debug("DebuggerConfigUpdater set for first time, processing deferred updates");
-      processDeferredUpdate(updater);
+  public static synchronized void setUpdater(@Nonnull DebuggerConfigUpdater updater) {
+    UPDATER = updater;
+    if (DEFERRED_UPDATE != null && DEFERRED_UPDATE.hasUpdates()) {
+      DebuggerConfigUpdate toApply = DEFERRED_UPDATE;
+      DEFERRED_UPDATE = null;
+      LOGGER.debug("Processing deferred update {}", toApply);
+      updater.updateConfig(toApply);
     }
   }
 
   // for testing purposes
   static void reset() {
-    UPDATER.set(null);
-    DEFERRED_UPDATE.set(null);
+    UPDATER = null;
+    DEFERRED_UPDATE = null;
   }
 
   public static boolean isDynamicInstrumentationEnabled() {
-    DebuggerConfigUpdater updater = UPDATER.get();
-    if (updater != null) {
-      return updater.isDynamicInstrumentationEnabled();
+    if (UPDATER != null) {
+      return UPDATER.isDynamicInstrumentationEnabled();
     }
     return Config.get().isDynamicInstrumentationEnabled();
   }
 
   public static boolean isExceptionReplayEnabled() {
-    DebuggerConfigUpdater updater = UPDATER.get();
-    if (updater != null) {
-      return updater.isExceptionReplayEnabled();
+    if (UPDATER != null) {
+      return UPDATER.isExceptionReplayEnabled();
     }
     return Config.get().isDebuggerExceptionEnabled();
   }
 
   public static boolean isCodeOriginEnabled() {
-    DebuggerConfigUpdater updater = UPDATER.get();
-    if (updater != null) {
-      return updater.isCodeOriginEnabled();
+    if (UPDATER != null) {
+      return UPDATER.isCodeOriginEnabled();
     }
     return Config.get().isDebuggerCodeOriginEnabled();
   }
 
   public static boolean isDistributedDebuggerEnabled() {
-    DebuggerConfigUpdater updater = UPDATER.get();
-    if (updater != null) {
-      return updater.isDistributedDebuggerEnabled();
+    if (UPDATER != null) {
+      return UPDATER.isDistributedDebuggerEnabled();
     }
     return Config.get().isDistributedDebuggerEnabled();
   }
-
-  private static void processDeferredUpdate(DebuggerConfigUpdater updater) {
-    DebuggerConfigUpdate deferredUpdate = DEFERRED_UPDATE.getAndSet(null);
-    if (deferredUpdate != null) {
-      updater.updateConfig(deferredUpdate);
-      LOGGER.debug("Processed deferred update {}", deferredUpdate);
-    }
-  }
 }