dd-trace 5.131.1 → 5.132.0

package/index.d.ts

@@ -4063,7 +4063,8 @@ declare namespace tracer {
 
       /**
        * Sets inputs, outputs, tags, metadata, and metrics as provided for a given LLM Observability span.
-       * Note that with the exception of tags, this method will override any existing values for the provided fields.
+       * Note that with the exception of tags and agent, this method will override any existing values for the provided fields.
+       * Agent fields update earlier agent annotations one top-level field at a time.
        *
        * For example:
        * ```javascript
@@ -4079,7 +4080,7 @@ declare namespace tracer {
        * ```
        *
        * @param span The span to annotate (defaults to the current LLM Observability span if not provided)
-       * @param options An object containing the inputs, outputs, tags, metadata, and metrics to set on the span.
+       * @param options An object containing the inputs, outputs, tags, metadata, metrics, and agent to set on the span.
        */
       annotate (options: llmobs.AnnotationOptions): void
       annotate (span: tracer.Span | undefined, options: llmobs.AnnotationOptions): void
@@ -5006,6 +5007,81 @@ declare namespace tracer {
     }
 
 
+    interface AgentToolParameter {
+      type?: string,
+      required?: boolean
+    }
+
+    /**
+     * A plain JSON Schema object with `type: 'object'`, which is how it is told apart from a parameter map.
+     * Schema-library objects (for example Zod schemas) must be converted first, for example with
+     * `z.toJSONSchema()`, or they are dropped.
+     */
+    interface AgentToolJsonSchema {
+      type: 'object',
+      properties: { [param: string]: { type?: string, [key: string]: unknown } },
+      required?: string[]
+    }
+
+    interface AgentTool {
+      name: string,
+      description?: string,
+      /**
+       * Parameters as `{ [param]: { type, required } }`, or a JSON Schema object, which is flattened to the
+       * same shape.
+       */
+      parameters?: { [param: string]: AgentToolParameter } | AgentToolJsonSchema
+    }
+
+    /**
+     * Inference parameters reported in an agent manifest. Keys are accepted in snake_case or camelCase and
+     * reported in snake_case. Other keys are dropped, since provider-specific settings can carry secrets.
+     */
+    interface AgentModelSettings {
+      frequency_penalty?: number,
+      frequencyPenalty?: number,
+      logit_bias?: { [token: string]: number },
+      logitBias?: { [token: string]: number },
+      logprobs?: boolean,
+      max_tokens?: number,
+      maxTokens?: number,
+      parallel_tool_calls?: boolean,
+      parallelToolCalls?: boolean,
+      presence_penalty?: number,
+      presencePenalty?: number,
+      seed?: number,
+      stop_sequences?: string[],
+      stopSequences?: string[],
+      temperature?: number,
+      timeout?: number,
+      tool_choice?: string,
+      toolChoice?: string,
+      top_k?: number,
+      topK?: number,
+      top_logprobs?: number,
+      topLogprobs?: number,
+      top_p?: number,
+      topP?: number
+    }
+
+    /**
+     * Declares the agent an `agent` span represents, reported as the agent's manifest. Only applies to
+     * `agent` spans. Unreportable values are dropped with a warning, and unset values (`undefined`, `null`,
+     * `''`, `[]`) leave what an earlier annotation declared in place.
+     */
+    interface Agent {
+      /** The agent's name. Defaults to the agent span's name. */
+      name?: string,
+      /** The system instructions the agent runs with. */
+      instructions?: string,
+      /** The model the agent is configured to call. */
+      model?: string,
+      /** Inference parameters. Replaces the settings an earlier annotation declared as a whole. */
+      modelSettings?: AgentModelSettings,
+      /** The tools the agent can call. Replaces tools declared by an earlier annotation. */
+      tools?: AgentTool[]
+    }
+
     /**
      * Annotation options for LLM Observability spans.
      */
@@ -5057,7 +5133,12 @@ declare namespace tracer {
        * A list of ToolDefinition object that represents the tools available to the LLM for this span
        * Each definition requires a `name` and optionally accepts `description`, `schema`, and `version`.
        * */
-      toolDefinitions?: ToolDefinition[]
+      toolDefinitions?: ToolDefinition[],
+
+      /**
+       * Declares the agent this span represents. Only used on `agent` spans.
+       */
+      agent?: Agent
     }
 
     interface AnnotationContextOptions {
@@ -5082,6 +5163,13 @@ declare namespace tracer {
        * A Prompt object that represents the prompt used for an LLM call. Only used on `llm` spans.
        */
       prompt?: Prompt,
+
+      /**
+       * Declares the agent running in this context, read when the context is entered. The manifest is
+       * reported on every `agent` span in the context, nested ones included. Use `annotate` on a nested agent
+       * span to declare its own agent.
+       */
+      agent?: Agent,
     }
 
     interface RoutingContextOptions {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.131.1",
+  "version": "5.132.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -193,7 +193,7 @@
     "@datadog/native-appsec": "11.0.3",
     "@datadog/native-iast-taint-tracking": "4.2.1",
     "@datadog/native-metrics": "4.0.0",
-    "@datadog/pprof": "5.19.0",
+    "@datadog/pprof": "5.20.0",
     "@datadog/wasm-js-rewriter": "5.0.4",
     "@opentelemetry/api": ">=1.0.0 <1.10.0",
     "@opentelemetry/api-logs": "<1.0.0",

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentations/webdriverio.js

@@ -80,6 +80,19 @@ module.exports = [
     },
     channelName: 'Runner_run',
   },
+  {
+    module: {
+      name: '@wdio/runner',
+      versionRange: '>=9.0.0',
+      filePath: 'build/index.js',
+    },
+    functionQuery: {
+      className: 'Runner',
+      methodName: '_startSession',
+      kind: 'Async',
+    },
+    channelName: 'Runner_startSession',
+  },
   {
     module: {
       name: '@wdio/runner',
@@ -130,6 +143,33 @@ module.exports = [
     channelName: 'BaseReporter_waitForSync',
     transform: 'waitForAsyncEnd',
   },
+  {
+    module: {
+      name: '@wdio/mocha-framework',
+      versionRange: '>=9.0.0',
+      filePath: 'build/index.js',
+    },
+    functionQuery: {
+      className: 'MochaAdapter',
+      methodName: 'init',
+      kind: 'Async',
+    },
+    channelName: 'MochaAdapter_init',
+  },
+  {
+    module: {
+      name: '@wdio/mocha-framework',
+      versionRange: '>=9.0.0',
+      filePath: 'build/index.js',
+    },
+    astQuery: 'VariableDeclarator[id.name="MochaAdapter"] > ClassExpression > ClassBody > ' +
+      'MethodDefinition[key.name="init"] ReturnStatement > ' +
+      'CallExpression[callee.object.name="promise"][callee.property.name="then"], ' +
+      'ClassDeclaration[id.name="MochaAdapter"] > ClassBody > MethodDefinition[key.name="init"] ReturnStatement > ' +
+      'CallExpression[callee.object.name="promise"][callee.property.name="then"]',
+    channelName: 'MochaAdapter_init',
+    transform: 'waitForAsyncEnd',
+  },
   {
     module: {
       name: '@wdio/jasmine-framework',
@@ -495,7 +535,7 @@ module.exports = [
   {
     module: {
       name: 'jasmine-core',
-      versionRange: '>=5.0.0 <6.0.0',
+      versionRange: '>=5.0.0 <7.0.0',
       filePath: 'lib/jasmine-core/jasmine.js',
     },
     astQuery: 'AssignmentExpression[left.object.object.name="Spec"]' +
@@ -508,7 +548,7 @@ module.exports = [
   {
     module: {
       name: 'jasmine-core',
-      versionRange: '>=5.0.0 <6.0.0',
+      versionRange: '>=5.0.0 <7.0.0',
       filePath: 'lib/jasmine-core/jasmine.js',
     },
     astQuery: 'AssignmentExpression[left.object.object.name="Spec"]' +
@@ -521,7 +561,20 @@ module.exports = [
   {
     module: {
       name: 'jasmine-core',
-      versionRange: '>=5.0.0 <6.0.0',
+      versionRange: '>=5.0.0 <7.0.0',
+      filePath: 'lib/jasmine-core/jasmine.js',
+    },
+    functionQuery: {
+      className: 'Spec',
+      methodName: 'status',
+      kind: 'Sync',
+    },
+    channelName: 'Spec_attemptDone',
+  },
+  {
+    module: {
+      name: 'jasmine-core',
+      versionRange: '>=5.0.0 <7.0.0',
       filePath: 'lib/jasmine-core/jasmine.js',
     },
     functionQuery: {
@@ -534,7 +587,7 @@ module.exports = [
   {
     module: {
       name: 'jasmine-core',
-      versionRange: '>=5.0.0 <6.0.0',
+      versionRange: '>=5.0.0 <7.0.0',
       filePath: 'lib/jasmine-core/jasmine.js',
     },
     functionQuery: {

package/packages/datadog-instrumentations/src/helpers/rewriter/targets.json

@@ -45,6 +45,7 @@
   "@wdio/config/build/node/index.js": "@wdio/config",
   "@wdio/jasmine-framework/build/index.js": "@wdio/jasmine-framework",
   "@wdio/local-runner/build/index.js": "@wdio/local-runner",
+  "@wdio/mocha-framework/build/index.js": "@wdio/mocha-framework",
   "@wdio/runner/build/index.js": "@wdio/runner",
   "@wdio/utils/build/index.js": "@wdio/utils",
   "ai/dist/index.js": "ai",

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

@@ -10,6 +10,7 @@ const { performance } = require('node:perf_hooks')
 const path = require('path')
 const satisfies = require('../../../vendor/dist/semifies')
 const { DD_MAJOR } = require('../../../version')
+const { storage } = require('../../datadog-core')
 const shimmer = require('../../datadog-shimmer')
 const { getEnvironmentVariable, getValueFromEnvSources } = require('../../dd-trace/src/config/helper')
 const log = require('../../dd-trace/src/log')
@@ -88,6 +89,8 @@ const testSkippedCh = channel('ci:jest:test:skip')
 const testFinishCh = channel('ci:jest:test:finish')
 const testErrCh = channel('ci:jest:test:err')
 const testFnCh = channel('ci:jest:test:fn')
+const snapshotStorage = storage('ci:jest:snapshots')
+let activeSnapshotTrackers = 0
 const testSuiteHookFnCh = channel('ci:jest:test-suite:hook:fn')
 const consoleLogSubmissionCh = channel('ci:log-submission:console')
 const logSubmissionFlushCh = channel('ci:log-submission:flush')
@@ -666,7 +669,12 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
     #discardedEfdRetryTests
     #earlyFlakeDetectionRetryPolicy
     #efdRetryGatesByName
+    #expect
     #pendingPre30ConcurrentTests
+    /** @type {(() => void)|undefined} */
+    #restoreSnapshotState
+    /** @type {Set<string>|undefined} */
+    #snapshotTestNames
 
     constructor (config, context) {
       super(config, context)
@@ -1445,6 +1453,98 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       }
     }
 
+    getSnapshotState () {
+      return this.#expect?.getState?.()?.snapshotState
+    }
+
+    /**
+     * Attributes snapshot increments to the executing test when serial and concurrent bodies can overlap.
+     * Both Jest and image snapshot matchers write this shared counter directly.
+     */
+    #trackQuarantinedSnapshots () {
+      if (!this.hasConcurrentTests || !this.testManagementTestsForThisSuite?.quarantined?.length) return
+
+      const snapshotState = this.getSnapshotState()
+      const descriptor = snapshotState && Object.getOwnPropertyDescriptor(snapshotState, 'unmatched')
+      if (!descriptor?.configurable || typeof descriptor.value !== 'number') return
+
+      let unmatched = descriptor.value
+      try {
+        Object.defineProperty(snapshotState, 'unmatched', {
+          configurable: true,
+          enumerable: descriptor.enumerable,
+          get () { return unmatched },
+          /** @param {number} value */
+          set (value) {
+            const ctx = /** @type {{ unmatchedSnapshots?: number }|undefined} */ (snapshotStorage.getStore())
+            if (ctx?.unmatchedSnapshots !== undefined && value > unmatched) {
+              ctx.unmatchedSnapshots += value - unmatched
+            }
+            unmatched = value
+          },
+        })
+      } catch (error) {
+        log.error('Could not track quarantined Jest snapshots: %s', error)
+        return
+      }
+
+      if (activeSnapshotTrackers++ === 0) testFnCh.bindStore(snapshotStorage)
+      this.#restoreSnapshotState = () => {
+        try {
+          Object.defineProperty(snapshotState, 'unmatched', { ...descriptor, value: unmatched })
+        } catch (error) {
+          log.error('Could not restore Jest snapshot state: %s', error)
+        } finally {
+          if (--activeSnapshotTrackers === 0) testFnCh.unbindStore(snapshotStorage)
+        }
+      }
+    }
+
+    /**
+     * Keeps the snapshot results of a quarantined test from failing the run.
+     *
+     * Jest fails the run on unmatched or obsolete snapshots even when no test failed.
+     *
+     * @param {object} test
+     */
+    ignoreQuarantinedSnapshotResults (test) {
+      const ctx = testContexts.get(test)
+      const unmatchedBeforeTest = ctx?.unmatchedSnapshotsBeforeTest
+      const unmatchedSnapshots = ctx?.unmatchedSnapshots
+      // Jest retries the attempts that still have errors and resets their snapshot results itself.
+      if ((unmatchedBeforeTest === undefined && unmatchedSnapshots === undefined) || test.errors?.length) return
+
+      const snapshotState = this.getSnapshotState()
+      if (!snapshotState) return
+
+      if (unmatchedSnapshots !== undefined) {
+        snapshotState.unmatched -= unmatchedSnapshots
+        ctx.unmatchedSnapshots = 0
+      } else if (snapshotState.unmatched > unmatchedBeforeTest) {
+        snapshotState.unmatched = unmatchedBeforeTest
+      }
+      // Jest's name-based marker can consume other tests' keys, so delete only keys owned by this test.
+      const keys = snapshotState._uncheckedKeys
+      const testNames = this.#snapshotTestNames
+      if (!keys?.delete || !testNames) return
+      const testName = getRawJestTestName(test)
+      const hintPrefix = `${testName}: `
+      for (const key of keys) {
+        const snapshotName = key.slice(0, key.lastIndexOf(' '))
+        if (snapshotName !== testName && !snapshotName.startsWith(hintPrefix)) continue
+        let belongsToAnotherTest = false
+        // Snapshot names do not identify their owner when another registered name matches the same key.
+        for (const name of testNames) {
+          if (name !== testName &&
+            (snapshotName === name || snapshotName.startsWith(`${name}: `))) {
+            belongsToAnotherTest = true
+            break
+          }
+        }
+        if (!belongsToAnotherTest) keys.delete(key)
+      }
+    }
+
     // This function returns an array if the known tests are valid and null otherwise.
     getKnownTestsForSuite (suiteKnownTests) {
       // `suiteKnownTests` is `this.testEnvironmentOptions._ddKnownTests`,
@@ -1819,6 +1919,11 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       if (event.concurrent) {
         this.hasConcurrentTests = true
       }
+      const registeredTest = getTestEntries(state.currentDescribeBlock)?.at(-1)
+      if (registeredTest && this.testManagementTestsForThisSuite?.quarantined?.length) {
+        this.#snapshotTestNames ??= new Set()
+        this.#snapshotTestNames.add(getRawJestTestName(registeredTest))
+      }
       if (event.failing) {
         return
       }
@@ -1827,7 +1932,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       const concurrentTestContexts = this.concurrentTestContexts.get(testFullName)
       const concurrentTestState = this.concurrentTestStates.get(event.fn) ||
         concurrentTestContexts?.at(-1)?.concurrentTestState
-      const registeredTest = getTestEntries(state.currentDescribeBlock)?.at(-1)
       if (concurrentTestState && registeredTest?.fn === event.fn) {
         testContexts.set(registeredTest, concurrentTestState.ctx)
       }
@@ -1925,10 +2029,12 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       }
 
       if (event.name === 'run_start') {
+        this.#trackQuarantinedSnapshots()
         const registerResultHandler = dynamicAtrResultHandlerRegistrations.get(this)
         dynamicAtrResultHandlerRegistrations.delete(this)
         registerResultHandler?.()
       } else if (event.name === 'setup') {
+        this.#expect = event.runtimeGlobals?.expect ?? this.global.expect
         this.wrapConcurrentTest(state)
         this.bindTestEach(this.global.test)
       }
@@ -2044,6 +2150,13 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           ctx.concurrentTestState = concurrentTestState
           concurrentTestState.ctx = ctx
         }
+        if (isQuarantined && !isAttemptToFix && !event.test.concurrent && !ctx.concurrentTestState) {
+          if (this.#restoreSnapshotState) {
+            ctx.unmatchedSnapshots = 0
+          } else if (!this.hasConcurrentTests) {
+            ctx.unmatchedSnapshotsBeforeTest = this.getSnapshotState()?.unmatched
+          }
+        }
         testContexts.set(event.test, ctx)
 
         if (isAttemptToFix) {
@@ -2282,6 +2395,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
             event.test.errors = []
           }
         }
+        this.ignoreQuarantinedSnapshotResults(event.test)
 
         // Quarantine must consume terminal failures before we save errors for Jest's final result.
         if (dynamicAtrCount !== undefined && failedAllTests && event.test.errors?.length) {
@@ -2359,6 +2473,8 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           ctx.currentStore = undefined
         }
       } else if (event.name === 'run_finish') {
+        this.#restoreSnapshotState?.()
+        this.#restoreSnapshotState = undefined
         this.removeDiscardedEfdRetries()
         for (const [test, errors] of atrSuppressedErrors) {
           // Do not restore errors for non-ATF quarantined tests — they should stay suppressed
@@ -2528,6 +2644,8 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
     }
 
     teardown () {
+      this.#restoreSnapshotState?.()
+      this.#restoreSnapshotState = undefined
       if (this._globalProxy?.propertyToValue) {
         for (const [key] of this._globalProxy.propertyToValue) {
           if (typeof key === 'string' && key.startsWith('_dd')) {