dd-trace 6.17.0 → 6.19.0

package/LICENSE-3rdparty.csv

@@ -1,5 +1,6 @@
 "component","origin","license","copyright"
 "@apm-js-collab/code-transformer","https://github.com/nodejs/orchestrion-js","['Apache-2.0']","['nodejs']"
+"@bufbuild/protobuf","https://github.com/bufbuild/protobuf-es","['(Apache-2.0 AND BSD-3-Clause)']","['bufbuild']"
 "@datadog/flagging-core","https://github.com/DataDog/openfeature-js-client","['Apache-2.0']","['DataDog']"
 "@datadog/libdatadog","https://github.com/DataDog/libdatadog-nodejs","['Apache-2.0']","['DataDog']"
 "@datadog/libdatadog-extras","https://github.com/DataDog/libdatadog-nodejs","['Apache-2.0']","['Datadog Inc.']"

package/ci/vitest-no-worker-init-setup.mjs

@@ -114,14 +114,12 @@ if (isNoWorkerInitActive) {
     onTestFinished(() => {
       recordTestAttemptTiming(task, attemptIndex, attemptStart)
       recordRetryErrorCount(task)
-      if (
-        (isAttemptToFixTest || isEarlyFlakeDetectionTestAttempt || isQuarantinedTest) &&
-        attemptIndex === getFinalAttemptIndex(task)
-      ) {
+      if (isEarlyFlakeDetectionTestAttempt || isQuarantinedTest ||
+        (isAttemptToFixTest && attemptIndex === getFinalAttemptIndex(task))) {
         if (isAttemptToFixTest || isEarlyFlakeDetectionTestAttempt) {
-          recordTestOptimizationStatus(task, attemptIndex, true)
+          recordTestOptimizationStatus(task, attemptIndex, attemptIndex === getFinalAttemptIndex(task))
         }
-        switchQuarantinedFinalFailure(task, attemptIndex)
+        switchQuarantinedFinalFailure(task)
       }
       finishRumCorrelation(task, attemptIndex)
     })
@@ -134,7 +132,7 @@ if (isNoWorkerInitActive) {
       recordTestOptimizationStatus(task, attemptIndex)
     }
     if (!restoredEarlyFlakeDetectionResult) {
-      switchQuarantinedFinalFailure(task, attemptIndex)
+      switchQuarantinedFinalFailure(task)
     }
   })
 }
@@ -433,7 +431,10 @@ function recordEarlyFlakeDetectionStatus (task, attemptIndex, onlyIfNewErrors) {
     return
   }
 
-  if (!earlyFlakeDetectionRetriesByTask.has(task)) {
+  // onTestFinished runs before aroundEach fixture teardown. Select the budget
+  // when the next attempt records the completed attempt instead.
+  const isCompletedAttempt = attemptIndex < task.meta.__ddTestOptCurrentAttemptIndex
+  if (isCompletedAttempt && !earlyFlakeDetectionRetriesByTask.has(task)) {
     const retryCount = getEarlyFlakeDetectionRetryCount(task)
     earlyFlakeDetectionRetriesByTask.set(task, retryCount)
     task.repeats = retryCount
@@ -452,9 +453,15 @@ function recordEarlyFlakeDetectionStatus (task, attemptIndex, onlyIfNewErrors) {
   )
   task.meta.__ddTestOptEfdErrorCounts[attemptIndex] = task.result?.errors?.length || 0
 
-  if (attemptIndex === getEarlyFlakeDetectionRetryCountForTask(task) &&
+  // Vitest 5.0.3 retains failures across repeats. Defer EFD's overall failure until
+  // the last attempt, while keeping each attempt's actual outcome in the metadata.
+  if (attemptIndex < getEarlyFlakeDetectionRetryCountForTask(task) ||
     task.meta.__ddTestOptEfdStatuses.includes('pass')) {
     task.result.state = 'pass'
+  } else if (isCompletedAttempt) {
+    // A zero retry budget cancels repeats after we suppressed the initial failure.
+    task.result.state = 'fail'
+    markQuarantinedFailure(task)
   }
 }
 
@@ -525,7 +532,7 @@ function wrapRetryCondition (task) {
         shouldRetry = condition(error)
       }
 
-      if (!shouldRetry && (task.result?.repeatCount || 0) >= (task.repeats || 0)) {
+      if (!shouldRetry) {
         const attemptIndex = task.meta.__ddTestOptCurrentAttemptIndex
         recordTestOptimizationStatus(task, attemptIndex)
         markQuarantinedFailure(task)
@@ -579,7 +586,7 @@ function getFinalAttemptIndex (task) {
   return attemptIndex + retriesRemaining + (repeatsRemaining * (retryLimit + 1))
 }
 
-function switchQuarantinedFinalFailure (task, attemptIndex) {
+function switchQuarantinedFinalFailure (task) {
   const testSuite = getTestSuite(task)
   const testName = getTestName(task)
   if (
@@ -590,7 +597,10 @@ function switchQuarantinedFinalFailure (task, attemptIndex) {
     return
   }
 
-  if (attemptIndex < getFinalAttemptIndex(task)) {
+  // Finish the retries in this repetition before suppressing its failure. A later
+  // repetition cannot undo a failure that Vitest has already aggregated.
+  const retryAttemptIndex = retryAttemptIndexByTask.get(task)?.index || 0
+  if (retryAttemptIndex < getRetryLimit(task)) {
     return
   }
 

package/index.d.ts

@@ -2025,8 +2025,9 @@ declare namespace tracer {
       /**
        * Whether to capture LLM Observability spans for this integration. When set to `false`,
        * the integration keeps emitting APM spans and propagating trace context, but no LLM
-       * Observability spans are produced. Useful when another integration already captures the
-       * same operation and the payloads would otherwise be stored twice.
+       * Observability spans and no basic `gen_ai.*` APM tags are produced. Useful when another
+       * integration already captures the same operation and the payloads would otherwise be
+       * stored twice.
        * @default true
        */
       llmobs?: boolean;
@@ -3886,13 +3887,13 @@ declare namespace tracer {
       /** Create a text or chat prompt and its first version. */
       createPrompt (
         promptId: string,
-        template: string | PromptTemplateMessage[],
+        template: string | PromptTemplateItem[],
         options?: CreatePromptOptions
       ): Promise<PromptResponse>
       /** Add a text or chat version to an existing prompt. */
       createPromptVersion (
         promptId: string,
-        template: string | PromptTemplateMessage[],
+        template: string | PromptTemplateItem[],
         options?: CreatePromptVersionOptions
       ): Promise<PromptVersionResponse>
       /** Update prompt metadata. */
@@ -3916,10 +3917,45 @@ declare namespace tracer {
       content: string
     }
 
+    /** Provider fields on expanded messages; authored templates remain text-only. */
+    interface FormattedPromptMessage extends PromptTemplateMessage {
+      // The inherited content type stays string for compatibility; tool-only payloads can omit it or contain null.
+      tool_calls?: PromptToolCall[] | null,
+      tool_results?: PromptToolResult[] | null,
+      tool_call_id?: string | null
+    }
+
+    interface PromptToolCall {
+      id?: string | null,
+      type?: string | null,
+      tool_id?: string | null,
+      name?: string | null,
+      arguments?: unknown,
+      function?: {
+        name: string,
+        arguments: string
+      } | null
+    }
+
+    interface PromptToolResult {
+      id?: string | null,
+      type?: string | null,
+      tool_id?: string | null,
+      name?: string | null,
+      result?: unknown
+    }
+
+    interface PromptMessagePlaceholder {
+      type: 'placeholder',
+      name: string
+    }
+
+    type PromptTemplateItem = PromptTemplateMessage | PromptMessagePlaceholder
+
     type PromptFallbackValue =
       | string
-      | PromptTemplateMessage[]
-      | { template: string | PromptTemplateMessage[], version?: string }
+      | PromptTemplateItem[]
+      | { template: string | PromptTemplateItem[], version?: string, config?: Record<string, JSONType> }
     type PromptFallback = PromptFallbackValue | (() => PromptFallbackValue)
 
     interface GetPromptOptions {
@@ -3938,13 +3974,15 @@ declare namespace tracer {
       title?: string,
       description?: string,
       userVersion?: string,
-      envIds?: string[]
+      envIds?: string[],
+      config?: Record<string, JSONType>
     }
 
     interface CreatePromptVersionOptions {
       description?: string,
       userVersion?: string,
-      envIds?: string[]
+      envIds?: string[],
+      config?: Record<string, JSONType>
     }
 
     interface UpdatePromptOptions {
@@ -3957,14 +3995,16 @@ declare namespace tracer {
       envIds?: string[]
     }
 
+    // Preserve released output types; placeholder entries and null/omitted tool content are not fully described here.
     interface ManagedPrompt {
       readonly id: string,
       readonly version: string,
       readonly source: 'registry' | 'cache' | 'fallback' | 'ff' | 'resolve',
       readonly template: string | ReadonlyArray<Readonly<PromptTemplateMessage>>,
+      readonly config: Readonly<Record<string, ReadonlyJSONType>>,
       readonly promptUuid?: string,
       readonly promptVersionUuid?: string,
-      format (variables?: Record<string, unknown>): string | PromptTemplateMessage[]
+      format (variables?: Record<string, unknown>): string | FormattedPromptMessage[]
       toAnnotation (variables?: Record<string, unknown>): Prompt
     }
 
@@ -3982,7 +4022,8 @@ declare namespace tracer {
       ml_app?: string,
       ml_apps?: string[],
       last_version_created_at?: string,
-      extracted_from?: string
+      extracted_from?: string,
+      config?: Record<string, JSONType>
     }
 
     interface PromptVersionResponse {
@@ -3996,7 +4037,8 @@ declare namespace tracer {
       version_created_at?: string,
       author?: string,
       description?: string,
-      ml_app?: string
+      ml_app?: string,
+      config?: Record<string, JSONType>
     }
 
     interface DeletedPromptResponse {
@@ -4008,6 +4050,8 @@ declare namespace tracer {
     /** JSON-serializable value accepted by LLMObs Experiments. */
     type JSONType = string | number | boolean | null | JSONType[] | { [key: string]: JSONType }
 
+    type ReadonlyJSONType = string | number | boolean | null | ReadonlyArray<ReadonlyJSONType> | { readonly [key: string]: ReadonlyJSONType }
+
     /**
      * A task run over each dataset record during an experiment.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "6.17.0",
+  "version": "6.19.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -206,7 +206,7 @@
     "@eslint/eslintrc": "^3.3.7",
     "@eslint/js": "^10.0.1",
     "@eslint/plugin-kit": "^0.7.3",
-    "@datadog/openfeature-node-server": "2.3.0",
+    "@datadog/openfeature-node-server": "2.4.0",
     "@msgpack/msgpack": "^3.1.3",
     "@openfeature/core": "^1.12.0",
     "@openfeature/server-sdk": "~1.23.0",
@@ -222,14 +222,14 @@
     "bun": "1.4.2",
     "c8": "^12.0.0",
     "codeowners-audit": "^2.9.0",
-    "eslint": "^10.10.0",
+    "eslint": "^10.11.0",
     "eslint-plugin-cypress": "^7.0.2",
     "eslint-plugin-import-x": "^4.16.2",
-    "eslint-plugin-jsdoc": "^64.5.2",
+    "eslint-plugin-jsdoc": "^64.5.4",
     "eslint-plugin-mocha": "^12.0.2",
     "eslint-plugin-n": "^18.3.0",
     "eslint-plugin-promise": "^7.3.0",
-    "eslint-plugin-regexp": "^3.3.0",
+    "eslint-plugin-regexp": "^3.3.1",
     "eslint-plugin-sonarjs": "^4.2.1",
     "eslint-plugin-unicorn": "^74.0.0",
     "express": "^5.1.0",
@@ -251,7 +251,7 @@
     "node-preload": "^0.2.1",
     "nyc": "^18.0.0",
     "octokit": "^5.0.3",
-    "p-limit": "^7.3.2",
+    "p-limit": "^7.3.3",
     "proxyquire": "^2.1.3",
     "retry": "^0.13.1",
     "semifies": "^1.0.0",

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

@@ -124,13 +124,48 @@ function wrapStreamIterator (iterator, ctx) {
   }
 }
 
+/**
+ * Gives the SDK a detached copy of the response to decode, leaving the body the caller can still
+ * read through `asResponse()` untouched. The bytes are buffered instead of streamed from a live
+ * clone, and the controller is replaced, because the SDK cancels its reader and aborts its
+ * controller whenever a stream ends early: that abort would kill the caller's request, and on a
+ * cloned body that cancel blocks until the other branch is read, which the caller cannot do while
+ * it is still waiting for this parse.
+ *
+ * Any failure falls back to the original props and tells the wrapper to skip inspection, leaving
+ * the SDK to behave as it does untraced.
+ *
+ * @param {{response: Response}} props
+ * @param {() => void} onFailure
+ * @returns {object|Promise<object>}
+ */
+function detachResponse (props, onFailure) {
+  const { status, statusText, headers } = props.response
+  try {
+    return props.response.clone().arrayBuffer()
+      .then(body => ({
+        ...props,
+        response: new Response(body, { status, statusText, headers }),
+        controller: new AbortController(),
+      }))
+      .catch(() => {
+        onFailure()
+        return props
+      })
+  } catch {
+    onFailure()
+    return props
+  }
+}
+
 function wrapCreate (create) {
   return function (...args) {
     const stream = args[0]?.stream
-    const preparing = !stream && messagesPrepareChannel.hasSubscribers
-    const intercepting = !stream && messagesInterceptChannel.hasSubscribers
+    const tracing = anthropicTracingChannel.start.hasSubscribers
+    const preparing = messagesPrepareChannel.hasSubscribers
+    const intercepting = messagesInterceptChannel.hasSubscribers
 
-    if (!anthropicTracingChannel.start.hasSubscribers && !preparing && !intercepting) {
+    if (!tracing && !preparing && !intercepting) {
       return create.apply(this, args)
     }
 
@@ -160,23 +195,60 @@ function wrapCreate (create) {
 
       let parseResult
       let wrappedResponse
+      // Set around a `parse()` whose body a raw-response reader also holds, so the SDK decodes a
+      // copy and leaves that body to the caller. Plain streaming has no second reader and copies
+      // nothing.
+      let detach = false
 
+      // These helpers live on each returned APIPromise, so there is no module export for
+      // Orchestrion to replace; wrap this instance instead.
       shimmer.wrap(apiPromise, 'parse', parse => function (...parseArgs) {
         if (parseResult) return parseResult
 
-        parseResult = heldUntil(parse.apply(this, parseArgs), interceptCtx?.beforeResult?.())
+        let detachmentFailed = false
+        const responsePromise = detach ? this.responsePromise : undefined
+        if (responsePromise) {
+          this.responsePromise = responsePromise.then(props => detachResponse(props, () => {
+            detachmentFailed = true
+          }))
+        }
+
+        let result
+        try {
+          result = parse.apply(this, parseArgs)
+        } finally {
+          if (responsePromise) this.responsePromise = responsePromise
+        }
+
+        const onResult = interceptCtx?.onResult
+        parseResult = heldUntil(result, interceptCtx?.beforeResult?.())
           .then(response => {
             if (stream) {
-              shimmer.wrap(response, Symbol.asyncIterator, iterator => wrapStreamIterator(iterator, ctx))
-              return response
+              if (!onResult || detachmentFailed) {
+                if (tracing) {
+                  shimmer.wrap(response, Symbol.asyncIterator, iterator => wrapStreamIterator(iterator, ctx))
+                }
+                return response
+              }
+
+              return Promise.resolve(onResult(response)).then(deliveredResponse => {
+                if (tracing) {
+                  shimmer.wrap(
+                    deliveredResponse,
+                    Symbol.asyncIterator,
+                    iterator => wrapStreamIterator(iterator, ctx)
+                  )
+                }
+                return deliveredResponse
+              })
             }
 
-            if (!interceptCtx?.onResult) {
+            if (!onResult) {
               finish(ctx, response)
               return response
             }
 
-            return Promise.resolve(interceptCtx.onResult(response)).then(deliveredResponse => {
+            return Promise.resolve(onResult(response)).then(deliveredResponse => {
               finish(ctx, response)
               return deliveredResponse
             })
@@ -190,9 +262,26 @@ function wrapCreate (create) {
         shimmer.wrap(apiPromise, 'asResponse', origAsResponse => function (...asResponseArgs) {
           return heldUntil(origAsResponse.apply(this, asResponseArgs), interceptCtx?.beforeResult?.())
             .then(response => {
+              if (stream) {
+                // A caller holding the parsed stream closes the span as it drains it. When only
+                // the raw body is read, decode the stream here so it is still evaluated.
+                if (!interceptCtx?.onResult) return response
+                if (parseResult) return parseResult.then(() => response)
+
+                detach = true
+                try {
+                  return apiPromise.parse().then(() => {
+                    finish(ctx)
+                    return response
+                  })
+                } finally {
+                  detach = false
+                }
+              }
+
               // Wrap json()/text()/clone() so the span still closes on the raw-response path,
               // and not twice for the same response.
-              if (!stream && wrappedResponse !== response) {
+              if (wrappedResponse !== response) {
                 wrappedResponse = response
                 wrapRawResponse(response, ctx, interceptCtx)
               }
@@ -202,6 +291,19 @@ function wrapCreate (create) {
         })
       }
 
+      // `withResponse()` is the one SDK call that hands out the raw response *and* the parsed
+      // stream; it invokes `parse()` synchronously, so the flag only has to outlive that call.
+      if (stream && interceptCtx?.onResult && typeof apiPromise.withResponse === 'function') {
+        shimmer.wrap(apiPromise, 'withResponse', withResponse => function (...withResponseArgs) {
+          detach = true
+          try {
+            return withResponse.apply(this, withResponseArgs)
+          } finally {
+            detach = false
+          }
+        })
+      }
+
       anthropicTracingChannel.end.publish(ctx)
 
       return apiPromise

package/packages/datadog-instrumentations/src/claude-agent-sdk.js

@@ -44,6 +44,7 @@ const chunkEmitTimes = new WeakMap()
  *   tools: Map<string, ToolState>,
  *   subagents: Map<string, Record<string, unknown>>,
  *   prompt?: string,
+ *   systemPrompt?: string | string[] | { type: string, prompt?: string | string[], append?: string },
  *   model?: string,
  *   resume?: string,
  *   maxTurns?: number,
@@ -235,6 +236,7 @@ function onQueryStart (ctx) {
   const prompt = queryArg.prompt
   const sessionCtx = {
     prompt: typeof prompt === 'string' ? prompt : undefined,
+    systemPrompt: options.systemPrompt,
     model: options.model,
     resume: options.resume,
     maxTurns: options.maxTurns,
@@ -451,6 +453,7 @@ function processStep (
     llmCh.traceSync(() => {}, {
       model,
       usage,
+      systemPrompt: parentToolUseId ? undefined : sessionCtx?.systemPrompt,
       startTime: stepStartTime,
       finishTime: chunkEmitTimes.get(chunks[messageEndIdx - 1]),
       chunks,
@@ -529,7 +532,8 @@ function processChunks (chunks, agentCtx) {
   const sessionCtx = agentCtx.sessionCtx
   const getLifecycle = createStreamLookup(chunks)
 
-  const { type, subtype, ...rest } = chunks[0]
+  const initChunk = chunks.find(chunk => chunk.type === 'system' && chunk.subtype === 'init') || chunks[0]
+  const { type, subtype, ...rest } = initChunk
   Object.assign(agentCtx, rest)
   if (sessionCtx) {
     if (sessionCtx.sessionId) agentCtx.session_id = sessionCtx.sessionId

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

@@ -142,7 +142,6 @@ let knownTests = {}
 let skippedSuites = []
 let isSuitesSkipped = false
 let areAllSuitesSkipped = false
-let hasTestsToRun = false
 let repositoryRoot
 
 function shouldRunEarlyFlakeDetection () {
@@ -1218,7 +1217,6 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
       }
     }
 
-    hasTestsToRun = isCoordinator ? this.sourcedPickles.length > 0 : this.pickleIds.length > 0
     pickleByFile = isCoordinator ? getPickleByFileNew(this) : getPickleByFile(this)
 
     if (isKnownTestsEnabled) {
@@ -1330,10 +1328,17 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
       global.__coverage__ = fromCoverageMapToCoverage(originalCoverageMap)
     }
 
-    const isExpectedEmptySession = success && !hasTestsToRun
+    const testCaseAttempts = (this.eventDataCollector || eventDataCollector).getTestCaseAttempts()
+    const getStatus = satisfies(frameworkVersion, '>=7.3.0') ? getStatusFromResultLatest : getStatusFromResult
+    const hasExecutedTests = testCaseAttempts.some(({ worstTestStepResult }) =>
+      getStatus(worstTestStepResult).status !== 'skip'
+    )
+    const testSessionEmptyReason = success && !hasExecutedTests
+      ? (testCaseAttempts.length > 0 || skippedSuites.length > 0 ? 'all_tests_skipped' : 'zero_tests')
+      : undefined
     const flushPromise = getChannelPromise(sessionFinishCh, {
-      status: isExpectedEmptySession ? 'skip' : (success ? 'pass' : 'fail'),
-      isExpectedEmptySession,
+      status: testSessionEmptyReason ? 'skip' : (success ? 'pass' : 'fail'),
+      testSessionEmptyReason,
       isSuitesSkipped,
       testCodeCoverageLinesTotal,
       testSessionCoverageFiles,
@@ -1413,13 +1418,49 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
 
     if (isImpactedTestsEnabled) {
       const setIsModified = (receivedIsModified) => { isModified = receivedIsModified }
-      const scenarios = gherkinDocument.feature?.children?.filter(
-        children => pickle.astNodeIds.includes(children.scenario.id)
-      ).map(scenario => scenario.scenario)
+      const gherkinNodes = []
+      // Prefix ranges catch removed Backgrounds, which have no AST node in the target document.
+      const gherkinScopeRanges = []
+      const feature = gherkinDocument.feature
+      const featureChildren = feature?.children
+      if (featureChildren?.length) {
+        const firstFeatureChild = featureChildren[0]
+        const firstFeatureNode = firstFeatureChild.background ?? firstFeatureChild.rule ?? firstFeatureChild.scenario
+        const firstFeatureLine = firstFeatureNode.tags?.[0]?.location.line ?? firstFeatureNode.location.line
+        const featurePrefix = [feature.location.line, firstFeatureLine - 1]
+        let featureBackground
+        for (const child of featureChildren) {
+          if (child.background) {
+            featureBackground = child.background
+            continue
+          }
+          const rule = child.rule
+          const children = rule?.children ?? [child]
+          let ruleBackground
+          for (const { background } of children) {
+            if (background) ruleBackground = background
+          }
+          for (const { scenario } of children) {
+            if (scenario && pickle.astNodeIds.includes(scenario.id)) {
+              if (!featureBackground) gherkinScopeRanges.push(featurePrefix)
+              if (rule?.children?.length && !ruleBackground) {
+                const firstRuleChild = rule.children.at(0)
+                const firstRuleNode = firstRuleChild.background ?? firstRuleChild.scenario
+                const firstRuleLine = firstRuleNode.tags?.[0]?.location.line ?? firstRuleNode.location.line
+                gherkinScopeRanges.push([rule.location.line, firstRuleLine - 1])
+              }
+              if (featureBackground) gherkinNodes.push(featureBackground)
+              if (ruleBackground) gherkinNodes.push(ruleBackground)
+              gherkinNodes.push(scenario)
+            }
+          }
+        }
+      }
       const stepIds = testCase?.testSteps?.flatMap(testStep => testStep.stepDefinitionIds)
 
       isModifiedCh.publish({
-        scenarios,
+        gherkinNodes,
+        gherkinScopeRanges,
         testFileAbsolutePath: gherkinDocument.uri,
         modifiedFiles,
         stepIds,