dd-trace 5.30.0 → 5.32.0

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

@@ -26,12 +26,7 @@ const {
   TEST_MODULE,
   TEST_MODULE_ID,
   TEST_SUITE,
-  CUCUMBER_IS_PARALLEL,
-  TEST_NAME,
-  DI_ERROR_DEBUG_INFO_CAPTURED,
-  DI_DEBUG_ERROR_SNAPSHOT_ID,
-  DI_DEBUG_ERROR_FILE,
-  DI_DEBUG_ERROR_LINE
+  CUCUMBER_IS_PARALLEL
 } = require('../../dd-trace/src/plugins/util/test')
 const { RESOURCE_NAME } = require('../../../ext/tags')
 const { COMPONENT, ERROR_MESSAGE } = require('../../dd-trace/src/constants')
@@ -50,8 +45,8 @@ const {
 } = require('../../dd-trace/src/ci-visibility/telemetry')
 const id = require('../../dd-trace/src/id')
 
+const BREAKPOINT_HIT_GRACE_PERIOD_MS = 200
 const isCucumberWorker = !!process.env.CUCUMBER_WORKER_ID
-const debuggerParameterPerTest = new Map()
 
 function getTestSuiteTags (testSuiteSpan) {
   const suiteTags = {
@@ -210,7 +205,13 @@ class CucumberPlugin extends CiPlugin {
       this.telemetry.ciVisEvent(TELEMETRY_CODE_COVERAGE_FINISHED, 'suite', { library: 'istanbul' })
     })
 
-    this.addSub('ci:cucumber:test:start', ({ testName, testFileAbsolutePath, testSourceLine, isParallel }) => {
+    this.addSub('ci:cucumber:test:start', ({
+      testName,
+      testFileAbsolutePath,
+      testSourceLine,
+      isParallel,
+      promises
+    }) => {
       const store = storage.getStore()
       const testSuite = getTestSuitePath(testFileAbsolutePath, this.sourceRoot)
       const testSourceFile = getTestSuitePath(testFileAbsolutePath, this.repositoryRoot)
@@ -227,38 +228,30 @@ class CucumberPlugin extends CiPlugin {
 
       this.enter(testSpan, store)
 
-      const debuggerParameters = debuggerParameterPerTest.get(testName)
-
-      if (debuggerParameters) {
-        const spanContext = testSpan.context()
-
-        // TODO: handle race conditions with this.retriedTestIds
-        this.retriedTestIds = {
-          spanId: spanContext.toSpanId(),
-          traceId: spanContext.toTraceId()
-        }
-        const { snapshotId, file, line } = debuggerParameters
-
-        // TODO: should these be added on test:end if and only if the probe is hit?
-        // Sync issues: `hitProbePromise` might be resolved after the test ends
-        testSpan.setTag(DI_ERROR_DEBUG_INFO_CAPTURED, 'true')
-        testSpan.setTag(DI_DEBUG_ERROR_SNAPSHOT_ID, snapshotId)
-        testSpan.setTag(DI_DEBUG_ERROR_FILE, file)
-        testSpan.setTag(DI_DEBUG_ERROR_LINE, line)
+      this.activeTestSpan = testSpan
+      // Time we give the breakpoint to be hit
+      if (promises && this.runningTestProbeId) {
+        promises.hitBreakpointPromise = new Promise((resolve) => {
+          setTimeout(resolve, BREAKPOINT_HIT_GRACE_PERIOD_MS)
+        })
       }
     })
 
-    this.addSub('ci:cucumber:test:retry', ({ isRetry, error }) => {
+    this.addSub('ci:cucumber:test:retry', ({ isFirstAttempt, error }) => {
       const store = storage.getStore()
       const span = store.span
-      if (isRetry) {
+      if (!isFirstAttempt) {
         span.setTag(TEST_IS_RETRY, 'true')
       }
       span.setTag('error', error)
-      if (this.di && error && this.libraryConfig?.isDiEnabled) {
-        const testName = span.context()._tags[TEST_NAME]
-        const debuggerParameters = this.addDiProbe(error)
-        debuggerParameterPerTest.set(testName, debuggerParameters)
+      if (isFirstAttempt && this.di && error && this.libraryConfig?.isDiEnabled) {
+        const probeInformation = this.addDiProbe(error)
+        if (probeInformation) {
+          const { probeId, stackIndex } = probeInformation
+          this.runningTestProbeId = probeId
+          this.testErrorStackIndex = stackIndex
+          // TODO: we're not waiting for setProbePromise to be resolved, so there might be race conditions
+        }
       }
       span.setTag(TEST_STATUS, 'fail')
       span.finish()
@@ -363,6 +356,11 @@ class CucumberPlugin extends CiPlugin {
         if (isCucumberWorker) {
           this.tracer._exporter.flush()
         }
+        this.activeTestSpan = null
+        if (this.runningTestProbeId) {
+          this.removeDiProbe(this.runningTestProbeId)
+          this.runningTestProbeId = null
+        }
       }
     })
 

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

@@ -23,11 +23,7 @@ const {
   JEST_DISPLAY_NAME,
   TEST_IS_RUM_ACTIVE,
   TEST_BROWSER_DRIVER,
-  DI_ERROR_DEBUG_INFO_CAPTURED,
-  DI_DEBUG_ERROR_SNAPSHOT_ID,
-  DI_DEBUG_ERROR_FILE,
-  DI_DEBUG_ERROR_LINE,
-  TEST_NAME
+  getFormattedError
 } = require('../../dd-trace/src/plugins/util/test')
 const { COMPONENT } = require('../../dd-trace/src/constants')
 const id = require('../../dd-trace/src/id')
@@ -44,11 +40,20 @@ const {
 } = require('../../dd-trace/src/ci-visibility/telemetry')
 
 const isJestWorker = !!process.env.JEST_WORKER_ID
-const debuggerParameterPerTest = new Map()
 
 // https://github.com/facebook/jest/blob/d6ad15b0f88a05816c2fe034dd6900d28315d570/packages/jest-worker/src/types.ts#L38
 const CHILD_MESSAGE_END = 2
 
+function withTimeout (promise, timeoutMs) {
+  return new Promise(resolve => {
+    // Set a timeout to resolve after 1s
+    setTimeout(resolve, timeoutMs)
+
+    // Also resolve if the original promise resolves
+    promise.then(resolve)
+  })
+}
+
 class JestPlugin extends CiPlugin {
   static get id () {
     return 'jest'
@@ -260,6 +265,12 @@ class JestPlugin extends CiPlugin {
       })
     })
 
+    this.addSub('ci:jest:worker-report:logs', (logsPayloads) => {
+      JSON.parse(logsPayloads).forEach(({ testConfiguration, logMessage }) => {
+        this.tracer._exporter.exportDiLogs(testConfiguration, logMessage)
+      })
+    })
+
     this.addSub('ci:jest:test-suite:finish', ({ status, errorMessage, error }) => {
       this.testSuiteSpan.setTag(TEST_STATUS, status)
       if (error) {
@@ -308,32 +319,10 @@ class JestPlugin extends CiPlugin {
       const span = this.startTestSpan(test)
 
       this.enter(span, store)
-
-      const { name: testName } = test
-
-      const debuggerParameters = debuggerParameterPerTest.get(testName)
-
-      // If we have a debugger probe, we need to add the snapshot id to the span
-      if (debuggerParameters) {
-        const spanContext = span.context()
-
-        // TODO: handle race conditions with this.retriedTestIds
-        this.retriedTestIds = {
-          spanId: spanContext.toSpanId(),
-          traceId: spanContext.toTraceId()
-        }
-        const { snapshotId, file, line } = debuggerParameters
-
-        // TODO: should these be added on test:end if and only if the probe is hit?
-        // Sync issues: `hitProbePromise` might be resolved after the test ends
-        span.setTag(DI_ERROR_DEBUG_INFO_CAPTURED, 'true')
-        span.setTag(DI_DEBUG_ERROR_SNAPSHOT_ID, snapshotId)
-        span.setTag(DI_DEBUG_ERROR_FILE, file)
-        span.setTag(DI_DEBUG_ERROR_LINE, line)
-      }
+      this.activeTestSpan = span
     })
 
-    this.addSub('ci:jest:test:finish', ({ status, testStartLine }) => {
+    this.addSub('ci:jest:test:finish', ({ status, testStartLine, promises, shouldRemoveProbe }) => {
       const span = storage.getStore().span
       span.setTag(TEST_STATUS, status)
       if (testStartLine) {
@@ -354,20 +343,28 @@ class JestPlugin extends CiPlugin {
 
       span.finish()
       finishAllTraceSpans(span)
+      this.activeTestSpan = null
+      if (shouldRemoveProbe && this.runningTestProbeId) {
+        promises.isProbeRemoved = withTimeout(this.removeDiProbe(this.runningTestProbeId), 2000)
+        this.runningTestProbeId = null
+      }
     })
 
-    this.addSub('ci:jest:test:err', ({ error, willBeRetried, probe, isDiEnabled }) => {
+    this.addSub('ci:jest:test:err', ({ error, shouldSetProbe, promises }) => {
       if (error) {
         const store = storage.getStore()
         if (store && store.span) {
           const span = store.span
           span.setTag(TEST_STATUS, 'fail')
-          span.setTag('error', error)
-          if (willBeRetried && this.di && isDiEnabled) {
-            // if we use numTestExecutions, we have to remove the breakpoint after each execution
-            const testName = span.context()._tags[TEST_NAME]
-            const debuggerParameters = this.addDiProbe(error, probe)
-            debuggerParameterPerTest.set(testName, debuggerParameters)
+          span.setTag('error', getFormattedError(error, this.repositoryRoot))
+          if (shouldSetProbe) {
+            const probeInformation = this.addDiProbe(error)
+            if (probeInformation) {
+              const { probeId, setProbePromise, stackIndex } = probeInformation
+              this.runningTestProbeId = probeId
+              this.testErrorStackIndex = stackIndex
+              promises.isProbeReady = withTimeout(setProbePromise, 2000)
+            }
           }
         }
       }

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

@@ -1,89 +1,21 @@
 'use strict'
 
-const { MEASURED } = require('../../../ext/tags')
-const { storage } = require('../../datadog-core')
-const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+const LangChainTracingPlugin = require('./tracing')
+const LangChainLLMObsPlugin = require('../../dd-trace/src/llmobs/plugins/langchain')
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
 
-const API_KEY = 'langchain.request.api_key'
-const MODEL = 'langchain.request.model'
-const PROVIDER = 'langchain.request.provider'
-const TYPE = 'langchain.request.type'
-
-const LangChainHandler = require('./handlers/default')
-const LangChainChatModelHandler = require('./handlers/language_models/chat_model')
-const LangChainLLMHandler = require('./handlers/language_models/llm')
-const LangChainChainHandler = require('./handlers/chain')
-const LangChainEmbeddingHandler = require('./handlers/embedding')
-
-class LangChainPlugin extends TracingPlugin {
+class LangChainPlugin extends CompositePlugin {
   static get id () { return 'langchain' }
-  static get operation () { return 'invoke' }
-  static get system () { return 'langchain' }
-  static get prefix () {
-    return 'tracing:apm:langchain:invoke'
-  }
-
-  constructor () {
-    super(...arguments)
-
-    const langchainConfig = this._tracerConfig.langchain || {}
-    this.handlers = {
-      chain: new LangChainChainHandler(langchainConfig),
-      chat_model: new LangChainChatModelHandler(langchainConfig),
-      llm: new LangChainLLMHandler(langchainConfig),
-      embedding: new LangChainEmbeddingHandler(langchainConfig),
-      default: new LangChainHandler(langchainConfig)
+  static get plugins () {
+    return {
+      // ordering here is important - the llm observability plugin must come first
+      // so that we can add annotations associated with the span before it finishes.
+      // however, because the tracing plugin uses `bindStart` vs the llmobs' `start`,
+      // the span is guaranteed to be created in the tracing plugin before the llmobs one is called
+      llmobs: LangChainLLMObsPlugin,
+      tracing: LangChainTracingPlugin
     }
   }
-
-  bindStart (ctx) {
-    const { resource, type } = ctx
-    const handler = this.handlers[type]
-
-    const instance = ctx.instance
-    const apiKey = handler.extractApiKey(instance)
-    const provider = handler.extractProvider(instance)
-    const model = handler.extractModel(instance)
-
-    const tags = handler.getSpanStartTags(ctx, provider) || []
-
-    if (apiKey) tags[API_KEY] = apiKey
-    if (provider) tags[PROVIDER] = provider
-    if (model) tags[MODEL] = model
-    if (type) tags[TYPE] = type
-
-    const span = this.startSpan('langchain.request', {
-      service: this.config.service,
-      resource,
-      kind: 'client',
-      meta: {
-        [MEASURED]: 1,
-        ...tags
-      }
-    }, false)
-
-    const store = storage.getStore() || {}
-    ctx.currentStore = { ...store, span }
-
-    return ctx.currentStore
-  }
-
-  asyncEnd (ctx) {
-    const span = ctx.currentStore.span
-
-    const { type } = ctx
-
-    const handler = this.handlers[type]
-    const tags = handler.getSpanEndTags(ctx) || {}
-
-    span.addTags(tags)
-
-    span.finish()
-  }
-
-  getHandler (type) {
-    return this.handlers[type] || this.handlers.default
-  }
 }
 
 module.exports = LangChainPlugin

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

@@ -0,0 +1,89 @@
+'use strict'
+
+const { MEASURED } = require('../../../ext/tags')
+const { storage } = require('../../datadog-core')
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+
+const API_KEY = 'langchain.request.api_key'
+const MODEL = 'langchain.request.model'
+const PROVIDER = 'langchain.request.provider'
+const TYPE = 'langchain.request.type'
+
+const LangChainHandler = require('./handlers/default')
+const LangChainChatModelHandler = require('./handlers/language_models/chat_model')
+const LangChainLLMHandler = require('./handlers/language_models/llm')
+const LangChainChainHandler = require('./handlers/chain')
+const LangChainEmbeddingHandler = require('./handlers/embedding')
+
+class LangChainTracingPlugin extends TracingPlugin {
+  static get id () { return 'langchain' }
+  static get operation () { return 'invoke' }
+  static get system () { return 'langchain' }
+  static get prefix () {
+    return 'tracing:apm:langchain:invoke'
+  }
+
+  constructor () {
+    super(...arguments)
+
+    const langchainConfig = this._tracerConfig.langchain || {}
+    this.handlers = {
+      chain: new LangChainChainHandler(langchainConfig),
+      chat_model: new LangChainChatModelHandler(langchainConfig),
+      llm: new LangChainLLMHandler(langchainConfig),
+      embedding: new LangChainEmbeddingHandler(langchainConfig),
+      default: new LangChainHandler(langchainConfig)
+    }
+  }
+
+  bindStart (ctx) {
+    const { resource, type } = ctx
+    const handler = this.handlers[type]
+
+    const instance = ctx.instance
+    const apiKey = handler.extractApiKey(instance)
+    const provider = handler.extractProvider(instance)
+    const model = handler.extractModel(instance)
+
+    const tags = handler.getSpanStartTags(ctx, provider) || []
+
+    if (apiKey) tags[API_KEY] = apiKey
+    if (provider) tags[PROVIDER] = provider
+    if (model) tags[MODEL] = model
+    if (type) tags[TYPE] = type
+
+    const span = this.startSpan('langchain.request', {
+      service: this.config.service,
+      resource,
+      kind: 'client',
+      meta: {
+        [MEASURED]: 1,
+        ...tags
+      }
+    }, false)
+
+    const store = storage.getStore() || {}
+    ctx.currentStore = { ...store, span }
+
+    return ctx.currentStore
+  }
+
+  asyncEnd (ctx) {
+    const span = ctx.currentStore.span
+
+    const { type } = ctx
+
+    const handler = this.handlers[type]
+    const tags = handler.getSpanEndTags(ctx) || {}
+
+    span.addTags(tags)
+
+    span.finish()
+  }
+
+  getHandler (type) {
+    return this.handlers[type] || this.handlers.default
+  }
+}
+
+module.exports = LangChainTracingPlugin

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

@@ -30,12 +30,7 @@ const {
   TEST_SUITE,
   MOCHA_IS_PARALLEL,
   TEST_IS_RUM_ACTIVE,
-  TEST_BROWSER_DRIVER,
-  TEST_NAME,
-  DI_ERROR_DEBUG_INFO_CAPTURED,
-  DI_DEBUG_ERROR_SNAPSHOT_ID,
-  DI_DEBUG_ERROR_FILE,
-  DI_DEBUG_ERROR_LINE
+  TEST_BROWSER_DRIVER
 } = require('../../dd-trace/src/plugins/util/test')
 const { COMPONENT } = require('../../dd-trace/src/constants')
 const {
@@ -52,8 +47,6 @@ const {
 const id = require('../../dd-trace/src/id')
 const log = require('../../dd-trace/src/log')
 
-const debuggerParameterPerTest = new Map()
-
 function getTestSuiteLevelVisibilityTags (testSuiteSpan) {
   const testSuiteSpanContext = testSuiteSpan.context()
   const suiteTags = {
@@ -192,36 +185,15 @@ class MochaPlugin extends CiPlugin {
       const store = storage.getStore()
       const span = this.startTestSpan(testInfo)
 
-      const { testName } = testInfo
-
-      const debuggerParameters = debuggerParameterPerTest.get(testName)
-
-      if (debuggerParameters) {
-        const spanContext = span.context()
-
-        // TODO: handle race conditions with this.retriedTestIds
-        this.retriedTestIds = {
-          spanId: spanContext.toSpanId(),
-          traceId: spanContext.toTraceId()
-        }
-        const { snapshotId, file, line } = debuggerParameters
-
-        // TODO: should these be added on test:end if and only if the probe is hit?
-        // Sync issues: `hitProbePromise` might be resolved after the test ends
-        span.setTag(DI_ERROR_DEBUG_INFO_CAPTURED, 'true')
-        span.setTag(DI_DEBUG_ERROR_SNAPSHOT_ID, snapshotId)
-        span.setTag(DI_DEBUG_ERROR_FILE, file)
-        span.setTag(DI_DEBUG_ERROR_LINE, line)
-      }
-
       this.enter(span, store)
+      this.activeTestSpan = span
     })
 
     this.addSub('ci:mocha:worker:finish', () => {
       this.tracer._exporter.flush()
     })
 
-    this.addSub('ci:mocha:test:finish', ({ status, hasBeenRetried }) => {
+    this.addSub('ci:mocha:test:finish', ({ status, hasBeenRetried, isLastRetry }) => {
       const store = storage.getStore()
       const span = store?.span
 
@@ -245,6 +217,11 @@ class MochaPlugin extends CiPlugin {
 
         span.finish()
         finishAllTraceSpans(span)
+        this.activeTestSpan = null
+        if (this.di && this.libraryConfig?.isDiEnabled && this.runningTestProbeId && isLastRetry) {
+          this.removeDiProbe(this.runningTestProbeId)
+          this.runningTestProbeId = null
+        }
       }
     })
 
@@ -271,7 +248,7 @@ class MochaPlugin extends CiPlugin {
       }
     })
 
-    this.addSub('ci:mocha:test:retry', ({ isFirstAttempt, willBeRetried, err }) => {
+    this.addSub('ci:mocha:test:retry', ({ isFirstAttempt, willBeRetried, err, test }) => {
       const store = storage.getStore()
       const span = store?.span
       if (span) {
@@ -294,10 +271,15 @@ class MochaPlugin extends CiPlugin {
             browserDriver: spanTags[TEST_BROWSER_DRIVER]
           }
         )
-        if (willBeRetried && this.di && this.libraryConfig?.isDiEnabled) {
-          const testName = span.context()._tags[TEST_NAME]
-          const debuggerParameters = this.addDiProbe(err)
-          debuggerParameterPerTest.set(testName, debuggerParameters)
+        if (isFirstAttempt && willBeRetried && this.di && this.libraryConfig?.isDiEnabled) {
+          const probeInformation = this.addDiProbe(err)
+          if (probeInformation) {
+            const { probeId, stackIndex } = probeInformation
+            this.runningTestProbeId = probeId
+            this.testErrorStackIndex = stackIndex
+            test._ddShouldWaitForHitProbe = true
+            // TODO: we're not waiting for setProbePromise to be resolved, so there might be race conditions
+          }
         }
 
         span.finish()

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

@@ -17,12 +17,7 @@ const {
   TEST_SOURCE_START,
   TEST_IS_NEW,
   TEST_EARLY_FLAKE_ENABLED,
-  TEST_EARLY_FLAKE_ABORT_REASON,
-  TEST_NAME,
-  DI_ERROR_DEBUG_INFO_CAPTURED,
-  DI_DEBUG_ERROR_SNAPSHOT_ID,
-  DI_DEBUG_ERROR_FILE,
-  DI_DEBUG_ERROR_LINE
+  TEST_EARLY_FLAKE_ABORT_REASON
 } = require('../../dd-trace/src/plugins/util/test')
 const { COMPONENT } = require('../../dd-trace/src/constants')
 const {
@@ -36,8 +31,6 @@ const {
 // This is because there's some loss of resolution.
 const MILLISECONDS_TO_SUBTRACT_FROM_FAILED_TEST_DURATION = 5
 
-const debuggerParameterPerTest = new Map()
-
 class VitestPlugin extends CiPlugin {
   static get id () {
     return 'vitest'
@@ -67,7 +60,7 @@ class VitestPlugin extends CiPlugin {
       onDone(isFaulty)
     })
 
-    this.addSub('ci:vitest:test:start', ({ testName, testSuiteAbsolutePath, isRetry, isNew }) => {
+    this.addSub('ci:vitest:test:start', ({ testName, testSuiteAbsolutePath, isRetry, isNew, mightHitProbe }) => {
       const testSuite = getTestSuitePath(testSuiteAbsolutePath, this.repositoryRoot)
       const store = storage.getStore()
 
@@ -88,27 +81,13 @@ class VitestPlugin extends CiPlugin {
         extraTags
       )
 
-      const debuggerParameters = debuggerParameterPerTest.get(testName)
-
-      if (debuggerParameters) {
-        const spanContext = span.context()
-
-        // TODO: handle race conditions with this.retriedTestIds
-        this.retriedTestIds = {
-          spanId: spanContext.toSpanId(),
-          traceId: spanContext.toTraceId()
-        }
-        const { snapshotId, file, line } = debuggerParameters
+      this.enter(span, store)
 
-        // TODO: should these be added on test:end if and only if the probe is hit?
-        // Sync issues: `hitProbePromise` might be resolved after the test ends
-        span.setTag(DI_ERROR_DEBUG_INFO_CAPTURED, 'true')
-        span.setTag(DI_DEBUG_ERROR_SNAPSHOT_ID, snapshotId)
-        span.setTag(DI_DEBUG_ERROR_FILE, file)
-        span.setTag(DI_DEBUG_ERROR_LINE, line)
+      // TODO: there might be multiple tests for which mightHitProbe is true, so activeTestSpan
+      // might be wrongly overwritten.
+      if (mightHitProbe) {
+        this.activeTestSpan = span
       }
-
-      this.enter(span, store)
     })
 
     this.addSub('ci:vitest:test:finish-time', ({ status, task }) => {
@@ -137,15 +116,19 @@ class VitestPlugin extends CiPlugin {
       }
     })
 
-    this.addSub('ci:vitest:test:error', ({ duration, error, willBeRetried, probe, isDiEnabled }) => {
+    this.addSub('ci:vitest:test:error', ({ duration, error, shouldSetProbe, promises }) => {
       const store = storage.getStore()
       const span = store?.span
 
       if (span) {
-        if (willBeRetried && this.di && isDiEnabled) {
-          const testName = span.context()._tags[TEST_NAME]
-          const debuggerParameters = this.addDiProbe(error, probe)
-          debuggerParameterPerTest.set(testName, debuggerParameters)
+        if (shouldSetProbe && this.di) {
+          const probeInformation = this.addDiProbe(error)
+          if (probeInformation) {
+            const { probeId, stackIndex, setProbePromise } = probeInformation
+            this.runningTestProbeId = probeId
+            this.testErrorStackIndex = stackIndex
+            promises.setProbePromise = setProbePromise
+          }
         }
         this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'test', {
           hasCodeowners: !!span.context()._tags[TEST_CODE_OWNERS]
@@ -158,7 +141,7 @@ class VitestPlugin extends CiPlugin {
         if (duration) {
           span.finish(span._startTime + duration - MILLISECONDS_TO_SUBTRACT_FROM_FAILED_TEST_DURATION) // milliseconds
         } else {
-          span.finish() // retries will not have a duration
+          span.finish() // `duration` is empty for retries, so we'll use clock time
         }
         finishAllTraceSpans(span)
       }
@@ -242,6 +225,9 @@ class VitestPlugin extends CiPlugin {
       this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'suite')
       // TODO: too frequent flush - find for method in worker to decrease frequency
       this.tracer._exporter.flush(onFinish)
+      if (this.runningTestProbeId) {
+        this.removeDiProbe(this.runningTestProbeId)
+      }
     })
 
     this.addSub('ci:vitest:test-suite:error', ({ error }) => {

package/packages/dd-trace/src/appsec/iast/analyzers/analyzers.js

@@ -17,6 +17,7 @@ module.exports = {
   SSRF: require('./ssrf-analyzer'),
   TEMPLATE_INJECTION_ANALYZER: require('./template-injection-analyzer'),
   UNVALIDATED_REDIRECT_ANALYZER: require('./unvalidated-redirect-analyzer'),
+  UNTRUSTED_DESERIALIZATION_ANALYZER: require('./untrusted-deserialization-analyzer'),
   WEAK_CIPHER_ANALYZER: require('./weak-cipher-analyzer'),
   WEAK_HASH_ANALYZER: require('./weak-hash-analyzer'),
   WEAK_RANDOMNESS_ANALYZER: require('./weak-randomness-analyzer'),

package/packages/dd-trace/src/appsec/iast/analyzers/code-injection-analyzer.js

@@ -10,6 +10,8 @@ class CodeInjectionAnalyzer extends InjectionAnalyzer {
 
   onConfigure () {
     this.addSub('datadog:eval:call', ({ script }) => this.analyze(script))
+    this.addSub('datadog:vm:run-script:start', ({ code }) => this.analyze(code))
+    this.addSub('datadog:vm:source-text-module:start', ({ code }) => this.analyze(code))
   }
 
   _areRangesVulnerable () {

package/packages/dd-trace/src/appsec/iast/analyzers/untrusted-deserialization-analyzer.js

@@ -0,0 +1,16 @@
+'use strict'
+
+const InjectionAnalyzer = require('./injection-analyzer')
+const { UNTRUSTED_DESERIALIZATION } = require('../vulnerabilities')
+
+class UntrustedDeserializationAnalyzer extends InjectionAnalyzer {
+  constructor () {
+    super(UNTRUSTED_DESERIALIZATION)
+  }
+
+  onConfigure () {
+    this.addSub('datadog:node-serialize:unserialize:start', ({ obj }) => this.analyze(obj))
+  }
+}
+
+module.exports = new UntrustedDeserializationAnalyzer()