dd-trace 5.110.0 → 5.112.0

package/packages/datadog-plugin-ai/src/index.js

@@ -5,7 +5,7 @@ const VercelAILLMObsPlugin = require('../../dd-trace/src/llmobs/plugins/ai')
 const VercelAITracingPlugin = require('./tracing')
 
 class VercelAIPlugin extends CompositePlugin {
-  static get id () { return 'ai' }
+  static id = 'ai'
   static get plugins () {
     return {
       llmobs: VercelAILLMObsPlugin,

package/packages/datadog-plugin-ai/src/tracing.js

@@ -1,10 +1,11 @@
 'use strict'
 
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
 const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
-const { getModelProvider } = require('./utils')
+const { getModelProvider, parseModelProvider } = require('./utils')
 
-class VercelAITracingPlugin extends TracingPlugin {
-  static id = 'ai'
+class DdTelemetryPlugin extends TracingPlugin {
+  static id = 'ai_tracing_dd_telemetry'
   static prefix = 'tracing:dd-trace:vercel-ai'
 
   bindStart (ctx) {
@@ -30,4 +31,66 @@ class VercelAITracingPlugin extends TracingPlugin {
   }
 }
 
+class VercelAiTelemetryPlugin extends TracingPlugin {
+  static id = 'ai_tracing_vercel_telemetry'
+  static prefix = 'tracing:ai:telemetry'
+
+  #streamedCalls = new Set()
+
+  constructor () {
+    super(...arguments)
+
+    this.addSub('dd-trace:vercel-ai:chunk', ({ ctx, chunk, done }) => {
+      ctx.streamConsumed = done
+    })
+  }
+
+  bindStart (ctx) {
+    const { type: name, event } = ctx
+    const model = event.modelId
+    const modelProvider = parseModelProvider(event.provider, model)
+
+    let isStream = this.#streamedCalls.has(event.callId)
+    if (name.includes('stream')) {
+      this.#streamedCalls.add(event.callId)
+      isStream = true
+
+      ctx.streamConsumed = false
+    }
+
+    ctx.isStream = isStream
+
+    this.startSpan(name, {
+      meta: {
+        'resource.name': event.functionId ?? name,
+        'ai.request.model': model,
+        'ai.request.model_provider': modelProvider,
+      },
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  asyncEnd (ctx) {
+    // check if isStreamed and stream resolved
+    // this event will fire multiple times for the same channel
+    if (ctx.isStream && ctx.result?.stream && !ctx.streamConsumed) return
+
+    if (ctx.type?.includes('stream')) {
+      this.#streamedCalls.delete(ctx.event?.callId)
+    }
+
+    const span = ctx.currentStore?.span
+    span?.finish()
+  }
+}
+
+class VercelAITracingPlugin extends CompositePlugin {
+  static id = 'ai_tracing'
+  static plugins = {
+    dd: DdTelemetryPlugin,
+    ai: VercelAiTelemetryPlugin,
+  }
+}
+
 module.exports = VercelAITracingPlugin

package/packages/datadog-plugin-ai/src/utils.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { parseModelId } = require('../../datadog-plugin-aws-sdk/src/services/bedrockruntime/utils')
+const { parseModelId: parseBedrockModelId } = require('../../datadog-plugin-aws-sdk/src/services/bedrockruntime/utils')
 
 /**
  * Get the model provider from the span tags or attributes.
@@ -11,12 +11,24 @@ const { parseModelId } = require('../../datadog-plugin-aws-sdk/src/services/bedr
  */
 function getModelProvider (tags) {
   const modelProviderTag = tags['ai.model.provider']
-  const providerParts = modelProviderTag?.split('.')
+  const modelId = tags['ai.model.id']
+
+  return parseModelProvider(modelProviderTag, modelId)
+}
+
+/**
+ * Parse the model provider from the raw provider string.
+ *
+ * @param {string} rawProvider
+ * @param {string} modelId
+ * @returns {string}
+ */
+function parseModelProvider (rawProvider, modelId) {
+  const providerParts = rawProvider?.split('.')
   const provider = providerParts?.[0]
 
   if (provider === 'amazon-bedrock') {
-    const modelId = tags['ai.model.id']
-    const model = modelId && parseModelId(modelId)
+    const model = modelId && parseBedrockModelId(modelId)
     return model?.modelProvider ?? provider
   }
 
@@ -25,4 +37,5 @@ function getModelProvider (tags) {
 
 module.exports = {
   getModelProvider,
+  parseModelProvider,
 }

package/packages/datadog-plugin-aws-durable-execution-sdk-js/src/client.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const ClientPlugin = require('../../dd-trace/src/plugins/client')
-const { addOpMeta, unwrapDurableError } = require('./util')
+const { addOpMeta, getStepDataForNext, unwrapDurableError } = require('./util')
 
 class AwsDurableExecutionSdkJsClientPlugin extends ClientPlugin {
   static id = 'aws-durable-execution-sdk-js'
@@ -29,7 +29,7 @@ class AwsDurableExecutionSdkJsClientPlugin extends ClientPlugin {
     if (operationName) {
       meta['aws.durable.operation_name'] = operationName
     }
-    addOpMeta(meta, ctx.self)
+    addOpMeta(meta, getStepDataForNext(ctx.self))
 
     this.startSpan(this.operationName(), {
       resource: operationName,

package/packages/datadog-plugin-aws-durable-execution-sdk-js/src/context.js

@@ -2,7 +2,7 @@
 
 const { storage } = require('../../datadog-core')
 const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
-const { addOpMeta, unwrapDurableError } = require('./util')
+const { addOpMeta, getOperationAttempt, getStepDataForNext, unwrapDurableError } = require('./util')
 
 // Span names whose direct children must keep the default resource.
 // These can have very high cardinality which is undesireable in the resource.
@@ -41,12 +41,19 @@ class BaseContextPlugin extends TracingPlugin {
     if (operationName) {
       meta['aws.durable.operation_name'] = operationName
     }
-    addOpMeta(meta, ctx.self)
+    const stepInfo = getStepDataForNext(ctx.self)
+    addOpMeta(meta, stepInfo)
+
+    const metrics = this.constructor.retryable
+      ? { 'aws.durable.operation_attempt': getOperationAttempt(stepInfo.stepData) }
+      : undefined
 
     this.startSpan(spanName, {
       resource,
+      type: this.constructor.type,
       kind: this.constructor.kind,
       meta,
+      metrics,
     }, ctx)
 
     return ctx.currentStore
@@ -71,11 +78,12 @@ class BaseContextPlugin extends TracingPlugin {
   }
 }
 
-function makeContextPlugin (method, spanName) {
+function makeContextPlugin (method, spanName, { retryable }) {
   return class extends BaseContextPlugin {
     static prefix = `tracing:orchestrion:@aws/durable-execution-sdk-js:DurableContextImpl_${method}`
     static settleChannel = `apm:aws-durable-execution-sdk-js:${method}:settle`
     static spanName = spanName
+    static retryable = retryable
   }
 }
 
@@ -83,6 +91,7 @@ class RunInChildContextPlugin extends BaseContextPlugin {
   static prefix = 'tracing:orchestrion:@aws/durable-execution-sdk-js:DurableContextImpl_runInChildContext'
   static settleChannel = 'apm:aws-durable-execution-sdk-js:runInChildContext:settle'
   static spanName = 'aws.durable.child_context'
+  static retryable = false
 
   bindStart (ctx) {
     if (SUPPRESSED_CHILD_CONTEXT_SUBTYPES.has(getRunInChildContextSubType(ctx))) {
@@ -103,12 +112,12 @@ function getRunInChildContextSubType (ctx) {
 }
 
 module.exports = {
-  step: makeContextPlugin('step', 'aws.durable.step'),
-  wait: makeContextPlugin('wait', 'aws.durable.wait'),
-  waitForCondition: makeContextPlugin('waitForCondition', 'aws.durable.wait_for_condition'),
-  waitForCallback: makeContextPlugin('waitForCallback', 'aws.durable.wait_for_callback'),
-  createCallback: makeContextPlugin('createCallback', 'aws.durable.create_callback'),
-  map: makeContextPlugin('map', 'aws.durable.map'),
-  parallel: makeContextPlugin('parallel', 'aws.durable.parallel'),
+  step: makeContextPlugin('step', 'aws.durable.step', { retryable: true }),
+  wait: makeContextPlugin('wait', 'aws.durable.wait', { retryable: false }),
+  waitForCondition: makeContextPlugin('waitForCondition', 'aws.durable.wait_for_condition', { retryable: true }),
+  waitForCallback: makeContextPlugin('waitForCallback', 'aws.durable.wait_for_callback', { retryable: false }),
+  createCallback: makeContextPlugin('createCallback', 'aws.durable.create_callback', { retryable: false }),
+  map: makeContextPlugin('map', 'aws.durable.map', { retryable: false }),
+  parallel: makeContextPlugin('parallel', 'aws.durable.parallel', { retryable: false }),
   runInChildContext: RunInChildContextPlugin,
 }

package/packages/datadog-plugin-aws-durable-execution-sdk-js/src/handler.js

@@ -52,6 +52,7 @@ class AwsDurableExecutionSdkJsHandlerPlugin extends TracingPlugin {
 
     this.startSpan(this.operationName(), {
       resource: handler?.name,
+      type: this.constructor.type,
       kind: this.constructor.kind,
       meta,
     }, ctx)

package/packages/datadog-plugin-aws-durable-execution-sdk-js/src/util.js

@@ -2,27 +2,63 @@
 
 const { createHash } = require('node:crypto')
 
+// A checkpoint in one of these terminal states means the operation is served from the checkpoint
+// on a replay rather than executed: the SDK reloads a SUCCEEDED result or re-raises a FAILED error
+// without running the user function. Both also carry the 1-indexed attempt that reached the terminal
+// state, so both need the same normalization to agree with the 0-indexed live run.
+const REPLAYED_STATUSES = new Set(['SUCCEEDED', 'FAILED'])
+
 /**
- * Populates the replay and operation_id tags for the op the DurableContextImpl is about to
- * run, deriving both from a single `getNextStepId()` call. `aws.durable.replayed` is always
- * set ('true' when the next stepId already has a SUCCEEDED checkpoint entry, i.e. the op will
- * be served from the SDK's checkpoint). `aws.durable.operation_id` — the 16-hex-char MD5 of
- * the stepId, mirroring the SDK's internal calculation — is only added when a stepId exists.
- * @param {Record<string, string>} meta - The span meta/tags object to populate.
+ * Resolves the SDK's next stepId and its checkpoint entry in a single pass, so one span start can
+ * feed both addOpMeta and getOperationAttempt without traversing the SDK internals twice. `stepData`
+ * is undefined when there is no next stepId, or no checkpoint entry exists for it yet.
  * @param {object} [ctxImpl] - The DurableContextImpl about to run the op.
- * @returns {void}
+ * @returns {{ stepId: string | undefined, stepData: object | undefined }}
  */
-function addOpMeta (meta, ctxImpl) {
+function getStepDataForNext (ctxImpl) {
   const stepId = ctxImpl?.getNextStepId?.()
+  const stepData = stepId ? ctxImpl?._executionContext?.getStepData?.(stepId) : undefined
+  return { stepId, stepData }
+}
+
+/**
+ * Populates the replay and operation_id tags from a pre-resolved step lookup (see
+ * getStepDataForNext). `aws.durable.replayed` is always set ('true' when the next stepId already
+ * has a terminal checkpoint entry — SUCCEEDED or FAILED — i.e. the op will be served from the SDK's
+ * checkpoint rather than executed). `aws.durable.operation_id` — the 16-hex-char MD5 of the stepId,
+ * mirroring the SDK's internal calculation — is only added when a stepId exists.
+ * @param {Record<string, string>} meta - The span meta/tags object to populate.
+ * @param {{ stepId?: string, stepData?: object }} stepInfo - Resolved next stepId and checkpoint entry.
+ * @returns {void}
+ */
+function addOpMeta (meta, { stepId, stepData }) {
   if (!stepId) {
     meta['aws.durable.replayed'] = 'false'
     return
   }
-  const stepData = ctxImpl?._executionContext?.getStepData?.(stepId)
-  meta['aws.durable.replayed'] = String(stepData?.Status === 'SUCCEEDED')
+  meta['aws.durable.replayed'] = String(REPLAYED_STATUSES.has(stepData?.Status))
   meta['aws.durable.operation_id'] = createHash('md5').update(stepId).digest('hex').slice(0, 16)
 }
 
+/**
+ * Returns the 0-indexed attempt number for the op (0 original, 1 first retry, …) from a pre-resolved
+ * checkpoint entry (see getStepDataForNext), defaulting to 0 before any checkpoint exists.
+ *
+ * StepDetails.Attempt is indexed differently depending on checkpoint status: on a pending/retry
+ * checkpoint it's the count of prior failed attempts (already 0-indexed), but on a terminal
+ * checkpoint read on replay (SUCCEEDED or FAILED) it's the 1-indexed attempt that reached that
+ * state. We subtract 1 in the terminal case so a replay agrees with the original run, flooring at
+ * 0 since the 1-indexing is observed server behavior, not an SDK guarantee.
+ *
+ * @param {object} [stepData] - The checkpoint entry for the next stepId.
+ * @returns {number}
+ */
+function getOperationAttempt (stepData) {
+  const attempt = stepData?.StepDetails?.Attempt
+  if (!Number.isFinite(attempt)) return 0
+  return REPLAYED_STATUSES.has(stepData.Status) ? Math.max(0, attempt - 1) : attempt
+}
+
 /**
  * The SDK wraps user errors in typed classes (StepError, ChildContextError, etc.); we follow the
  * `.cause` chain to recover the user's original Error. SDK wrappers expose a string `errorType`
@@ -40,4 +76,4 @@ function unwrapDurableError (ctx) {
   return err
 }
 
-module.exports = { addOpMeta, unwrapDurableError }
+module.exports = { addOpMeta, getOperationAttempt, getStepDataForNext, unwrapDurableError }

package/packages/datadog-plugin-child_process/src/index.js

@@ -97,11 +97,22 @@ class ChildProcessPlugin extends TracingPlugin {
   }
 
   asyncEnd (ctx) {
-    const { result } = ctx
+    const { result, error } = ctx
+    let exitCode
+
+    if (result !== null && typeof result === 'object') {
+      // util.promisify(execFile) resolves with a { stdout, stderr } object on
+      // success, where the exit code is 0.
+      exitCode = result.status ?? 0
+    } else if (result === undefined && error !== undefined) {
+      exitCode = error.status ?? error.code ?? 0
+    } else {
+      exitCode = result
+    }
 
     const span = ctx.currentStore?.span || this.activeSpan
 
-    span?.setTag('cmd.exit_code', `${result}`)
+    span?.setTag('cmd.exit_code', `${exitCode}`)
     span?.finish()
 
     return ctx.parentStore

package/packages/datadog-plugin-claude-agent-sdk/src/index.js

@@ -0,0 +1,31 @@
+'use strict'
+
+require('../../datadog-instrumentations/src/claude-agent-sdk')
+
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+const ClaudeAgentSdkLLMObsPlugins = require('../../dd-trace/src/llmobs/plugins/claude-agent-sdk')
+const ClaudeAgentSdkTracingPlugins = require('./tracing')
+
+class ClaudeAgentSdkPlugin extends CompositePlugin {
+  static id = 'claude-agent-sdk'
+
+  static get plugins () {
+    const plugins = {}
+
+    // LLM Obs plugins must be registered before tracing plugins so that
+    // annotations are added to the span before it finishes.
+    // The tracing plugin uses `bindStart` vs the LLM Obs plugin's `start`,
+    // so the span is created in the tracing plugin before the LLM Obs one runs.
+    for (const Plugin of ClaudeAgentSdkLLMObsPlugins) {
+      plugins[Plugin.id] = Plugin
+    }
+
+    for (const Plugin of ClaudeAgentSdkTracingPlugins) {
+      plugins[Plugin.id] = Plugin
+    }
+
+    return plugins
+  }
+}
+
+module.exports = ClaudeAgentSdkPlugin

package/packages/datadog-plugin-claude-agent-sdk/src/tracing.js

@@ -0,0 +1,107 @@
+'use strict'
+
+const { storage } = require('../../datadog-core')
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+const { splitModel } = require('./util')
+
+class QueryTracingPlugin extends TracingPlugin {
+  static id = 'claude_agent_sdk_query'
+  static operation = 'turn'
+  static system = 'claude-agent-sdk'
+  static prefix = 'tracing:orchestrion:@anthropic-ai/claude-agent-sdk:query'
+
+  bindStart (ctx) {
+    this.startSpan('claude_agent_sdk.query', {
+      meta: { 'resource.name': 'claude_agent_sdk.query' },
+      startTime: ctx.startTime,
+    }, ctx)
+    ctx.runInContext = fn => storage('legacy').run(ctx.currentStore, fn)
+    return ctx.currentStore
+  }
+
+  asyncEnd (ctx) {
+    if (!ctx.streamResolved) return
+
+    ctx.currentStore?.span?.finish(ctx.finishTime)
+  }
+}
+
+class StepTracingPlugin extends TracingPlugin {
+  static id = 'claude_agent_sdk_step'
+  static operation = 'step'
+  static system = 'claude-agent-sdk'
+  static prefix = 'tracing:apm:claude-agent-sdk:step'
+
+  bindStart (ctx) {
+    this.startSpan(`step-${ctx.stepIndex}`, {
+      meta: { 'resource.name': 'claude_agent_sdk.step' },
+      startTime: ctx.startTime,
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  end (ctx) {
+    ctx.currentStore?.span?.finish(ctx.finishTime)
+  }
+}
+
+class ToolTracingPlugin extends TracingPlugin {
+  static id = 'claude_agent_sdk_tool'
+  static operation = 'tool'
+  static system = 'claude-agent-sdk'
+  static prefix = 'tracing:apm:claude-agent-sdk:tool'
+
+  bindStart (ctx) {
+    const toolName = ctx.name || 'claude_agent_sdk.tool'
+
+    this.startSpan(toolName, {
+      meta: { 'resource.name': 'claude_agent_sdk.tool' },
+      startTime: ctx.startTime,
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  end (ctx) {
+    const span = ctx.currentStore?.span
+    if (ctx.error) this.addError(ctx.error, span)
+    span?.finish(ctx.finishTime)
+  }
+}
+
+class LlmTracingPlugin extends TracingPlugin {
+  static id = 'claude_agent_sdk_llm'
+  static operation = 'llm'
+  static system = 'claude-agent-sdk'
+  static prefix = 'tracing:apm:claude-agent-sdk:llm'
+
+  bindStart (ctx) {
+    const { model } = ctx
+
+    const { modelName, modelProvider } = splitModel(model)
+    const name = modelName || 'claude_agent_sdk.llm'
+
+    this.startSpan(name, {
+      meta: {
+        'resource.name': 'claude_agent_sdk.llm',
+        'claude-agent-sdk.request.model_name': modelName,
+        'claude-agent-sdk.request.model_provider': modelProvider,
+      },
+      startTime: ctx.startTime,
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  end (ctx) {
+    ctx.currentStore?.span?.finish(ctx.finishTime)
+  }
+}
+
+module.exports = [
+  QueryTracingPlugin,
+  StepTracingPlugin,
+  ToolTracingPlugin,
+  LlmTracingPlugin,
+]

package/packages/datadog-plugin-claude-agent-sdk/src/util.js

@@ -0,0 +1,15 @@
+'use strict'
+
+/**
+ * Parse a model ID string into the model name and provider for claude agent sdk provided model IDs
+ * @param {string} model model id
+ * @returns {{ modelName: string, modelProvider: string }}
+ */
+function splitModel (model) {
+  if (!model) return { modelName: undefined, modelProvider: 'anthropic' }
+  const idx = model.indexOf('/')
+  if (idx === -1) return { modelName: model, modelProvider: 'anthropic' }
+  return { modelName: model.slice(idx + 1), modelProvider: model.slice(0, idx) }
+}
+
+module.exports = { splitModel }

package/packages/datadog-plugin-cucumber/src/index.js

@@ -1,9 +1,5 @@
 'use strict'
 
-// Capture real timers at module load time, before any test can install fake timers.
-const realDateNow = Date.now.bind(Date)
-const realSetTimeout = setTimeout
-
 const CiPlugin = require('../../dd-trace/src/plugins/ci_plugin')
 const { storage } = require('../../datadog-core')
 const { getEnvironmentVariable } = require('../../dd-trace/src/config/helper')
@@ -54,9 +50,6 @@ const {
   TELEMETRY_TEST_SESSION,
 } = require('../../dd-trace/src/ci-visibility/telemetry')
 
-const BREAKPOINT_HIT_GRACE_PERIOD_MS = 200
-const BREAKPOINT_SET_GRACE_PERIOD_MS = 400
-
 const isCucumberWorker = !!getEnvironmentVariable('CUCUMBER_WORKER_ID')
 
 class CucumberPlugin extends CiPlugin {
@@ -130,7 +123,7 @@ class CucumberPlugin extends CiPlugin {
       finishAllTraceSpans(this.testSessionSpan)
       this.telemetry.count(TELEMETRY_TEST_SESSION, {
         provider: this.ciProviderName,
-        autoInjected: !!this._tracerConfig.DD_CIVISIBILITY_AUTO_INSTRUMENTATION_PROVIDER,
+        autoInjected: !!this._tracerConfig.testOptimization.DD_CIVISIBILITY_AUTO_INSTRUMENTATION_PROVIDER,
       })
 
       this.libraryConfig = null
@@ -248,17 +241,14 @@ class CucumberPlugin extends CiPlugin {
       ctx.currentStore = { ...store, span }
 
       this.activeTestSpan = span
-      // Time we give the breakpoint to be hit
       if (promises && this.runningTestProbe) {
-        promises.hitBreakpointPromise = new Promise((resolve) => {
-          realSetTimeout(resolve, BREAKPOINT_HIT_GRACE_PERIOD_MS)
-        })
+        promises.hitBreakpointPromise = this.waitForDiBreakpointHits()
       }
 
       return ctx.currentStore
     })
 
-    this.addSub('ci:cucumber:test:retry', ({ span, isFirstAttempt, error, isAtrRetry }) => {
+    this.addSub('ci:cucumber:test:retry', ({ span, isFirstAttempt, error, isAtrRetry, promises, canWaitForDi }) => {
       if (!isFirstAttempt) {
         span.setTag(TEST_IS_RETRY, 'true')
         if (isAtrRetry) {
@@ -268,18 +258,18 @@ class CucumberPlugin extends CiPlugin {
         }
       }
       span.setTag('error', error)
-      if (isFirstAttempt && this.di && error && this.libraryConfig?.isDiEnabled) {
-        const probeInformation = this.addDiProbe(error)
-        if (probeInformation) {
-          const { file, line, stackIndex } = probeInformation
-          this.runningTestProbe = { file, line }
-          this.testErrorStackIndex = stackIndex
-          const waitUntil = realDateNow() + BREAKPOINT_SET_GRACE_PERIOD_MS
-          while (realDateNow() < waitUntil) {
-            // TODO: To avoid a race condition, we should wait until `probeInformation.setProbePromise` has resolved.
-            // However, Cucumber doesn't have a mechanism for waiting asyncrounously here, so for now, we'll have to
-            // fall back to a fixed syncronous delay.
+      if (canWaitForDi !== false && promises && this.di && error && this.libraryConfig?.isDiEnabled) {
+        if (isFirstAttempt) {
+          const probeInformation = this.addDiProbe(error)
+          if (probeInformation) {
+            const { file, line, stackIndex, setProbePromise } = probeInformation
+            this.runningTestProbe = { file, line }
+            this.testErrorStackIndex = stackIndex
+            this.prepareDiBreakpointHitWait()
+            promises.setProbePromise = this.waitForDiOperation(setProbePromise)
           }
+        } else if (this.runningTestProbe) {
+          this.prepareDiBreakpointHitWait()
         }
       }
       span.setTag(TEST_STATUS, 'fail')
@@ -410,6 +400,7 @@ class CucumberPlugin extends CiPlugin {
           this.tracer._exporter.flush()
         }
         this.activeTestSpan = null
+        this.cancelDiBreakpointHitWait()
         if (this.runningTestProbe) {
           this.removeDiProbe(this.runningTestProbe)
           this.runningTestProbe = null