feat: refactor FTR logic into it's own exceptiondebugger implementation

DataDog · daniel-mohedano · Sep 9, 2025 · Jul 4, 2025 · Jul 4, 2025 · Jul 4, 2025
commit 34cf624cd9ded2d6c402490bd5329f2a613721b8
@@ -6,7 +6,9 @@
 import static datadog.trace.util.AgentThreadFactory.AGENT_THREAD_GROUP;
 
 import com.datadog.debugger.codeorigin.DefaultCodeOriginRecorder;
+import com.datadog.debugger.exception.AbstractExceptionDebugger;
 import com.datadog.debugger.exception.DefaultExceptionDebugger;
+import com.datadog.debugger.exception.FailedTestReplayExceptionDebugger;
 import com.datadog.debugger.sink.DebuggerSink;
 import com.datadog.debugger.sink.ProbeStatusSink;
 import com.datadog.debugger.sink.SnapshotSink;
@@ -62,7 +64,7 @@ public class DebuggerAgent {
   private static volatile ClassNameFilter classNameFilter;
   private static volatile SymDBEnablement symDBEnablement;
   private static volatile ConfigurationUpdater configurationUpdater;
-  private static volatile DefaultExceptionDebugger exceptionDebugger;
+  private static volatile AbstractExceptionDebugger exceptionDebugger;
   private static final AtomicBoolean commonInitDone = new AtomicBoolean();
   static final AtomicBoolean dynamicInstrumentationEnabled = new AtomicBoolean();
   static final AtomicBoolean exceptionReplayEnabled = new AtomicBoolean();
@@ -211,7 +213,13 @@ public static void startExceptionReplay() {
     Config config = Config.get();
     commonInit(config);
     initClassNameFilter();
-    exceptionDebugger = new DefaultExceptionDebugger(configurationUpdater, classNameFilter, config);
+    if (config.isCiVisibilityEnabled()) {
+      exceptionDebugger =
+          new FailedTestReplayExceptionDebugger(configurationUpdater, classNameFilter, config);
+    } else {
+      exceptionDebugger =
+          new DefaultExceptionDebugger(configurationUpdater, classNameFilter, config);
+    }
     DebuggerContext.initExceptionDebugger(exceptionDebugger);
     LOGGER.info("Started Exception Replay");
   }

@@ -0,0 +1,196 @@
+package com.datadog.debugger.exception;
+
+import static com.datadog.debugger.agent.ConfigurationAcceptor.Source.EXCEPTION;
+import static com.datadog.debugger.util.ExceptionHelper.createThrowableMapping;
+
+import com.datadog.debugger.agent.ConfigurationUpdater;
+import com.datadog.debugger.agent.DebuggerAgent;
+import com.datadog.debugger.sink.Snapshot;
+import com.datadog.debugger.util.ExceptionHelper;
+import datadog.trace.bootstrap.debugger.DebuggerContext;
+import datadog.trace.bootstrap.instrumentation.api.AgentSpan;
+import datadog.trace.bootstrap.instrumentation.api.Tags;
+import datadog.trace.util.AgentTaskScheduler;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Deque;
+import java.util.List;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Abstract implementation of {@link DebuggerContext.ExceptionDebugger} that uses {@link
+ * ExceptionProbeManager} to instrument the exception stacktrace and send snapshots.
+ */
+public abstract class AbstractExceptionDebugger implements DebuggerContext.ExceptionDebugger {
+  private static final Logger LOGGER = LoggerFactory.getLogger(AbstractExceptionDebugger.class);
+  public static final String DD_DEBUG_ERROR_PREFIX = "_dd.debug.error.";
+  public static final String DD_DEBUG_ERROR_EXCEPTION_ID = DD_DEBUG_ERROR_PREFIX + "exception_id";
+  public static final String DD_DEBUG_ERROR_EXCEPTION_HASH =
+      DD_DEBUG_ERROR_PREFIX + "exception_hash";
+  public static final String SNAPSHOT_ID_TAG_FMT = DD_DEBUG_ERROR_PREFIX + "%d.snapshot_id";
+
+  private final ExceptionProbeManager exceptionProbeManager;
+  private final ConfigurationUpdater configurationUpdater;
+  private final DebuggerContext.ClassNameFilter classNameFiltering;
+  private final int maxCapturedFrames;
+  private final boolean applyConfigAsync;
+
+  AbstractExceptionDebugger(
+      ExceptionProbeManager exceptionProbeManager,
+      ConfigurationUpdater configurationUpdater,
+      DebuggerContext.ClassNameFilter classNameFiltering,
+      int maxCapturedFrames,
+      boolean applyConfigAsync) {
+    this.exceptionProbeManager = exceptionProbeManager;
+    this.configurationUpdater = configurationUpdater;
+    this.classNameFiltering = classNameFiltering;
+    this.maxCapturedFrames = maxCapturedFrames;
+    this.applyConfigAsync = applyConfigAsync;
+  }
+
+  protected abstract boolean shouldHandleException(Throwable t, AgentSpan span);
+
+  @Override
+  public void handleException(Throwable t, AgentSpan span) {
+    if (!shouldHandleException(t, span)) {
+      if (LOGGER.isDebugEnabled()) {
+        LOGGER.debug("Skip handling error: {}", t.toString());
+      }
+      return;
+    }
+
+    String fingerprint = Fingerprinter.fingerprint(t, classNameFiltering);
+    if (fingerprint == null) {
+      LOGGER.debug("Unable to fingerprint exception", t);
+      return;
+    }
+    Deque<Throwable> chainedExceptions = new ArrayDeque<>();
+    Throwable innerMostException = ExceptionHelper.getInnerMostThrowable(t, chainedExceptions);
+    if (innerMostException == null) {
+      LOGGER.debug("Unable to find root cause of exception");
+      return;
+    }
+    List<Throwable> chainedExceptionsList = new ArrayList<>(chainedExceptions);
+    if (exceptionProbeManager.isAlreadyInstrumented(fingerprint)) {
+      ExceptionProbeManager.ThrowableState state =
+          exceptionProbeManager.getStateByThrowable(innerMostException);
+      if (state == null) {
+        LOGGER.debug("Unable to find state for throwable: {}", innerMostException.toString());
+        return;
+      }
+      processSnapshotsAndSetTags(
+          t, span, state, chainedExceptionsList, fingerprint, maxCapturedFrames);
+      exceptionProbeManager.updateLastCapture(fingerprint);
+    } else {
+      // climb up the exception chain to find the first exception that has instrumented frames
+      Throwable throwable;
+      int chainedExceptionIdx = 0;
+      while ((throwable = chainedExceptions.pollFirst()) != null) {
+        ExceptionProbeManager.CreationResult creationResult =
+            exceptionProbeManager.createProbesForException(
+                throwable.getStackTrace(), chainedExceptionIdx);
+        if (creationResult.probesCreated > 0) {
+          if (!applyConfigAsync) {
+            applyExceptionConfiguration(fingerprint);
+          } else {
+            AgentTaskScheduler.INSTANCE.execute(() -> applyExceptionConfiguration(fingerprint));
+          }
+          break;
+        } else {
+          if (LOGGER.isDebugEnabled()) {
+            LOGGER.debug(
+                "No probe created, nativeFrames={}, thirdPartyFrames={} for exception: {}",
+                creationResult.nativeFrames,
+                creationResult.thirdPartyFrames,
+                ExceptionHelper.foldExceptionStackTrace(throwable));
+          }
+        }
+        chainedExceptionIdx++;
+      }
+    }
+  }
+
+  private void applyExceptionConfiguration(String fingerprint) {
+    configurationUpdater.accept(EXCEPTION, exceptionProbeManager.getProbes());
+    exceptionProbeManager.addFingerprint(fingerprint);
+  }
+
+  protected void addStackFrameTags(
+      AgentSpan span, Snapshot snapshot, int frameIndex, StackTraceElement stackFrame) {
+    String tagName = String.format(SNAPSHOT_ID_TAG_FMT, frameIndex);
+    span.setTag(tagName, snapshot.getId());
+    LOGGER.debug("add tag to span[{}]: {}: {}", span.getSpanId(), tagName, snapshot.getId());
+  }
+
+  private void processSnapshotsAndSetTags(
+      Throwable t,
+      AgentSpan span,
+      ExceptionProbeManager.ThrowableState state,
+      List<Throwable> chainedExceptions,
+      String fingerprint,
+      int maxCapturedFrames) {
+    if (span.getTag(DD_DEBUG_ERROR_EXCEPTION_ID) != null) {
+      LOGGER.debug("Clear previous frame tags");
+      // already set for this span, clear the frame tags
+      span.getTags()
+          .forEach(
+              (k, v) -> {
+                if (k.startsWith(DD_DEBUG_ERROR_PREFIX)) {
+                  span.setTag(k, (String) null);
+                }
+              });
+    }
+    boolean snapshotAssigned = false;
+    List<Snapshot> snapshots = state.getSnapshots();
+    int maxSnapshotSize = Math.min(snapshots.size(), maxCapturedFrames);
+    for (int i = 0; i < maxSnapshotSize; i++) {
+      Snapshot snapshot = snapshots.get(i);
+      Throwable currentEx = chainedExceptions.get(snapshot.getChainedExceptionIdx());
+      int[] mapping = createThrowableMapping(currentEx, t);
+      StackTraceElement[] innerTrace = currentEx.getStackTrace();
+      int currentIdx = innerTrace.length - snapshot.getStack().size();
+      if (!sanityCheckSnapshotAssignment(snapshot, innerTrace, currentIdx)) {
+        continue;
+      }
+      int frameIndex = mapping[currentIdx];
+      if (frameIndex == -1) {
+        continue;
+      }
+
+      addStackFrameTags(span, snapshot, frameIndex, innerTrace[currentIdx]);
+
+      if (!state.isSnapshotSent()) {
+        DebuggerAgent.getSink().addSnapshot(snapshot);
+      }
+      snapshotAssigned = true;
+    }
+    if (snapshotAssigned) {
+      state.markAsSnapshotSent();
+      span.setTag(DD_DEBUG_ERROR_EXCEPTION_ID, state.getExceptionId());
+      LOGGER.debug(
+          "add tag to span[{}]: {}: {}",
+          span.getSpanId(),
+          DD_DEBUG_ERROR_EXCEPTION_ID,
+          state.getExceptionId());
+      span.setTag(Tags.ERROR_DEBUG_INFO_CAPTURED, true);
+      span.setTag(DD_DEBUG_ERROR_EXCEPTION_HASH, fingerprint);
+    }
+  }
+
+  private static boolean sanityCheckSnapshotAssignment(
+      Snapshot snapshot, StackTraceElement[] innerTrace, int currentIdx) {
+    String className = snapshot.getProbe().getLocation().getType();
+    String methodName = snapshot.getProbe().getLocation().getMethod();
+    if (!className.equals(innerTrace[currentIdx].getClassName())
+        || !methodName.equals(innerTrace[currentIdx].getMethodName())) {
+      LOGGER.warn("issue when assigning snapshot to frame: {} {}", className, methodName);
+      return false;
+    }
+    return true;
+  }
+
+  public ExceptionProbeManager getExceptionProbeManager() {
+    return exceptionProbeManager;
+  }
+}