dd-trace 6.20.0 → 6.21.0

package/packages/dd-trace/src/debugger/probe_sampler.js

@@ -2,6 +2,7 @@
 
 const { types } = require('node:util')
 
+const { storage } = require('../../../datadog-core')
 const { MAX_SNAPSHOTS_PER_SECOND_GLOBALLY } = require('./devtools_client/defaults')
 const { MAX_MESSAGE_LENGTH } = require('./constants')
 const { EVENT_TYPE, SKIPPED_REASON } = require('./guardrail-metrics')
@@ -32,6 +33,20 @@ const ddTraceGlobal = /** @type {Record<symbol, SharedArrayBuffer | object | und
  * @property {{ DD_DYNAMIC_INSTRUMENTATION_EVALUATION_TIMEOUT_MS: number }} dynamicInstrumentation
  */
 
+/**
+ * The trace object shared by all spans of a trace in this process (`DatadogSpanContext#_trace`).
+ *
+ * @typedef {{ started: object[] }} LocalTrace
+ */
+
+/**
+ * The span active in the current async context, as stored in the legacy storage by the tracer.
+ *
+ * @typedef {{ context: () => { _trace: LocalTrace } }} ActiveSpan
+ */
+
+const legacyStorage = storage('legacy')
+
 let evaluationTimeoutNs = 0n
 
 module.exports = {
@@ -63,6 +78,14 @@ function installProbeSampler (guardrailMetrics, config) {
   const buffer = createProbeSamplerBuffer()
 
   const lastCaptureNsByProbeId = new Map()
+  /**
+   * The coordinated sampling decision of each trace in which a snapshot-producing probe was hit: `false` if the trace
+   * was dropped, otherwise the sampling indexes of the probes that already emitted a snapshot in it. Keyed weakly, so
+   * a decision is released together with its trace.
+   *
+   * @type {WeakMap<LocalTrace, Set<number> | false>}
+   */
+  const emittedProbesByTrace = new WeakMap()
   /**
    * Probes that are skipped at entry because a recent evaluation failed or exceeded its time budget. One error result
    * is reported per throttle window, so the probe stays visible without repeatedly paying for the evaluation.
@@ -219,7 +242,10 @@ function installProbeSampler (guardrailMetrics, config) {
   }
 
   /**
-   * Apply the per-probe and global rate limits and store the sampled probe index for the debugger worker.
+   * Decide if a probe hit should be sampled and store the sampled probe index for the debugger worker.
+   *
+   * Snapshot-producing probes hit within an active trace share one sampling decision per trace, so a trace emits the
+   * snapshots of all of its probes or none of them. Other hits are sampled independently.
    *
    * @param {number} probeIndex - The worker-side probe sampling index.
    * @param {string} probeId - The probe id.
@@ -228,29 +254,100 @@ function installProbeSampler (guardrailMetrics, config) {
    * @param {boolean} isSnapshotProducingProbe - Whether this probe counts toward the global snapshot sample limit.
    */
   function sample (probeIndex, probeId, now, nsBetweenSampling, isSnapshotProducingProbe) {
+    if (isSnapshotProducingProbe === true) {
+      const span = /** @type {ActiveSpan | null | undefined} */ (legacyStorage.getStore()?.span)
+      const trace = span?.context()._trace
+      // The span processor empties `started` once all spans of a trace have finished. A probe hit under such a trace
+      // runs in a context that outlived it, e.g. a connection pool or event emitter callback bound to a request that
+      // has since ended. Coordinating that hit would let a decision made for the old request silence the probe, or
+      // limit it to a single snapshot, for as long as the context lives, so it's sampled independently instead.
+      if (trace !== undefined && trace.started.length !== 0) {
+        return sampleInTrace(trace, probeIndex, probeId, now, nsBetweenSampling)
+      }
+    }
+
+    if (isRateLimited(probeId, now, nsBetweenSampling, isSnapshotProducingProbe)) return false
+    return commitSample(probeIndex, probeId, now, isSnapshotProducingProbe)
+  }
+
+  /**
+   * Sample a snapshot-producing probe hit using the sampling decision of its trace. The first such probe hit in the
+   * trace makes the decision for all of them, subject to its per-probe rate limit and the global snapshot rate limit.
+   * If the trace is sampled, each probe then emits once in it without being subject to the rate limits, so the trace
+   * emits a complete set of snapshots. Those snapshots still count toward the rate limits, which keeps the overall
+   * volume close to the limits by making later traces less likely to be sampled.
+   *
+   * @param {LocalTrace} trace - The trace the probe was hit in.
+   * @param {number} probeIndex - The worker-side probe sampling index.
+   * @param {string} probeId - The probe id.
+   * @param {bigint} now - The current time.
+   * @param {bigint} nsBetweenSampling - Minimum nanoseconds between samples for this probe.
+   */
+  function sampleInTrace (trace, probeIndex, probeId, now, nsBetweenSampling) {
+    const emittedProbes = emittedProbesByTrace.get(trace)
+
+    if (emittedProbes === undefined) {
+      if (isRateLimited(probeId, now, nsBetweenSampling, true)) {
+        emittedProbesByTrace.set(trace, false)
+        return false
+      }
+      // If the sampled probe can't be handed over, no decision is made, so the next probe hit in the trace makes it
+      if (!commitSample(probeIndex, probeId, now, true)) return false
+      emittedProbesByTrace.set(trace, new Set([probeIndex]))
+      return true
+    }
+
+    if (emittedProbes === false || emittedProbes.has(probeIndex)) {
+      guardrailMetrics.eventSkipped(SKIPPED_REASON.RATE_LIMIT_PROBE, EVENT_TYPE.SNAPSHOT)
+      return false
+    }
+
+    if (!commitSample(probeIndex, probeId, now, true)) return false
+    emittedProbes.add(probeIndex)
+    return true
+  }
+
+  /**
+   * Check the per-probe and global rate limits, recording the skip if a limit is reached.
+   *
+   * @param {string} probeId - The probe id.
+   * @param {bigint} now - The current time.
+   * @param {bigint} nsBetweenSampling - Minimum nanoseconds between samples for this probe.
+   * @param {boolean} isSnapshotProducingProbe - Whether this probe is subject to the global snapshot sample limit.
+   */
+  function isRateLimited (probeId, now, nsBetweenSampling, isSnapshotProducingProbe) {
     const lastCaptureNs = lastCaptureNsByProbeId.get(probeId)
     if (lastCaptureNs !== undefined && now - lastCaptureNs < nsBetweenSampling) {
       guardrailMetrics.eventSkipped(
         SKIPPED_REASON.RATE_LIMIT_PROBE,
         isSnapshotProducingProbe === true ? EVENT_TYPE.SNAPSHOT : EVENT_TYPE.LOG
       )
-      return false
+      return true
     }
 
-    let shouldResetGlobalSnapshotRateWindow = false
-    if (isSnapshotProducingProbe === true) {
-      if (now - globalSnapshotSamplingRateWindowStart > oneSecondNs) {
-        shouldResetGlobalSnapshotRateWindow = true
-      } else if (snapshotsSampledWithinTheLastSecond >= MAX_SNAPSHOTS_PER_SECOND_GLOBALLY) {
-        guardrailMetrics.eventSkipped(SKIPPED_REASON.RATE_LIMIT_GLOBAL, EVENT_TYPE.SNAPSHOT)
-        return false
-      }
+    if (isSnapshotProducingProbe === true &&
+        now - globalSnapshotSamplingRateWindowStart <= oneSecondNs &&
+        snapshotsSampledWithinTheLastSecond >= MAX_SNAPSHOTS_PER_SECOND_GLOBALLY) {
+      guardrailMetrics.eventSkipped(SKIPPED_REASON.RATE_LIMIT_GLOBAL, EVENT_TYPE.SNAPSHOT)
+      return true
     }
 
+    return false
+  }
+
+  /**
+   * Store the sampled probe index for the debugger worker and count the sample toward the rate limits.
+   *
+   * @param {number} probeIndex - The worker-side probe sampling index.
+   * @param {string} probeId - The probe id.
+   * @param {bigint} now - The current time.
+   * @param {boolean} isSnapshotProducingProbe - Whether this probe counts toward the global snapshot sample limit.
+   */
+  function commitSample (probeIndex, probeId, now, isSnapshotProducingProbe) {
     if (!storeSampledProbeIndex(probeIndex)) return false
 
     if (isSnapshotProducingProbe === true) {
-      if (shouldResetGlobalSnapshotRateWindow === true) {
+      if (now - globalSnapshotSamplingRateWindowStart > oneSecondNs) {
         snapshotsSampledWithinTheLastSecond = 1
         globalSnapshotSamplingRateWindowStart = now
       } else {

package/packages/dd-trace/src/exporters/common/request.js

@@ -6,6 +6,7 @@
 const { Readable } = require('stream')
 const http = require('http')
 const https = require('https')
+const { URL } = require('url')
 const zlib = require('zlib')
 
 const { storage } = require('../../../../datadog-core')

package/packages/dd-trace/src/exporters/common/url.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const net = require('node:net')
-const { format } = require('node:url')
+const { format, URL } = require('node:url')
 
 const { urlToHttpOptions } = require('./url-to-http-options-polyfill')
 

package/packages/dd-trace/src/id.js

@@ -2,8 +2,6 @@
 
 const { randomFillSync } = require('crypto')
 
-const { channel } = require('dc-polyfill')
-
 const UINT_MAX = 4_294_967_296
 
 const data = new Uint8Array(8 * 8192)
@@ -11,8 +9,6 @@ const zeroId = new Uint8Array(8)
 
 let batch = 0
 
-channel('datadog:identity:update').subscribe(reseed)
-
 // Internal representation of a trace or span ID.
 class Identifier {
   /** @type {number[] | Uint8Array} */
@@ -267,3 +263,4 @@ module.exports = function createIdentifier (value, radix) {
 }
 
 module.exports.Identifier = Identifier
+module.exports.reseed = reseed

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/constants/tags.js

@@ -18,6 +18,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',

package/packages/dd-trace/src/llmobs/sdk.js

@@ -29,6 +29,8 @@ const {
   getFunctionArguments,
   validateKind,
 } = require('./util')
+const { buildAgentDeclaration } = require('./agent-manifest')
+/** @typedef {import('./agent-manifest').AgentDeclaration} AgentDeclaration */
 const { storage } = require('./storage')
 const telemetry = require('./telemetry')
 const LLMObsTagger = require('./tagger')
@@ -300,7 +302,7 @@ class LLMObs extends NoopLLMObs {
         throw new Error('LLMObs span must have a span kind specified')
       }
 
-      const { inputData, outputData, metadata, metrics, tags, prompt, costTags, toolDefinitions } = options
+      const { inputData, outputData, metadata, metrics, tags, prompt, costTags, toolDefinitions, agent } = options
 
       const hasInputOrOutput = spanKind === 'experiment'
         ? inputData !== undefined || outputData !== undefined
@@ -338,6 +340,15 @@ class LLMObs extends NoopLLMObs {
       if (toolDefinitions != null) {
         this._tagger.tagToolDefinitions(span, toolDefinitions)
       }
+      if (agent != null) {
+        if (spanKind === 'agent') {
+          this._tagger.tagAgent(span, agent)
+        } else {
+          logger.warn(
+            'Dropping agent annotation on non-agent span kind, annotating agents is only supported for agent spans.'
+          )
+        }
+      }
     } catch (e) {
       if (e.ddErrorTag) {
         err = e.ddErrorTag
@@ -602,14 +613,20 @@ class LLMObs extends NoopLLMObs {
   annotationContext (options, fn) {
     if (!this.enabled) return fn()
 
+    /** @type {{ annotationContext?: object, agentDeclarations?: AgentDeclaration[] } | undefined} */
     const currentStore = storage.getStore()
-
+    const { agent, ...contextOptions } = options ?? {}
+    /** @type {{ annotationContext: object, agentDeclarations?: AgentDeclaration[] }} */
     const store = {
       ...currentStore,
-      annotationContext: {
-        ...currentStore?.annotationContext,
-        ...options,
-      },
+      annotationContext: { ...currentStore?.annotationContext, ...contextOptions },
+    }
+
+    if (agent != null) {
+      const declaration = buildAgentDeclaration(agent)
+      // Outside `annotationContext`, whose keys come from the caller. Outermost first, so nested declarations fold
+      // onto the outer ones.
+      if (declaration) store.agentDeclarations = [...(currentStore?.agentDeclarations ?? []), declaration]
     }
 
     return storage.run(store, fn)

package/packages/dd-trace/src/llmobs/span_processor.js

@@ -15,6 +15,7 @@ const {
   MODEL_PROVIDER,
   METADATA,
   COST_TAGS,
+  AGENT_MANIFEST,
   TOOL_DEFINITIONS,
   EXPERIMENT_INPUT,
   EXPERIMENT_OUTPUT,
@@ -43,6 +44,7 @@ const {
   DEFAULT_MODEL,
 } = require('./constants/tags')
 const { UNSERIALIZABLE_VALUE_TEXT } = require('./constants/text')
+const { MANUAL_FRAMEWORK_NAME } = require('./agent-manifest')
 const { setGenAiApmTags } = require('./gen-ai-tags')
 const telemetry = require('./telemetry')
 const LLMObsTagger = require('./tagger')
@@ -152,15 +154,26 @@ class LLMObsSpanProcessor {
       meta.model_provider = (mlObsTags[MODEL_PROVIDER] || DEFAULT_MODEL).toLowerCase()
     }
 
-    if (mlObsTags[METADATA] || mlObsTags[COST_TAGS]) {
+    const name = mlObsTags[NAME] || span._name
+    const agentManifest = spanKind === 'agent' ? mlObsTags[AGENT_MANIFEST] : undefined
+
+    if (mlObsTags[METADATA] || mlObsTags[COST_TAGS] || agentManifest) {
+      /** @type {Record<string, unknown>} */
       const metadata = {}
       if (mlObsTags[METADATA]) this.#addObject(mlObsTags[METADATA], metadata)
-      // Only seed `metadata._dd` when there's something to put in it (currently cost_tags). Mirrors
-      // dd-trace-py and the cross-language wire format enforced by system-tests — metadata-only
-      // spans must not carry an empty `_dd: {}` block.
+      // Only seed `metadata._dd` when there's something to put in it. Mirrors dd-trace-py and the
+      // cross-language wire format enforced by system-tests, so metadata-only spans must not carry
+      // an empty `_dd: {}` block.
       if (mlObsTags[COST_TAGS]) {
         this.#getDdMetadata(metadata).cost_tags = mlObsTags[COST_TAGS]
       }
+      if (agentManifest) {
+        this.#getDdMetadata(metadata).agent_manifest = {
+          framework: MANUAL_FRAMEWORK_NAME,
+          ...agentManifest,
+          name: agentManifest.name ?? name,
+        }
+      }
       meta.metadata = metadata
     }
 
@@ -227,8 +240,6 @@ class LLMObsSpanProcessor {
     const sessionId = mlObsTags[SESSION_ID]
     const parentId = mlObsTags[PARENT_ID_KEY]
 
-    const name = mlObsTags[NAME] || span._name
-
     const tags = this.#getTags(span, mlApp, sessionId, error)
     llmObsSpan._tags = tags