Split CapturedContext instrumenters (#9778)

make it a specialized version for single probe and keep the previous
one as the fallback when multiple probes need to be instrumented for
the same location.
Introduced SingleCapturedContextIntrumenter and
MultipleCapturedContextInstrumenter based on current
CapturedContextInstrumenter. Introduced specialized version with only
one probe index of methods in DebuggerContext called from the
instrumetnation. Introduced CapturedContextProbe interface and move
some specific methods for LogProbe from ProbeImplementation.
This allow to implement later some optimized version of the
instrumentation which is not the case right now. This for now just a
refactoring for preparing the next ones

Author: jpbempel

dd-java-agent/agent-debugger/debugger-bootstrap/src/main/java/datadog/trace/bootstrap/debugger/CapturedContextProbe.java

@@ -0,0 +1,9 @@
+package datadog.trace.bootstrap.debugger;
+
+public interface CapturedContextProbe {
+  boolean isCaptureSnapshot();
+
+  boolean hasCondition();
+
+  boolean isReadyToCapture();
+}

dd-java-agent/agent-debugger/debugger-bootstrap/src/main/java/datadog/trace/bootstrap/debugger/DebuggerContext.java

@@ -246,7 +246,8 @@ public static DebuggerSpan createSpan(String probeId, String operationName, Stri
   }
 
   /**
-   * tests whether the provided probe Ids are ready for capturing data
+   * tests whether the provided probe Ids are ready for capturing data it allows to skip capture
+   * part if no condition and sampling is returns false
    *
    * @return true if can proceed to capture data
    */
@@ -259,6 +260,22 @@ public static boolean isReadyToCapture(Class<?> callingClass, int... probeIndice
     }
   }
 
+  public static boolean isReadyToCapture(Class<?> callingClass, int probeIndex) {
+    try {
+      ProbeImplementation probeImplementation = resolveProbe(probeIndex);
+      if (probeImplementation == null) {
+        return false;
+      }
+      if (((CapturedContextProbe) probeImplementation).isReadyToCapture()) {
+        return checkAndSetInProbe();
+      }
+      return false;
+    } catch (Exception ex) {
+      LOGGER.debug("Error in isReadyToCapture: ", ex);
+      return false;
+    }
+  }
+
   public static void disableInProbe() {
     IN_PROBE.set(Boolean.FALSE);
   }
@@ -277,7 +294,7 @@ public static boolean checkAndSetInProbe() {
   }
   /**
    * resolve probe details based on probe ids and evaluate the captured context regarding summary &
-   * conditions This is for method probes
+   * conditions. This is for method probes.
    */
   public static void evalContext(
       CapturedContext context,
@@ -310,7 +327,38 @@ public static void evalContext(
   }
 
   /**
-   * resolve probe details based on probe ids, evaluate the captured context regarding summary &
+   * Optimized version of {@link DebuggerContext#evalContext(CapturedContext, Class, long,
+   * MethodLocation, int...)} for single probe
+   */
+  public static void evalContext(
+      CapturedContext context,
+      Class<?> callingClass,
+      long startTimestamp,
+      MethodLocation methodLocation,
+      int probeIndex) {
+    try {
+      ProbeImplementation probeImplementation = resolveProbe(probeIndex);
+      if (probeImplementation == null) {
+        return;
+      }
+      CapturedContext.Status status =
+          context.evaluate(
+              probeImplementation, callingClass.getTypeName(), startTimestamp, methodLocation);
+      boolean needFreeze = status.shouldFreezeContext();
+      // only freeze the context when we have at lest one snapshot probe, and we should send
+      // snapshot
+      if (needFreeze) {
+        Duration timeout =
+            Duration.of(Config.get().getDynamicInstrumentationCaptureTimeout(), ChronoUnit.MILLIS);
+        context.freeze(new TimeoutChecker(timeout));
+      }
+    } catch (Exception ex) {
+      LOGGER.debug("Error in evalContext: ", ex);
+    }
+  }
+
+  /**
+   * resolve probe details based on probe indices, evaluate the captured context regarding summary &
    * conditions and commit snapshot to send it if needed. This is for line probes.
    */
   public static void evalContextAndCommit(
@@ -334,6 +382,26 @@ public static void evalContextAndCommit(
     }
   }
 
+  /**
+   * Optimized version of {@link DebuggerContext#evalContextAndCommit(CapturedContext, Class, int,
+   * int...)} for single probe
+   */
+  public static void evalContextAndCommit(
+      CapturedContext context, Class<?> callingClass, int line, int probeIndex) {
+    // Cannot call the multi probe version here, because it will add a new level for stacktrace
+    // recording
+    try {
+      ProbeImplementation probeImplementation = resolveProbe(probeIndex);
+      if (probeImplementation == null) {
+        return;
+      }
+      context.evaluate(probeImplementation, callingClass.getTypeName(), -1, MethodLocation.DEFAULT);
+      probeImplementation.commit(context, line);
+    } catch (Exception ex) {
+      LOGGER.debug("Error in evalContextAndCommit: ", ex);
+    }
+  }
+
   public static void codeOrigin(int probeIndex) {
     try {
       ProbeImplementation probe = probeResolver.resolve(probeIndex);
@@ -381,6 +449,41 @@ public static void commit(
     }
   }
 
+  /**
+   * Optimized version of {@link DebuggerContext#commit(CapturedContext, CapturedContext, List,
+   * int...)} for single probe
+   */
+  public static void commit(
+      CapturedContext entryContext,
+      CapturedContext exitContext,
+      List<CapturedContext.CapturedThrowable> caughtExceptions,
+      int probeIndex) {
+    // Cannot call the multi probe version here, because it will add a new level for stacktrace
+    // recording
+    try {
+      if (entryContext == CapturedContext.EMPTY_CONTEXT
+          && exitContext == CapturedContext.EMPTY_CONTEXT) {
+        // rate limited
+        return;
+      }
+      CapturedContext.Status entryStatus = entryContext.getStatus(probeIndex);
+      CapturedContext.Status exitStatus = exitContext.getStatus(probeIndex);
+      ProbeImplementation probeImplementation;
+      if (entryStatus.probeImplementation != ProbeImplementation.UNKNOWN
+          && (entryStatus.probeImplementation.getEvaluateAt() == MethodLocation.ENTRY
+              || entryStatus.probeImplementation.getEvaluateAt() == MethodLocation.DEFAULT)) {
+        probeImplementation = entryStatus.probeImplementation;
+      } else if (exitStatus.probeImplementation.getEvaluateAt() == MethodLocation.EXIT) {
+        probeImplementation = exitStatus.probeImplementation;
+      } else {
+        throw new IllegalStateException("no probe details for " + probeIndex);
+      }
+      probeImplementation.commit(entryContext, exitContext, caughtExceptions);
+    } catch (Exception ex) {
+      LOGGER.debug("Error in commit: ", ex);
+    }
+  }
+
   public static void marker() {}
 
   public static void captureCodeOrigin(boolean entry) {

dd-java-agent/agent-debugger/debugger-bootstrap/src/main/java/datadog/trace/bootstrap/debugger/ProbeImplementation.java

@@ -28,10 +28,6 @@ void commit(
 
   MethodLocation getEvaluateAt();
 
-  boolean isCaptureSnapshot();
-
-  boolean hasCondition();
-
   CapturedContext.Status createStatus();
 
   class NoopProbeImplementation implements ProbeImplementation {
@@ -102,16 +98,6 @@ public MethodLocation getEvaluateAt() {
       return evaluateAt;
     }
 
-    @Override
-    public boolean isCaptureSnapshot() {
-      return captureSnapshot;
-    }
-
-    @Override
-    public boolean hasCondition() {
-      return script != null;
-    }
-
     @Override
     public CapturedContext.Status createStatus() {
       return CapturedContext.Status.EMPTY_CAPTURING_STATUS;