dd-trace 6.20.1 → 6.22.0

package/packages/dd-trace/src/lambda/handler.js

@@ -1,20 +1,24 @@
 'use strict'
 
-const log = require('../log')
+const { types: { isProxy } } = require('node:util')
+
 const { channel } = require('../../../datadog-instrumentations/src/helpers/instrument')
 const { ERROR_MESSAGE, ERROR_TYPE } = require('../constants')
+const log = require('../log')
 const { ImpendingTimeout } = require('./runtime/errors')
 const { extractContext } = require('./context')
 
+const HANDLER_STREAMING = Symbol.for('aws.lambda.runtime.handler.streaming')
+const HANDLER_HIGHWATERMARK = Symbol.for('aws.lambda.runtime.handler.streaming.highWaterMark')
+const BEFORE_EXIT = Symbol.for('aws.lambda.beforeExit')
 const timeoutChannel = channel('apm:aws:lambda:timeout')
+const monitoredContexts = new WeakSet()
 // Always crash the flushes when a message is received
 // from this channel.
 timeoutChannel.subscribe(_ => {
   crashFlush()
 })
 
-let __lambdaTimeout
-
 /**
  * Publishes to the `apm:aws:lambda:timeout` channel when
  * the AWS Lambda run time is about to end.
@@ -23,11 +27,15 @@ let __lambdaTimeout
  */
 function checkTimeout (context) {
   const remainingTimeInMillis = context.getRemainingTimeInMillis()
-  const apmFlushDeadline = global._ddtrace._tracer._config.DD_APM_FLUSH_DEADLINE_MILLISECONDS
+  const apmFlushDeadline = global._ddtrace?._tracer?._config?.DD_APM_FLUSH_DEADLINE_MILLISECONDS
+  if (!Number.isFinite(remainingTimeInMillis) || !Number.isFinite(apmFlushDeadline)) return
 
-  __lambdaTimeout = setTimeout(() => {
+  const timeout = setTimeout(() => {
     timeoutChannel.publish()
-  }, remainingTimeInMillis - apmFlushDeadline)
+  }, Math.max(0, remainingTimeInMillis - apmFlushDeadline))
+  // eslint-disable-next-line eslint-rules/eslint-timer-unref -- AWS Lambda uses Node.js timers.
+  timeout.unref()
+  return timeout
 }
 
 /**
@@ -58,26 +66,178 @@ function crashFlush () {
 }
 
 /**
- * Patches your AWS Lambda handler function to add some tracing support.
+ * Monitors an AWS Lambda handler for impending timeouts without creating a span.
  *
  * @param {Function} lambdaHandler a Lambda handler function.
+ * @param {boolean} normalized whether datadog-lambda-js owns completion selection.
  */
-exports.datadog = function datadog (lambdaHandler) {
-  return (...args) => {
+exports.datadog = function datadog (lambdaHandler, normalized = false) {
+  function monitored (...args) {
     const context = extractContext(args)
+    if (!context || monitoredContexts.has(context)) return Reflect.apply(lambdaHandler, this, args)
 
-    if (context) {
-      checkTimeout(context)
+    const timeout = checkTimeout(context)
+    if (timeout === undefined) return Reflect.apply(lambdaHandler, this, args)
+
+    let completed = false
+    let callbackPending = false
+    /** @type {Array<[object, string | symbol, Function, Function]>} */
+    const completionMethods = []
+    const clear = () => {
+      if (completed) return
+      completed = true
+      clearTimeout(timeout)
+      for (const [target, name, original, wrapped] of completionMethods) {
+        try {
+          if (target[name] === wrapped) Reflect.set(target, name, original)
+        } catch (error) {
+          log.error('Error restoring Lambda completion %s: %s', name, error)
+        }
+      }
+    }
+    const clearOnHandlerCompletion = normalized
+      ? clear
+      : () => {
+          // Once a native callback selects event-loop drain, later handler signals are ignored by RIC.
+          if (!callbackPending) clear()
+        }
+
+    const contextIndex = args.indexOf(context)
+    const callbackObservable = contextIndex !== 2 && typeof args[2] === 'function'
+    if (!normalized) {
+      for (const name of ['done', 'succeed', 'fail']) {
+        wrapCompletion(context, name, clearOnHandlerCompletion, completionMethods)
+      }
     }
+    // Legacy Lambda runtimes complete idle invocations through this callback instead of the handler's callback.
+    wrapCompletion(globalThis, BEFORE_EXIT, clear, completionMethods)
 
-    const result = lambdaHandler.apply(this, args)
-    if (result && typeof result.then === 'function') {
-      return result.then((res) => {
-        clearTimeout(__lambdaTimeout)
-        return res
-      })
+    if (callbackObservable) {
+      const callback = args[2]
+      const beforeExitObservable = completionMethods.at(-1)?.[1] === BEFORE_EXIT
+      let callbackInvoked = false
+      args[2] = function (...callbackArgs) {
+        if (completed || callbackInvoked) return Reflect.apply(callback, this, callbackArgs)
+        callbackInvoked = true
+        let beforeExit
+        try {
+          if (beforeExitObservable && callbackArgs[0] == null && context.callbackWaitsForEmptyEventLoop) {
+            beforeExit = getDataProperty(globalThis, BEFORE_EXIT)
+          }
+        } catch (error) {
+          log.error('Error reading Lambda callback completion: %s', error)
+        }
+        if (typeof beforeExit !== 'function') clear()
+        try {
+          const result = Reflect.apply(callback, this, callbackArgs)
+          if (!completed) {
+            // A successful legacy callback installs a new listener while waiting for event-loop drain.
+            const replacement = getDataProperty(globalThis, BEFORE_EXIT)
+            if (typeof replacement !== 'function' || replacement === beforeExit ||
+                !wrapCompletion(globalThis, BEFORE_EXIT, clear, completionMethods)) clear()
+            else callbackPending = true
+          }
+          return result
+        } catch (error) {
+          clear()
+          throw error
+        }
+      }
     }
-    clearTimeout(__lambdaTimeout)
-    return result
+
+    try {
+      // The outer completion adapter owns this context during synchronous dispatch to nested wrappers.
+      monitoredContexts.add(context)
+      const result = Reflect.apply(lambdaHandler, this, args)
+      if (result && typeof result.then === 'function') {
+        return result.then(value => {
+          clearOnHandlerCompletion()
+          return value
+        }, error => {
+          clearOnHandlerCompletion()
+          throw error
+        })
+      }
+      // Legacy RIC supplies a callback; newer runtimes complete from the return value.
+      if (!callbackObservable) clear()
+      return result
+    } catch (error) {
+      clearOnHandlerCompletion()
+      throw error
+    } finally {
+      monitoredContexts.delete(context)
+    }
+  }
+
+  if (normalized) return monitored
+
+  // datadog-lambda-js uses arity and the runtime's streaming metadata to choose how to invoke the handler.
+  Object.defineProperty(monitored, 'length', { value: getDataProperty(lambdaHandler, 'length') ?? 0 })
+  for (const name of [HANDLER_STREAMING, HANDLER_HIGHWATERMARK, '_ddWrapped']) {
+    const value = getDataProperty(lambdaHandler, name)
+    if (value !== undefined) monitored[name] = value
+  }
+  if (!isProxy(lambdaHandler)) {
+    for (const name of Reflect.ownKeys(lambdaHandler)) {
+      if (name === 'arguments' || name === 'caller') continue
+      const descriptor = Object.getOwnPropertyDescriptor(lambdaHandler, name)
+      if (!Object.hasOwn(descriptor, 'value')) continue
+      const existing = Object.getOwnPropertyDescriptor(monitored, name)
+      if (existing?.configurable === false) {
+        // Intrinsic function slots such as prototype cannot change their descriptor shape.
+        if (existing.writable) {
+          Object.defineProperty(monitored, name, { value: descriptor.value, writable: descriptor.writable })
+        }
+      } else {
+        Object.defineProperty(monitored, name, descriptor)
+      }
+    }
+  }
+  return monitored
+}
+
+/**
+ * @param {object} target
+ * @param {string | symbol} name
+ * @param {() => void} clear
+ * @param {Array<[object, string | symbol, Function, Function]>} completionMethods
+ */
+function wrapCompletion (target, name, clear, completionMethods) {
+  try {
+    const original = target[name]
+    if (typeof original !== 'function') return true
+    const wrapped = onCompletion(original, clear)
+    if (!Reflect.set(target, name, wrapped) || target[name] !== wrapped) return false
+    completionMethods.push([target, name, original, wrapped])
+    return true
+  } catch (error) {
+    log.error('Error wrapping Lambda completion %s: %s', name, error)
+    return false
+  }
+}
+
+/**
+ * @param {Function} callback
+ * @param {() => void} clear
+ */
+function onCompletion (callback, clear) {
+  return function (...args) {
+    clear()
+    return Reflect.apply(callback, this, args)
+  }
+}
+
+/**
+ * Reads metadata without executing application getters or Proxy traps.
+ *
+ * @param {unknown} target
+ * @param {string | symbol} name
+ */
+function getDataProperty (target, name) {
+  if (target === null || (typeof target !== 'object' && typeof target !== 'function')) return
+  while (target !== null && !isProxy(target)) {
+    const descriptor = Object.getOwnPropertyDescriptor(target, name)
+    if (descriptor) return descriptor.value
+    target = Object.getPrototypeOf(target)
   }
 }

package/packages/dd-trace/src/lambda/index.js

@@ -41,7 +41,6 @@ if (!getValueFromEnvSources('DD_TRACE_DISABLED_INSTRUMENTATIONS')?.split(',').in
 
       return moduleExports
     })
-    return
   }
 
   const moduleToPatch = 'datadog-lambda-js'
@@ -62,4 +61,19 @@ if (!getValueFromEnvSources('DD_TRACE_DISABLED_INSTRUMENTATIONS')?.split(',').in
 
     return moduleExports
   })
+
+  // The published datadog-lambda-js ESM entrypoint imports this helper before initializing the tracer.
+  // Revisit cached copies through the registered hook without loading datadog-lambda-js early.
+  const helperSuffixes = [
+    path.join('datadog-lambda-js', 'dist', 'utils', 'handler.js'),
+    path.join('datadog-lambda-js', 'utils', 'handler.js'),
+  ]
+  for (const filename of Object.keys(require.cache)) {
+    if (!helperSuffixes.some(suffix => filename.endsWith(path.sep + suffix))) continue
+    try {
+      require(filename)
+    } catch (error) {
+      log.error('Error executing cached lambda hook for datadog-lambda-js: %s', error)
+    }
+  }
 }

package/packages/dd-trace/src/lambda/runtime/patch.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const path = require('path')
+const { types: { isModuleNamespaceObject } } = require('node:util')
 
 const { datadog } = require('../handler')
 const { addHook } = require('../../../../datadog-instrumentations/src/helpers/instrument')
@@ -23,22 +24,48 @@ function patchDatadogLambdaHandler (datadogHandler) {
   return userHandler => datadogHandler(datadog(userHandler))
 }
 
+/**
+ * Wraps datadog-lambda-js's promisifiedHandler factory, which wraps the customer's handler.
+ * The timeout monitor surrounds that adapter to observe the completion Promise selected by datadog-lambda-js.
+ * Legacy RIC completes returned Promises through context.succeed without waiting for event-loop drain.
+ *
+ * @param {object} moduleExports
+ */
+function patchPromisifiedHandlerModule (moduleExports) {
+  shimmer.wrap(moduleExports, 'promisifiedHandler', promisify => {
+    return handler => datadog(promisify(handler), true)
+  })
+  return moduleExports
+}
+
 /** @param {string} handlerPath */
 function patchLambdaModule (handlerPath) {
   return lambdaModule => {
-    shimmer.wrap(lambdaModule, handlerPath, patchLambdaHandler)
-    return lambdaModule
+    const descriptor = Object.getOwnPropertyDescriptor(lambdaModule, handlerPath)
+    if (typeof descriptor?.value === 'function') {
+      if (!descriptor.configurable && !descriptor.writable) return lambdaModule
+      // The monitor copies Lambda metadata without invoking application accessors or Proxy traps.
+      // Generic shimmer wrapping would copy the original properties back onto that safe wrapper.
+      descriptor.value = datadog(descriptor.value)
+      // Native ESM namespaces reject replacement even when their export reports writable: true.
+      const exports = isModuleNamespaceObject(lambdaModule)
+        ? Object.create(lambdaModule, Object.getOwnPropertyDescriptors(lambdaModule))
+        : lambdaModule
+      Object.defineProperty(exports, handlerPath, descriptor)
+      return exports
+    }
+    return shimmer.wrap(lambdaModule, handlerPath, datadog)
   }
 }
 
-/** @param {Function} lambdaHandler */
-function patchLambdaHandler (lambdaHandler) {
-  return datadog(lambdaHandler)
-}
-
 const lambdaTaskRoot = getEnvironmentVariable('LAMBDA_TASK_ROOT')
 const originalLambdaHandler = getValueFromEnvSources('DD_LAMBDA_HANDLER')
 
+// Observe the completion Promise selected by datadog-lambda-js inside the invocation span's async scope.
+// The npm package keeps dist/; Lambda layer builds place its contents directly in the package root.
+addHook({ name: 'datadog-lambda-js', file: 'dist/utils/handler.js' }, patchPromisifiedHandlerModule)
+addHook({ name: 'datadog-lambda-js', file: 'utils/handler.js' }, patchPromisifiedHandlerModule)
+
 if (originalLambdaHandler === undefined) {
   addHook({ name: 'datadog-lambda-js' }, patchDatadogLambdaModule)
 } else {

package/packages/dd-trace/src/llmobs/agent-manifest.js

@@ -0,0 +1,296 @@
+'use strict'
+
+const log = require('../log')
+
+// Set by the SDK so a consumer can tell a hand-declared manifest from one read off a framework object.
+const MANUAL_FRAMEWORK_NAME = 'manual'
+
+// Provider-specific keys such as `extra_headers` can carry secrets, so only these are reported.
+const ALLOWED_MODEL_SETTINGS_KEYS = new Set([
+  'frequency_penalty',
+  'logit_bias',
+  'logprobs',
+  'max_tokens',
+  'parallel_tool_calls',
+  'presence_penalty',
+  'seed',
+  'stop_sequences',
+  'temperature',
+  'timeout',
+  'tool_choice',
+  'top_k',
+  'top_logprobs',
+  'top_p',
+])
+
+const LABEL_FIELDS = ['name', 'instructions', 'model']
+
+/**
+ * @typedef {{ type?: string, required?: true }} AgentToolParameter
+ * @typedef {{ name: string, description?: string, parameters?: Record<string, AgentToolParameter> }} AgentTool
+ * @typedef {{
+ *   name?: string,
+ *   instructions?: string,
+ *   model?: string,
+ *   model_settings?: Record<string, unknown>,
+ *   tools?: AgentTool[],
+ * }} AgentManifestFields
+ * @typedef {{ manifest: AgentManifestFields }} AgentDeclaration
+ */
+
+/**
+ * Reads the agent a caller declared through `annotate({ agent })` or `annotationContext({ agent })` into an
+ * immutable snapshot. Never throws, since the caller's object may carry throwing getters or be a revoked Proxy,
+ * and this runs while an LLMObs span is being registered.
+ *
+ * @param {unknown} agent
+ * @returns {AgentDeclaration | undefined} undefined when the agent declares nothing reportable
+ */
+function buildAgentDeclaration (agent) {
+  let declaration
+  try {
+    if (isPlainObject(agent)) {
+      const manifest = buildAgentManifest(agent)
+      if (manifest !== undefined) declaration = { manifest }
+    } else {
+      log.warn('Dropping agent annotation, the agent must be a plain object.')
+    }
+  } catch {
+    log.warn('Dropping agent annotation, its fields could not be read.')
+  }
+  return declaration
+}
+
+/**
+ * Validates each manifest field on its own, so one bad field cannot blank the rest. Unset values (`undefined`,
+ * `null`, `''`, `[]`, `{}`) are omitted so they declare nothing rather than erase an earlier declaration. Fields
+ * that are set but unreportable are dropped and logged by name, never by value.
+ *
+ * @param {Record<string, unknown>} agent
+ * @returns {AgentManifestFields | undefined}
+ */
+function buildAgentManifest (agent) {
+  /** @type {string[]} */
+  const dropped = []
+  /** @type {AgentManifestFields | undefined} */
+  let manifest
+
+  for (const key of LABEL_FIELDS) {
+    const value = agent[key]
+    if (isUnset(value)) continue
+    if (typeof value === 'string') {
+      manifest ??= {}
+      manifest[key] = value
+    } else {
+      dropped.push(key)
+    }
+  }
+
+  const modelSettings = buildModelSettings(agent.modelSettings, dropped)
+  if (modelSettings) {
+    manifest ??= {}
+    manifest.model_settings = modelSettings
+  }
+
+  const tools = buildTools(agent.tools, dropped)
+  if (tools) {
+    manifest ??= {}
+    manifest.tools = tools
+  }
+
+  if (dropped.length > 0) {
+    log.warn('Dropping unsupported agent manifest fields: %s', dropped.join(', '))
+  }
+
+  return manifest
+}
+
+/**
+ * @param {unknown} settings
+ * @param {string[]} dropped
+ * @returns {Record<string, unknown> | undefined}
+ */
+function buildModelSettings (settings, dropped) {
+  if (isUnset(settings)) return
+  if (!isPlainObject(settings)) {
+    dropped.push('modelSettings')
+    return
+  }
+
+  let allowed
+  for (const [key, value] of Object.entries(settings)) {
+    const wireKey = toSnakeCase(key)
+    if (!ALLOWED_MODEL_SETTINGS_KEYS.has(wireKey)) {
+      dropped.push(`modelSettings.${key}`)
+      continue
+    }
+    if (isUnset(value)) continue
+    const wireValue = toFlatScalarValue(value)
+    if (wireValue === null) continue
+    if (wireValue === undefined) {
+      dropped.push(`modelSettings.${key}`)
+      continue
+    }
+    allowed ??= {}
+    allowed[wireKey] = wireValue
+  }
+  return allowed
+}
+
+/**
+ * A JSON scalar, a flat array of scalars, or a flat object of numbers (`logit_bias`). No allowed setting nests, so
+ * anything deeper is dropped rather than coerced. Returns undefined for a value that cannot be reported, and null
+ * for an empty object, which declares nothing.
+ *
+ * @param {unknown} value
+ */
+function toFlatScalarValue (value) {
+  if (isScalar(value)) return value
+  if (Array.isArray(value)) {
+    const items = [...value]
+    for (const item of items) {
+      if (!isScalar(item)) return
+    }
+    return items
+  }
+  if (!isPlainObject(value)) return
+
+  const entries = Object.entries(value)
+  if (entries.length === 0) return null
+  for (const [, item] of entries) {
+    if (!isFiniteNumber(item)) return
+  }
+  // Built from entries so a key such as `__proto__` becomes an own property rather than setting the prototype.
+  return Object.fromEntries(entries)
+}
+
+/**
+ * @param {unknown} declared
+ * @param {string[]} dropped
+ * @returns {AgentTool[] | undefined}
+ */
+function buildTools (declared, dropped) {
+  if (isUnset(declared)) return
+  if (!Array.isArray(declared)) {
+    dropped.push('tools')
+    return
+  }
+
+  const tools = []
+  for (let index = 0; index < declared.length; index++) {
+    const tool = declared[index]
+    const name = isPlainObject(tool) ? tool.name : undefined
+    // An unnamed tool is unidentifiable once it ships.
+    if (typeof name !== 'string' || name === '') {
+      dropped.push(`tools[${index}]`)
+      continue
+    }
+
+    /** @type {AgentTool} */
+    const built = { name }
+    const description = tool.description
+    if (typeof description === 'string' && description !== '') built.description = description
+    const parameters = buildToolParameters(tool.parameters)
+    if (parameters === null) {
+      dropped.push(`tools[${index}].parameters`)
+    } else if (parameters) {
+      built.parameters = parameters
+    }
+    tools.push(built)
+  }
+  return tools.length > 0 ? tools : undefined
+}
+
+/**
+ * Flattens tool parameters to `{ param: { type?, required? } }`, the shape the Python framework integrations emit.
+ * `required` is omitted rather than reported false. Returns null for parameters that are set but not a plain
+ * object, such as a schema-library instance, so the caller can report them as dropped.
+ *
+ * @param {unknown} parameters
+ * @returns {Record<string, AgentToolParameter> | null | undefined}
+ */
+function buildToolParameters (parameters) {
+  if (isUnset(parameters)) return
+  if (!isPlainObject(parameters)) return null
+
+  const { specs, required } = toolParameterSpecs(parameters)
+  const flattened = []
+  for (const [param, spec] of Object.entries(specs)) {
+    /** @type {AgentToolParameter} */
+    const entry = {}
+    if (isPlainObject(spec)) {
+      const { type } = spec
+      if (typeof type === 'string' && type !== '') entry.type = type
+      if (spec.required === true) entry.required = true
+    }
+    if (required?.has(param)) entry.required = true
+    if (entry.type === undefined && entry.required === undefined) continue
+    flattened.push([param, entry])
+  }
+  // Built from entries so a parameter named `__proto__` becomes an own property rather than setting the prototype.
+  return flattened.length > 0 ? Object.fromEntries(flattened) : undefined
+}
+
+/**
+ * Accepts a JSON Schema object as well as the documented `{ param: { type, required } }` mapping, since a JSON
+ * Schema is what OpenAI, Gemini and MCP tool definitions carry. Two markers are required rather than `properties`
+ * alone, so a mapping that declares a parameter named `properties` is still read as a mapping.
+ *
+ * @param {Record<string, unknown>} parameters
+ * @returns {{ specs: Record<string, unknown>, required?: Set<unknown> }}
+ */
+function toolParameterSpecs (parameters) {
+  const { properties, required } = parameters
+  const hasRequiredList = Array.isArray(required)
+  if (!isPlainObject(properties) || !(parameters.type === 'object' || hasRequiredList)) {
+    return { specs: parameters }
+  }
+  return { specs: properties, required: hasRequiredList ? new Set(required) : undefined }
+}
+
+/**
+ * @param {string} key
+ */
+function toSnakeCase (key) {
+  return key.replaceAll(/[A-Z]/g, letter => `_${letter.toLowerCase()}`)
+}
+
+/**
+ * Class instances are rejected so a schema-library object (Zod, the AI SDK `jsonSchema()` wrapper) is dropped rather
+ * than read field by field into a misleading manifest.
+ *
+ * @param {unknown} value
+ * @returns {value is Record<string, unknown>}
+ */
+function isPlainObject (value) {
+  if (value === null || typeof value !== 'object') return false
+  const prototype = Object.getPrototypeOf(value)
+  return prototype === Object.prototype || prototype === null
+}
+
+/**
+ * @param {unknown} value
+ */
+function isUnset (value) {
+  if (value === undefined || value === null || value === '') return true
+  return Array.isArray(value) && value.length === 0
+}
+
+/**
+ * @param {unknown} value
+ */
+function isFiniteNumber (value) {
+  return typeof value === 'number' && Number.isFinite(value)
+}
+
+/**
+ * @param {unknown} value
+ */
+function isScalar (value) {
+  return typeof value === 'string' || typeof value === 'boolean' || isFiniteNumber(value)
+}
+
+module.exports = {
+  MANUAL_FRAMEWORK_NAME,
+  buildAgentDeclaration,
+}

package/packages/dd-trace/src/llmobs/audio-utils.js

@@ -106,8 +106,9 @@ function fitsInlineAudioBudget (byteLength, maxBytes = LLMOBS_AUDIO_INLINE_MAX_B
  * @returns {AudioPart | undefined}
  */
 function formatAudioPartWithGuard (audioBytes, mimeType, maxBytes = LLMOBS_AUDIO_INLINE_MAX_BYTES) {
-  if (!audioBytes?.length || !isRenderableAudioMime(mimeType)) return
-  if (!fitsInlineAudioBudget(audioBytes.length, maxBytes)) return
+  if (!audioBytes?.length || !isRenderableAudioMime(mimeType) || !fitsInlineAudioBudget(audioBytes.length, maxBytes)) {
+    return
+  }
 
   return formatAudioPart(audioBytes, mimeType)
 }

package/packages/dd-trace/src/llmobs/constants/tags.js

@@ -7,7 +7,11 @@ const CACHE_READ_INPUT_TOKENS_METRIC_KEY = 'cache_read_input_tokens'
 const CACHE_WRITE_INPUT_TOKENS_METRIC_KEY = 'cache_write_input_tokens'
 const CACHE_WRITE_5M_INPUT_TOKENS_METRIC_KEY = 'ephemeral_5m_input_tokens'
 const CACHE_WRITE_1H_INPUT_TOKENS_METRIC_KEY = 'ephemeral_1h_input_tokens'
+const CACHE_WRITE_30M_INPUT_TOKENS_METRIC_KEY = 'ephemeral_30m_input_tokens'
+const CACHE_WRITE_12H_INPUT_TOKENS_METRIC_KEY = 'ephemeral_12h_input_tokens'
 const REASONING_OUTPUT_TOKENS_METRIC_KEY = 'reasoning_output_tokens'
+const WEB_SEARCH_COUNT_METRIC_KEY = 'web_search_count'
+const STORAGE_SEARCH_COUNT_METRIC_KEY = 'storage_search_count'
 
 module.exports = {
   SPAN_KINDS: ['llm', 'agent', 'workflow', 'task', 'tool', 'embedding', 'retrieval', 'experiment'],
@@ -18,6 +22,7 @@ module.exports = {
   INTEGRATION: '_ml_obs.integration',
   METADATA: '_ml_obs.meta.metadata',
   COST_TAGS: '_ml_obs.meta.metadata._dd.cost_tags',
+  AGENT_MANIFEST: '_ml_obs.meta.metadata._dd.agent_manifest',
   METRICS: '_ml_obs.metrics',
   TOOL_DEFINITIONS: '_ml_obs.meta.tool_definitions',
   ML_APP: '_ml_obs.meta.ml_app',
@@ -71,7 +76,11 @@ module.exports = {
   CACHE_WRITE_INPUT_TOKENS_METRIC_KEY,
   CACHE_WRITE_5M_INPUT_TOKENS_METRIC_KEY,
   CACHE_WRITE_1H_INPUT_TOKENS_METRIC_KEY,
+  CACHE_WRITE_30M_INPUT_TOKENS_METRIC_KEY,
+  CACHE_WRITE_12H_INPUT_TOKENS_METRIC_KEY,
   REASONING_OUTPUT_TOKENS_METRIC_KEY,
+  WEB_SEARCH_COUNT_METRIC_KEY,
+  STORAGE_SEARCH_COUNT_METRIC_KEY,
 
   // integrations build metric objects with these camelCase spellings. Null prototype: a metric
   // named after an `Object.prototype` member must not resolve to an inherited property.
@@ -83,7 +92,11 @@ module.exports = {
     cacheWriteTokens: CACHE_WRITE_INPUT_TOKENS_METRIC_KEY,
     cacheWrite5mTokens: CACHE_WRITE_5M_INPUT_TOKENS_METRIC_KEY,
     cacheWrite1hTokens: CACHE_WRITE_1H_INPUT_TOKENS_METRIC_KEY,
+    cacheWrite30mTokens: CACHE_WRITE_30M_INPUT_TOKENS_METRIC_KEY,
+    cacheWrite12hTokens: CACHE_WRITE_12H_INPUT_TOKENS_METRIC_KEY,
     reasoningOutputTokens: REASONING_OUTPUT_TOKENS_METRIC_KEY,
+    webSearchCount: WEB_SEARCH_COUNT_METRIC_KEY,
+    storageSearchCount: STORAGE_SEARCH_COUNT_METRIC_KEY,
   }),
 
   DROPPED_IO_COLLECTION_ERROR: 'dropped_io',

package/packages/dd-trace/src/llmobs/experiments/experiment.js

@@ -253,7 +253,7 @@ class Experiment {
     this.#external = options.external === true
     if (!this.#external) {
       if (!options.dataset) throw new Error('Experiment dataset is required')
-      if (typeof options.task !== 'function') throw new Error('Experiment task is required')
+      if (typeof options.task !== 'function') throw new TypeError('Experiment task is required')
     }
 
     this.#client = client