dd-trace 4.51.1 → 4.53.0

package/packages/datadog-instrumentations/src/vitest.js

@@ -117,6 +117,7 @@ function getSortWrapper (sort) {
     let isEarlyFlakeDetectionEnabled = false
     let earlyFlakeDetectionNumRetries = 0
     let isEarlyFlakeDetectionFaulty = false
+    let isDiEnabled = false
     let knownTests = {}
 
     try {
@@ -126,10 +127,12 @@ function getSortWrapper (sort) {
         flakyTestRetriesCount = libraryConfig.flakyTestRetriesCount
         isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
         earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
+        isDiEnabled = libraryConfig.isDiEnabled
       }
     } catch (e) {
       isFlakyTestRetriesEnabled = false
       isEarlyFlakeDetectionEnabled = false
+      isDiEnabled = false
     }
 
     if (isFlakyTestRetriesEnabled && !this.ctx.config.retry && flakyTestRetriesCount > 0) {
@@ -169,6 +172,15 @@ function getSortWrapper (sort) {
       }
     }
 
+    if (isDiEnabled) {
+      try {
+        const workspaceProject = this.ctx.getCoreWorkspaceProject()
+        workspaceProject._provided._ddIsDiEnabled = isDiEnabled
+      } catch (e) {
+        log.warn('Could not send Dynamic Instrumentation configuration to workers.')
+      }
+    }
+
     let testCodeCoverageLinesTotal
 
     if (this.ctx.coverageProvider?.generateCoverage) {
@@ -298,13 +310,16 @@ addHook({
     const testName = getTestName(task)
     let isNew = false
     let isEarlyFlakeDetectionEnabled = false
+    let isDiEnabled = false
 
     try {
       const {
-        _ddIsEarlyFlakeDetectionEnabled
+        _ddIsEarlyFlakeDetectionEnabled,
+        _ddIsDiEnabled
       } = globalThis.__vitest_worker__.providedContext
 
       isEarlyFlakeDetectionEnabled = _ddIsEarlyFlakeDetectionEnabled
+      isDiEnabled = _ddIsDiEnabled
 
       if (isEarlyFlakeDetectionEnabled) {
         isNew = newTasks.has(task)
@@ -316,12 +331,22 @@ addHook({
 
     // We finish the previous test here because we know it has failed already
     if (numAttempt > 0) {
+      const probe = {}
       const asyncResource = taskToAsync.get(task)
       const testError = task.result?.errors?.[0]
       if (asyncResource) {
         asyncResource.runInAsyncScope(() => {
-          testErrorCh.publish({ error: testError })
+          testErrorCh.publish({
+            error: testError,
+            willBeRetried: true,
+            probe,
+            isDiEnabled
+          })
         })
+        // We wait for the probe to be set
+        if (probe.setProbePromise) {
+          await probe.setProbePromise
+        }
       }
     }
 

package/packages/datadog-plugin-avsc/src/schema_iterator.js

@@ -108,10 +108,15 @@ class SchemaExtractor {
       if (!builder.shouldExtractSchema(schemaName, depth)) {
         return false
       }
-      for (const field of schema.fields) {
-        if (!this.extractProperty(field, schemaName, field.name, builder, depth)) {
-          log.warn(`DSM: Unable to extract field with name: ${field.name} from Avro schema with name: ${schemaName}`)
+      if (schema.fields?.[Symbol.iterator]) {
+        for (const field of schema.fields) {
+          if (!this.extractProperty(field, schemaName, field.name, builder, depth)) {
+            log.warn('DSM: Unable to extract field with name: %s from Avro schema with name: %s', field.name,
+              schemaName)
+          }
         }
+      } else {
+        log.warn('DSM: schema.fields is not iterable from Avro schema with name: %s', schemaName)
       }
     }
     return true

package/packages/datadog-plugin-aws-sdk/src/services/dynamodb.js

@@ -1,6 +1,9 @@
 'use strict'
 
 const BaseAwsSdkPlugin = require('../base')
+const log = require('../../../dd-trace/src/log')
+const { DYNAMODB_PTR_KIND, SPAN_POINTER_DIRECTION } = require('../../../dd-trace/src/constants')
+const { extractPrimaryKeys, generatePointerHash } = require('../util')
 
 class DynamoDb extends BaseAwsSdkPlugin {
   static get id () { return 'dynamodb' }
@@ -48,6 +51,157 @@ class DynamoDb extends BaseAwsSdkPlugin {
 
     return tags
   }
+
+  addSpanPointers (span, response) {
+    const request = response?.request
+    const operationName = request?.operation
+
+    const hashes = []
+    switch (operationName) {
+      case 'putItem': {
+        const hash = DynamoDb.calculatePutItemHash(
+          request?.params?.TableName,
+          request?.params?.Item,
+          this.getPrimaryKeyConfig()
+        )
+        if (hash) hashes.push(hash)
+        break
+      }
+      case 'updateItem':
+      case 'deleteItem': {
+        const hash = DynamoDb.calculateHashWithKnownKeys(request?.params?.TableName, request?.params?.Key)
+        if (hash) hashes.push(hash)
+        break
+      }
+      case 'transactWriteItems': {
+        const transactItems = request?.params?.TransactItems || []
+        for (const item of transactItems) {
+          if (item.Put) {
+            const hash =
+              DynamoDb.calculatePutItemHash(item.Put.TableName, item.Put.Item, this.getPrimaryKeyConfig())
+            if (hash) hashes.push(hash)
+          } else if (item.Update || item.Delete) {
+            const operation = item.Update ? item.Update : item.Delete
+            const hash = DynamoDb.calculateHashWithKnownKeys(operation.TableName, operation.Key)
+            if (hash) hashes.push(hash)
+          }
+        }
+        break
+      }
+      case 'batchWriteItem': {
+        const requestItems = request?.params.RequestItems || {}
+        for (const [tableName, operations] of Object.entries(requestItems)) {
+          if (!Array.isArray(operations)) continue
+          for (const operation of operations) {
+            if (operation?.PutRequest) {
+              const hash =
+                DynamoDb.calculatePutItemHash(tableName, operation.PutRequest.Item, this.getPrimaryKeyConfig())
+              if (hash) hashes.push(hash)
+            } else if (operation?.DeleteRequest) {
+              const hash = DynamoDb.calculateHashWithKnownKeys(tableName, operation.DeleteRequest.Key)
+              if (hash) hashes.push(hash)
+            }
+          }
+        }
+        break
+      }
+    }
+
+    for (const hash of hashes) {
+      span.addSpanPointer(DYNAMODB_PTR_KIND, SPAN_POINTER_DIRECTION.DOWNSTREAM, hash)
+    }
+  }
+
+  /**
+   * Parses primary key config from the `DD_AWS_SDK_DYNAMODB_TABLE_PRIMARY_KEYS` env var.
+   * Only runs when needed, and warns when missing or invalid config.
+   * @returns {Object|undefined} Parsed config from env var or undefined if empty/missing/invalid config.
+   */
+  getPrimaryKeyConfig () {
+    if (this.dynamoPrimaryKeyConfig) {
+      // Return cached config if it exists
+      return this.dynamoPrimaryKeyConfig
+    }
+
+    const configStr = this._tracerConfig?.aws?.dynamoDb?.tablePrimaryKeys
+    if (!configStr) {
+      log.warn('Missing DD_AWS_SDK_DYNAMODB_TABLE_PRIMARY_KEYS env variable. ' +
+        'Please add your table\'s primary keys under this env variable.')
+      return
+    }
+
+    try {
+      const parsedConfig = JSON.parse(configStr)
+      const config = {}
+      for (const [tableName, primaryKeys] of Object.entries(parsedConfig)) {
+        if (Array.isArray(primaryKeys) && primaryKeys.length > 0 && primaryKeys.length <= 2) {
+          config[tableName] = new Set(primaryKeys)
+        } else {
+          log.warn(`Invalid primary key configuration for table: ${tableName}.` +
+            'Please fix the DD_AWS_SDK_DYNAMODB_TABLE_PRIMARY_KEYS env var.')
+        }
+      }
+
+      this.dynamoPrimaryKeyConfig = config
+      return config
+    } catch (err) {
+      log.warn('Failed to parse DD_AWS_SDK_DYNAMODB_TABLE_PRIMARY_KEYS:', err.message)
+    }
+  }
+
+  /**
+   * Calculates a hash for DynamoDB PutItem operations using table's configured primary keys.
+   * @param {string} tableName - Name of the DynamoDB table.
+   * @param {Object} item - Complete PutItem item parameter to be put.
+   * @param {Object.<string, Set<string>>} primaryKeyConfig - Mapping of table names to Sets of primary key names
+   *                                                         loaded from DD_AWS_SDK_DYNAMODB_TABLE_PRIMARY_KEYS.
+   * @returns {string|undefined} Hash combining table name and primary key/value pairs, or undefined if unable.
+   */
+  static calculatePutItemHash (tableName, item, primaryKeyConfig) {
+    if (!tableName || !item) {
+      log.debug('Unable to calculate hash because missing required parameters')
+      return
+    }
+    if (!primaryKeyConfig) {
+      log.warn('Missing DD_AWS_SDK_DYNAMODB_TABLE_PRIMARY_KEYS env variable')
+      return
+    }
+    const primaryKeySet = primaryKeyConfig[tableName]
+    if (!primaryKeySet || !(primaryKeySet instanceof Set) || primaryKeySet.size === 0 || primaryKeySet.size > 2) {
+      log.warn(
+        `span pointers: failed to extract PutItem span pointer: table ${tableName} ` +
+        'not found in primary key names or the DD_AWS_SDK_DYNAMODB_TABLE_PRIMARY_KEYS env var was invalid.' +
+        'Please update the env var.'
+      )
+      return
+    }
+    const keyValues = extractPrimaryKeys(primaryKeySet, item)
+    if (keyValues) {
+      return generatePointerHash([tableName, ...keyValues])
+    }
+  }
+
+  /**
+   * Calculates a hash for DynamoDB operations that have keys provided (UpdateItem, DeleteItem).
+   * @param {string} tableName - Name of the DynamoDB table.
+   * @param {Object} keysObject - Object containing primary key/value attributes in DynamoDB format.
+   *                       (e.g., { userId: { S: "123" }, sortKey: { N: "456" } })
+   * @returns {string|undefined} Hash value combining table name and primary key/value pairs, or undefined if unable.
+   *
+   * @example
+   * calculateHashWithKnownKeys('UserTable', { userId: { S: "user123" }, timestamp: { N: "1234567" } })
+   */
+  static calculateHashWithKnownKeys (tableName, keysObject) {
+    if (!tableName || !keysObject) {
+      log.debug('Unable to calculate hash because missing parameters')
+      return
+    }
+    const keyNamesSet = new Set(Object.keys(keysObject))
+    const keyValues = extractPrimaryKeys(keyNamesSet, keysObject)
+    if (keyValues) {
+      return generatePointerHash([tableName, ...keyValues])
+    }
+  }
 }
 
 module.exports = DynamoDb

package/packages/datadog-plugin-aws-sdk/src/services/eventbridge.js

@@ -45,7 +45,7 @@ class EventBridge extends BaseAwsSdkPlugin {
         }
         request.params.Entries[0].Detail = finalData
       } catch (e) {
-        log.error(e)
+        log.error('EventBridge error injecting request', e)
       }
     }
   }

package/packages/datadog-plugin-aws-sdk/src/services/kinesis.js

@@ -97,7 +97,7 @@ class Kinesis extends BaseAwsSdkPlugin {
         parsedAttributes: decodedData._datadog
       }
     } catch (e) {
-      log.error(e)
+      log.error('Kinesis error extracting response', e)
     }
   }
 

package/packages/datadog-plugin-aws-sdk/src/services/lambda.js

@@ -43,7 +43,7 @@ class Lambda extends BaseAwsSdkPlugin {
           const newContextBase64 = Buffer.from(JSON.stringify(clientContext)).toString('base64')
           request.params.ClientContext = newContextBase64
         } catch (err) {
-          log.error(err)
+          log.error('Lambda error injecting request', err)
         }
       }
     }

package/packages/datadog-plugin-aws-sdk/src/services/s3.js

@@ -2,7 +2,7 @@
 
 const BaseAwsSdkPlugin = require('../base')
 const log = require('../../../dd-trace/src/log')
-const { generatePointerHash } = require('../../../dd-trace/src/util')
+const { generatePointerHash } = require('../util')
 const { S3_PTR_KIND, SPAN_POINTER_DIRECTION } = require('../../../dd-trace/src/constants')
 
 class S3 extends BaseAwsSdkPlugin {

package/packages/datadog-plugin-aws-sdk/src/services/sqs.js

@@ -163,7 +163,7 @@ class Sqs extends BaseAwsSdkPlugin {
         return JSON.parse(buffer)
       }
     } catch (e) {
-      log.error(e)
+      log.error('Sqs error parsing DD attributes', e)
     }
   }
 

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

@@ -0,0 +1,92 @@
+'use strict'
+
+const crypto = require('crypto')
+const log = require('../../dd-trace/src/log')
+
+/**
+ * Generates a unique hash from an array of strings by joining them with | before hashing.
+ * Used to uniquely identify AWS requests for span pointers.
+ * @param {string[]} components - Array of strings to hash
+ * @returns {string} A 32-character hash uniquely identifying the components
+ */
+function generatePointerHash (components) {
+  // If passing S3's ETag as a component, make sure any quotes have already been removed!
+  const dataToHash = components.join('|')
+  const hash = crypto.createHash('sha256').update(dataToHash).digest('hex')
+  return hash.substring(0, 32)
+}
+
+/**
+ * Encodes a DynamoDB attribute value to Buffer for span pointer hashing.
+ * @param {Object} valueObject - DynamoDB value in AWS format ({ S: string } or { N: string } or { B: Buffer })
+ * @returns {Buffer|undefined} Encoded value as Buffer, or undefined if invalid input.
+ *
+ * @example
+ * encodeValue({ S: "user123" }) -> Buffer("user123")
+ * encodeValue({ N: "42" }) -> Buffer("42")
+ * encodeValue({ B: Buffer([1, 2, 3]) }) -> Buffer([1, 2, 3])
+ */
+function encodeValue (valueObject) {
+  if (!valueObject) {
+    return
+  }
+
+  try {
+    const type = Object.keys(valueObject)[0]
+    const value = valueObject[type]
+
+    switch (type) {
+      case 'S':
+        return Buffer.from(value)
+      case 'N':
+        return Buffer.from(value.toString())
+      case 'B':
+        return Buffer.isBuffer(value) ? value : Buffer.from(value)
+      default:
+        log.debug(`Found unknown type while trying to create DynamoDB span pointer: ${type}`)
+    }
+  } catch (err) {
+    log.debug(`Failed to encode value while trying to create DynamoDB span pointer: ${err.message}`)
+  }
+}
+
+/**
+ * Extracts and encodes primary key values from a DynamoDB item.
+ * Handles tables with single-key and two-key scenarios.
+ *
+ * @param {Set<string>} keySet - Set of primary key names.
+ * @param {Object} keyValuePairs - Object containing key/value pairs.
+ * @returns {Array|undefined} [key1Name, key1Value, key2Name, key2Value], or undefined if invalid input.
+ *                            key2 entries are empty strings in the single-key case.
+ * @example
+ * extractPrimaryKeys(new Set(['userId']), {userId: {S: "user123"}})
+ * // Returns ["userId", Buffer("user123"), "", ""]
+ * extractPrimaryKeys(new Set(['userId', 'timestamp']), {userId: {S: "user123"}, timestamp: {N: "1234}})
+ * // Returns ["timestamp", Buffer.from("1234"), "userId", Buffer.from("user123")]
+ */
+const extractPrimaryKeys = (keySet, keyValuePairs) => {
+  const keyNames = Array.from(keySet)
+  if (keyNames.length === 0) {
+    return
+  }
+
+  if (keyNames.length === 1) {
+    const value = encodeValue(keyValuePairs[keyNames[0]])
+    if (value) {
+      return [keyNames[0], value, '', '']
+    }
+  } else {
+    const [key1, key2] = keyNames.sort()
+    const value1 = encodeValue(keyValuePairs[key1])
+    const value2 = encodeValue(keyValuePairs[key2])
+    if (value1 && value2) {
+      return [key1, value1, key2, value2]
+    }
+  }
+}
+
+module.exports = {
+  generatePointerHash,
+  encodeValue,
+  extractPrimaryKeys
+}

package/packages/datadog-plugin-azure-functions/src/index.js

@@ -20,7 +20,7 @@ class AzureFunctionsPlugin extends TracingPlugin {
   static get kind () { return 'server' }
   static get type () { return 'serverless' }
 
-  static get prefix () { return 'tracing:datadog:azure-functions:invoke' }
+  static get prefix () { return 'tracing:datadog:azure:functions:invoke' }
 
   bindStart (ctx) {
     const { functionName, methodName } = ctx

package/packages/datadog-plugin-child_process/src/scrub-cmd-params.js

@@ -6,7 +6,7 @@ const ALLOWED_ENV_VARIABLES = ['LD_PRELOAD', 'LD_LIBRARY_PATH', 'PATH']
 const PROCESS_DENYLIST = ['md5']
 
 const VARNAMES_REGEX = /\$([\w\d_]*)(?:[^\w\d_]|$)/gmi
-// eslint-disable-next-line max-len
+// eslint-disable-next-line @stylistic/js/max-len
 const PARAM_PATTERN = '^-{0,2}(?:p(?:ass(?:w(?:or)?d)?)?|address|api[-_]?key|e?mail|secret(?:[-_]?key)?|a(?:ccess|uth)[-_]?token|mysql_pwd|credentials|(?:stripe)?token)$'
 const regexParam = new RegExp(PARAM_PATTERN, 'i')
 const ENV_PATTERN = '^(\\w+=\\w+;)*\\w+=\\w+;?$'

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

@@ -26,7 +26,12 @@ const {
   TEST_MODULE,
   TEST_MODULE_ID,
   TEST_SUITE,
-  CUCUMBER_IS_PARALLEL
+  CUCUMBER_IS_PARALLEL,
+  TEST_NAME,
+  DI_ERROR_DEBUG_INFO_CAPTURED,
+  DI_DEBUG_ERROR_SNAPSHOT_ID,
+  DI_DEBUG_ERROR_FILE,
+  DI_DEBUG_ERROR_LINE
 } = require('../../dd-trace/src/plugins/util/test')
 const { RESOURCE_NAME } = require('../../../ext/tags')
 const { COMPONENT, ERROR_MESSAGE } = require('../../dd-trace/src/constants')
@@ -46,6 +51,7 @@ const {
 const id = require('../../dd-trace/src/id')
 
 const isCucumberWorker = !!process.env.CUCUMBER_WORKER_ID
+const debuggerParameterPerTest = new Map()
 
 function getTestSuiteTags (testSuiteSpan) {
   const suiteTags = {
@@ -220,14 +226,40 @@ class CucumberPlugin extends CiPlugin {
       const testSpan = this.startTestSpan(testName, testSuite, extraTags)
 
       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.addSub('ci:cucumber:test:retry', (isFlakyRetry) => {
+    this.addSub('ci:cucumber:test:retry', ({ isRetry, error }) => {
       const store = storage.getStore()
       const span = store.span
-      if (isFlakyRetry) {
+      if (isRetry) {
         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)
+      }
       span.setTag(TEST_STATUS, 'fail')
       span.finish()
       finishAllTraceSpans(span)
@@ -281,6 +313,7 @@ class CucumberPlugin extends CiPlugin {
       isStep,
       status,
       skipReason,
+      error,
       errorMessage,
       isNew,
       isEfdRetry,
@@ -302,7 +335,9 @@ class CucumberPlugin extends CiPlugin {
         span.setTag(TEST_SKIP_REASON, skipReason)
       }
 
-      if (errorMessage) {
+      if (error) {
+        span.setTag('error', error)
+      } else if (errorMessage) { // we can't get a full error in cucumber steps
         span.setTag(ERROR_MESSAGE, errorMessage)
       }
 

package/packages/datadog-plugin-cypress/src/cypress-plugin.js

@@ -223,7 +223,7 @@ class CypressPlugin {
     this.libraryConfigurationPromise = getLibraryConfiguration(this.tracer, this.testConfiguration)
       .then((libraryConfigurationResponse) => {
         if (libraryConfigurationResponse.err) {
-          log.error(libraryConfigurationResponse.err)
+          log.error('Cypress plugin library config response error', libraryConfigurationResponse.err)
         } else {
           const {
             libraryConfig: {
@@ -360,7 +360,7 @@ class CypressPlugin {
         this.testConfiguration
       )
       if (knownTestsResponse.err) {
-        log.error(knownTestsResponse.err)
+        log.error('Cypress known tests response error', knownTestsResponse.err)
         this.isEarlyFlakeDetectionEnabled = false
       } else {
         // We use TEST_FRAMEWORK_NAME for the name of the module
@@ -374,7 +374,7 @@ class CypressPlugin {
         this.testConfiguration
       )
       if (skippableTestsResponse.err) {
-        log.error(skippableTestsResponse.err)
+        log.error('Cypress skippable tests response error', skippableTestsResponse.err)
       } else {
         const { skippableTests, correlationId } = skippableTestsResponse
         this.testsToSkip = skippableTests || []

package/packages/datadog-plugin-grpc/src/client.js

@@ -62,7 +62,7 @@ class GrpcClientPlugin extends ClientPlugin {
     return parentStore
   }
 
-  error ({ span, error }) {
+  error ({ span = this.activeSpan, error }) {
     this.addCode(span, error.code)
     if (error.code && !this._tracerConfig.grpc.client.error.statuses.includes(error.code)) {
       return
@@ -108,7 +108,7 @@ class GrpcClientPlugin extends ClientPlugin {
   }
 
   addCode (span, code) {
-    if (code !== undefined) {
+    if (code !== undefined && span) {
       span.setTag('grpc.status.code', code)
     }
   }

package/packages/datadog-plugin-grpc/src/util.js

@@ -54,7 +54,7 @@ module.exports = {
     }
 
     if (config.hasOwnProperty(filter)) {
-      log.error(`Expected '${filter}' to be an array or function.`)
+      log.error('Expected \'%s\' to be an array or function.', filter)
     }
 
     return () => ({})

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

@@ -22,7 +22,12 @@ const {
   TEST_EARLY_FLAKE_ABORT_REASON,
   JEST_DISPLAY_NAME,
   TEST_IS_RUM_ACTIVE,
-  TEST_BROWSER_DRIVER
+  TEST_BROWSER_DRIVER,
+  DI_ERROR_DEBUG_INFO_CAPTURED,
+  DI_DEBUG_ERROR_SNAPSHOT_ID,
+  DI_DEBUG_ERROR_FILE,
+  DI_DEBUG_ERROR_LINE,
+  TEST_NAME
 } = require('../../dd-trace/src/plugins/util/test')
 const { COMPONENT } = require('../../dd-trace/src/constants')
 const id = require('../../dd-trace/src/id')
@@ -39,6 +44,7 @@ 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
@@ -155,6 +161,7 @@ class JestPlugin extends CiPlugin {
         config._ddRepositoryRoot = this.repositoryRoot
         config._ddIsFlakyTestRetriesEnabled = this.libraryConfig?.isFlakyTestRetriesEnabled ?? false
         config._ddFlakyTestRetriesCount = this.libraryConfig?.flakyTestRetriesCount
+        config._ddIsDiEnabled = this.libraryConfig?.isDiEnabled ?? false
       })
     })
 
@@ -301,6 +308,29 @@ 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.addSub('ci:jest:test:finish', ({ status, testStartLine }) => {
@@ -326,13 +356,19 @@ class JestPlugin extends CiPlugin {
       finishAllTraceSpans(span)
     })
 
-    this.addSub('ci:jest:test:err', (error) => {
+    this.addSub('ci:jest:test:err', ({ error, willBeRetried, probe, isDiEnabled }) => {
       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)
+          }
         }
       }
     })
@@ -348,7 +384,6 @@ class JestPlugin extends CiPlugin {
     const {
       suite,
       name,
-      runner,
       displayName,
       testParameters,
       frameworkVersion,
@@ -360,7 +395,7 @@ class JestPlugin extends CiPlugin {
     } = test
 
     const extraTags = {
-      [JEST_TEST_RUNNER]: runner,
+      [JEST_TEST_RUNNER]: 'jest-circus',
       [TEST_PARAMETERS]: testParameters,
       [TEST_FRAMEWORK_VERSION]: frameworkVersion
     }

package/packages/datadog-plugin-langchain/src/handlers/language_models/chat_model.js

@@ -46,7 +46,7 @@ class LangChainChatModelHandler extends LangChainLanguageModelHandler {
 
     this.extractTokenMetrics(ctx.currentStore?.span, result)
 
-    for (const messageSetIdx in result.generations) {
+    for (const messageSetIdx in result?.generations) {
       const messageSet = result.generations[messageSetIdx]
 
       for (const chatCompletionIdx in messageSet) {