dd-trace 6.17.0 → 6.19.0

package/packages/dd-trace/src/llmobs/gen-ai-tags.js

@@ -0,0 +1,127 @@
+'use strict'
+
+const {
+  ARTIFICIAL_GEN_AI_TAGS,
+  CACHE_READ_INPUT_TOKENS_METRIC_KEY,
+  CACHE_WRITE_INPUT_TOKENS_METRIC_KEY,
+  DEFAULT_MODEL,
+  GEN_AI_APPLICATION_NAME,
+  GEN_AI_CONVERSATION_ID,
+  GEN_AI_OPERATION_NAME,
+  GEN_AI_PROVIDER_NAME,
+  GEN_AI_REQUEST_MODEL,
+  GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS_METRIC_KEY,
+  GEN_AI_USAGE_CACHE_WRITE_INPUT_TOKENS_METRIC_KEY,
+  GEN_AI_USAGE_INPUT_TOKENS_METRIC_KEY,
+  GEN_AI_USAGE_OUTPUT_TOKENS_METRIC_KEY,
+  GEN_AI_USAGE_REASONING_OUTPUT_TOKENS_METRIC_KEY,
+  GEN_AI_USAGE_TOTAL_TOKENS_METRIC_KEY,
+  INPUT_TOKENS_METRIC_KEY,
+  METRIC_KEY_ALIASES,
+  OUTPUT_TOKENS_METRIC_KEY,
+  REASONING_OUTPUT_TOKENS_METRIC_KEY,
+  TOTAL_TOKENS_METRIC_KEY,
+} = require('./constants/tags')
+
+/** @type {Set<string | undefined>} */
+const MODEL_BACKED_SPAN_KINDS = new Set(['llm', 'embedding'])
+
+// null prototype: a metric named after an `Object.prototype` member must not resolve to an
+// inherited property
+const GEN_AI_USAGE_METRIC_KEYS = Object.assign(Object.create(null), {
+  [INPUT_TOKENS_METRIC_KEY]: GEN_AI_USAGE_INPUT_TOKENS_METRIC_KEY,
+  [OUTPUT_TOKENS_METRIC_KEY]: GEN_AI_USAGE_OUTPUT_TOKENS_METRIC_KEY,
+  [TOTAL_TOKENS_METRIC_KEY]: GEN_AI_USAGE_TOTAL_TOKENS_METRIC_KEY,
+  [CACHE_READ_INPUT_TOKENS_METRIC_KEY]: GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS_METRIC_KEY,
+  [CACHE_WRITE_INPUT_TOKENS_METRIC_KEY]: GEN_AI_USAGE_CACHE_WRITE_INPUT_TOKENS_METRIC_KEY,
+  [REASONING_OUTPUT_TOKENS_METRIC_KEY]: GEN_AI_USAGE_REASONING_OUTPUT_TOKENS_METRIC_KEY,
+})
+
+/**
+ * @typedef {object} GenAiApmTags
+ * @property {string} [spanKind] LLMObs span kind
+ * @property {string} [modelName]
+ * @property {string} [modelProvider]
+ * @property {string} [mlApp]
+ * @property {string} [sessionId]
+ * @property {Record<string, unknown>} [metrics] LLMObs metrics, in either spelling
+ */
+
+/**
+ * Writes the scalar `gen_ai.*` attributes onto the APM span, so model, provider, application,
+ * conversation and token usage are searchable in APM. Message bodies stay off the APM span.
+ *
+ * @param {import('../opentracing/span')} span
+ * @param {GenAiApmTags} tags
+ */
+function setGenAiApmTags (span, tags) {
+  // mirrors the LLMObs span event: a model-backed span always reports a model and provider
+  updateGenAiApmTags(span, MODEL_BACKED_SPAN_KINDS.has(tags.spanKind)
+    ? { ...tags, modelName: tags.modelName || DEFAULT_MODEL, modelProvider: tags.modelProvider || DEFAULT_MODEL }
+    : tags)
+}
+
+/**
+ * Writes only the `gen_ai.*` attributes present in `tags`, for values an integration resolves
+ * after the span started. Absent fields keep whatever the span already carries.
+ *
+ * @param {import('../opentracing/span')} span
+ * @param {GenAiApmTags} tags
+ */
+function updateGenAiApmTags (span, { spanKind, modelName, modelProvider, mlApp, sessionId, metrics }) {
+  const spanContext = span.context()
+
+  // written ahead of the attributes it covers: a throw partway through would otherwise leave
+  // `gen_ai.*` tags behind with nothing marking them as tracer-emitted
+  if (spanKind || modelName || modelProvider || mlApp || sessionId) {
+    markArtificialGenAiTags(spanContext)
+  }
+
+  if (spanKind) spanContext.setTag(GEN_AI_OPERATION_NAME, spanKind)
+  if (modelName) spanContext.setTag(GEN_AI_REQUEST_MODEL, modelName)
+  if (modelProvider) spanContext.setTag(GEN_AI_PROVIDER_NAME, modelProvider.toLowerCase())
+  if (mlApp) spanContext.setTag(GEN_AI_APPLICATION_NAME, mlApp)
+  if (sessionId) spanContext.setTag(GEN_AI_CONVERSATION_ID, sessionId)
+  if (metrics) setGenAiApmUsageMetrics(span, spanKind, metrics)
+}
+
+/**
+ * @param {import('../opentracing/span_context')} spanContext
+ */
+function markArtificialGenAiTags (spanContext) {
+  spanContext.setTag(ARTIFICIAL_GEN_AI_TAGS, 'true')
+}
+
+/**
+ * Writes the `gen_ai.usage.*` metrics onto the APM span. Accepts both the LLMObs metric keys and
+ * the camelCase spellings integrations extract before the tagger normalizes them.
+ *
+ * @param {import('../opentracing/span')} span
+ * @param {string | undefined} spanKind LLMObs span kind
+ * @param {Record<string, unknown>} metrics
+ */
+function setGenAiApmUsageMetrics (span, spanKind, metrics) {
+  // Other kinds carry unrelated metrics that would be misleading under a `gen_ai.usage.*` key.
+  if (!MODEL_BACKED_SPAN_KINDS.has(spanKind)) return
+
+  const spanContext = span.context()
+
+  // ahead of the metrics, for the same reason `updateGenAiApmTags` marks before its scalars
+  markArtificialGenAiTags(spanContext)
+
+  for (const [key, value] of Object.entries(metrics)) {
+    if (typeof value !== 'number') continue
+
+    const genAiKey = GEN_AI_USAGE_METRIC_KEYS[METRIC_KEY_ALIASES[key] ?? key]
+    if (!genAiKey) continue
+
+    spanContext.setTag(genAiKey, value)
+  }
+}
+
+module.exports = {
+  MODEL_BACKED_SPAN_KINDS,
+  setGenAiApmTags,
+  setGenAiApmUsageMetrics,
+  updateGenAiApmTags,
+}

package/packages/dd-trace/src/llmobs/plugins/ai/ddTelemetry.js

@@ -89,6 +89,24 @@ class DdTelemetryPlugin extends BaseLLMObsPlugin {
     return { kind, name: getLlmObsSpanName(operation, ctx.attributes['ai.telemetry.functionId']) }
   }
 
+  /**
+   * @override
+   */
+  getGenAiApmEndTags (ctx, spanKind) {
+    if (spanKind !== 'llm' && spanKind !== 'embedding') return
+
+    const tags = /** @type {Record<string, string>} */ (getSpanTags(ctx))
+    const embeddingUsage = tags['ai.usage.tokens']
+
+    return {
+      modelName: tags['ai.model.id'],
+      modelProvider: getModelProvider(tags),
+      metrics: spanKind === 'embedding'
+        ? { inputTokens: embeddingUsage, totalTokens: embeddingUsage }
+        : getUsage(tags),
+    }
+  }
+
   /**
    * @override
    */

package/packages/dd-trace/src/llmobs/plugins/ai/vercelTelemetry.js

@@ -140,6 +140,20 @@ function formatLanguageModelOutputMessages (content) {
   return outputMessages
 }
 
+/**
+ * @param {object} [usage] AI SDK usage, from the result or the stream's `finish` chunk
+ * @returns {Record<string, number | undefined>}
+ */
+function extractUsageMetrics (usage) {
+  return {
+    inputTokens: usage?.inputTokens?.total,
+    cacheWriteTokens: usage?.inputTokens?.cacheWrite ?? 0,
+    cacheReadTokens: usage?.inputTokens?.cacheRead ?? 0,
+    outputTokens: usage?.outputTokens?.total,
+    reasoningOutputTokens: usage?.outputTokens?.reasoning ?? 0,
+  }
+}
+
 class VercelAiTelemetryPlugin extends BaseLLMObsPlugin {
   static id = 'ai_llmobs_vercel_telemetry'
   static integration = 'ai'
@@ -152,6 +166,13 @@ class VercelAiTelemetryPlugin extends BaseLLMObsPlugin {
     super(...arguments)
 
     this.addSub('dd-trace:vercel-ai:chunk', ({ ctx, chunk, done }) => {
+      if (!this._llmobsEnabledFor(ctx)) {
+        // only the token usage is needed, for the `gen_ai.usage.*` metrics; the message bodies and
+        // `ctx.result` are left to the LLMObs path
+        if (chunk?.type === 'finish') ctx.streamedUsage = chunk.usage
+        return
+      }
+
       ctx.chunks ??= []
       const chunks = ctx.chunks
       if (chunk) chunks.push(chunk)
@@ -202,6 +223,17 @@ class VercelAiTelemetryPlugin extends BaseLLMObsPlugin {
     super.asyncEnd(ctx)
   }
 
+  /**
+   * @override
+   */
+  getGenAiApmEndTags (ctx, spanKind) {
+    const usage = ctx.result?.usage ?? ctx.streamedUsage
+    if (!usage) return {}
+
+    // `embed` reports a single token count, the generation operations a structured breakdown
+    return { metrics: spanKind === 'embedding' ? { inputTokens: usage.tokens } : extractUsageMetrics(usage) }
+  }
+
   /**
    * @override
    */
@@ -367,14 +399,7 @@ class VercelAiTelemetryPlugin extends BaseLLMObsPlugin {
     if (!result) return
 
     // metrics
-    const { usage } = result
-    this._tagger.tagMetrics(span, {
-      inputTokens: usage?.inputTokens?.total,
-      cacheWriteTokens: usage?.inputTokens?.cacheWrite ?? 0,
-      cacheReadTokens: usage?.inputTokens?.cacheRead ?? 0,
-      outputTokens: usage?.outputTokens?.total,
-      reasoningOutputTokens: usage?.outputTokens?.reasoning ?? 0,
-    })
+    this._tagger.tagMetrics(span, extractUsageMetrics(result.usage))
   }
 
   setToolTags (span, ctx) {

package/packages/dd-trace/src/llmobs/plugins/anthropic/index.js

@@ -22,6 +22,13 @@ class AnthropicLLMObsPlugin extends LLMObsPlugin {
     super(...arguments)
 
     this.addSub('apm:anthropic:request:chunk', ({ ctx, chunk, done }) => {
+      if (!this._llmobsEnabledFor(ctx)) {
+        // only the token usage is needed, for the `gen_ai.usage.*` metrics; the message bodies
+        // and the aggregated response are left to the LLMObs path
+        if (chunk) ctx.streamedUsage = mergeChunkUsage(ctx.streamedUsage, chunk)
+        return
+      }
+
       ctx.chunks ??= []
       const chunks = ctx.chunks
       if (chunk) chunks.push(chunk)
@@ -36,9 +43,8 @@ class AnthropicLLMObsPlugin extends LLMObsPlugin {
             const { message } = chunk
             if (!message) continue
 
-            const { role, usage } = message
-            if (role) response.role = role
-            if (usage) response.usage = usage
+            if (message.role) response.role = message.role
+            response.usage = mergeChunkUsage(response.usage, chunk)
             break
           }
           case 'content_block_start': {
@@ -86,22 +92,10 @@ class AnthropicLLMObsPlugin extends LLMObsPlugin {
             break
           }
           case 'message_delta': {
-            const { delta } = chunk
-
-            const finishReason = delta?.stop_reason
+            const finishReason = chunk.delta?.stop_reason
             if (finishReason) response.finish_reason = finishReason
 
-            const { usage } = chunk
-            if (usage) {
-              const responseUsage = (response.usage ??= { input_tokens: 0, output_tokens: 0 })
-              responseUsage.output_tokens = usage.output_tokens
-
-              const cacheCreationTokens = usage.cache_creation_input_tokens
-              const cacheReadTokens = usage.cache_read_input_tokens
-              if (cacheCreationTokens) responseUsage.cache_creation_input_tokens = cacheCreationTokens
-              if (cacheReadTokens) responseUsage.cache_read_input_tokens = cacheReadTokens
-            }
-
+            response.usage = mergeChunkUsage(response.usage, chunk)
             break
           }
           case 'error': {
@@ -140,6 +134,13 @@ class AnthropicLLMObsPlugin extends LLMObsPlugin {
     return UNKNOWN_MODEL_PROVIDER
   }
 
+  /**
+   * @override
+   */
+  getGenAiApmEndTags (ctx) {
+    return { metrics: extractUsage(ctx.result ?? { usage: ctx.streamedUsage }) }
+  }
+
   setLLMObsTags (ctx) {
     const span = ctx.currentStore?.span
     if (!span) return
@@ -213,38 +214,73 @@ class AnthropicLLMObsPlugin extends LLMObsPlugin {
   }
 
   #tagAnthropicUsage (span, result) {
-    if (!result) return
+    const metrics = extractUsage(result)
+    if (metrics) this._tagger.tagMetrics(span, metrics)
+  }
+}
 
-    const { usage } = result
-    if (!usage) return
+/**
+ * Merges the token usage a streamed chunk carries into the usage accumulated so far.
+ *
+ * @param {Record<string, number> | undefined} usage
+ * @param {object} chunk
+ * @returns {Record<string, number> | undefined}
+ */
+function mergeChunkUsage (usage, chunk) {
+  if (chunk.type === 'message_start') {
+    // copied: the `message_delta` counts are merged into this object, and the chunk is handed back
+    // to the application
+    const startUsage = chunk.message?.usage
+    return startUsage ? { ...startUsage } : usage
+  }
 
-    const inputTokens = usage.input_tokens
-    const outputTokens = usage.output_tokens
-    const cacheWriteTokens = usage.cache_creation_input_tokens
-    const cacheReadTokens = usage.cache_read_input_tokens
+  if (chunk.type !== 'message_delta' || !chunk.usage) return usage
 
-    const metrics = {
-      inputTokens: (inputTokens ?? 0) + (cacheWriteTokens ?? 0) + (cacheReadTokens ?? 0),
-    }
+  const mergedUsage = usage ?? { input_tokens: 0, output_tokens: 0 }
+  mergedUsage.output_tokens = chunk.usage.output_tokens
+
+  const cacheCreationTokens = chunk.usage.cache_creation_input_tokens
+  const cacheReadTokens = chunk.usage.cache_read_input_tokens
+  if (cacheCreationTokens) mergedUsage.cache_creation_input_tokens = cacheCreationTokens
+  if (cacheReadTokens) mergedUsage.cache_read_input_tokens = cacheReadTokens
 
-    if (outputTokens) metrics.outputTokens = outputTokens
-    const totalTokens = metrics.inputTokens + (outputTokens ?? 0)
-    if (totalTokens) metrics.totalTokens = totalTokens
+  return mergedUsage
+}
 
-    if (cacheWriteTokens != null) metrics.cacheWriteTokens = cacheWriteTokens
-    if (cacheReadTokens != null) metrics.cacheReadTokens = cacheReadTokens
+/**
+ * @param {object} [result]
+ * @returns {Record<string, number> | undefined}
+ */
+function extractUsage (result) {
+  const usage = result?.usage
+  if (!usage) return
+
+  const inputTokens = usage.input_tokens
+  const outputTokens = usage.output_tokens
+  const cacheWriteTokens = usage.cache_creation_input_tokens
+  const cacheReadTokens = usage.cache_read_input_tokens
+
+  const metrics = {
+    inputTokens: (inputTokens ?? 0) + (cacheWriteTokens ?? 0) + (cacheReadTokens ?? 0),
+  }
 
-    const cacheCreation = usage.cache_creation
-    if (cacheCreation) {
-      metrics.cacheWrite5mTokens = cacheCreation.ephemeral_5m_input_tokens ?? 0
-      metrics.cacheWrite1hTokens = cacheCreation.ephemeral_1h_input_tokens ?? 0
-    } else if (cacheWriteTokens != null) {
-      metrics.cacheWrite5mTokens = cacheWriteTokens
-      metrics.cacheWrite1hTokens = 0
-    }
+  if (outputTokens) metrics.outputTokens = outputTokens
+  const totalTokens = metrics.inputTokens + (outputTokens ?? 0)
+  if (totalTokens) metrics.totalTokens = totalTokens
 
-    this._tagger.tagMetrics(span, metrics)
+  if (cacheWriteTokens != null) metrics.cacheWriteTokens = cacheWriteTokens
+  if (cacheReadTokens != null) metrics.cacheReadTokens = cacheReadTokens
+
+  const cacheCreation = usage.cache_creation
+  if (cacheCreation) {
+    metrics.cacheWrite5mTokens = cacheCreation.ephemeral_5m_input_tokens ?? 0
+    metrics.cacheWrite1hTokens = cacheCreation.ephemeral_1h_input_tokens ?? 0
+  } else if (cacheWriteTokens != null) {
+    metrics.cacheWrite5mTokens = cacheWriteTokens
+    metrics.cacheWrite1hTokens = 0
   }
+
+  return metrics
 }
 
 module.exports = AnthropicLLMObsPlugin

package/packages/dd-trace/src/llmobs/plugins/base.js

@@ -1,32 +1,89 @@
 'use strict'
 
 const log = require('../../log')
+const { PROPAGATED_SESSION_ID_KEY } = require('../constants/tags')
+const { MODEL_BACKED_SPAN_KINDS, setGenAiApmTags, updateGenAiApmTags } = require('../gen-ai-tags')
 const { storage: llmobsStorage } = require('../storage')
 const telemetry = require('../telemetry')
 
 const TracingPlugin = require('../../plugins/tracing')
 const LLMObsTagger = require('../tagger')
 
+/**
+ * @typedef {object} LLMObsSpanRegisterOptions
+ * @property {string} kind LLMObs span kind
+ * @property {string} [name]
+ * @property {string} [modelName]
+ * @property {string} [modelProvider]
+ * @property {string} [mlApp]
+ * @property {string} [sessionId]
+ */
+
 class LLMObsPlugin extends TracingPlugin {
+  /**
+   * Whether this integration emits the `gen_ai.*` APM attributes while LLM Observability is off.
+   * An integration sets this to `false` when staying subscribed would cost more than the tags are
+   * worth, and then behaves as it did before those attributes existed: disabled outright.
+   */
+  static emitsGenAiApmTags = true
+
   constructor (...args) {
     super(...args)
 
     this._tagger = new LLMObsTagger(this._tracerConfig, true)
   }
 
+  /**
+   * Whether the LLMObs layer is active. When it is not, the plugin stays subscribed but only
+   * emits the `gen_ai.*` APM attributes.
+   *
+   */
+  get _llmobsEnabled () {
+    return this._tracerConfig.llmobs.DD_LLMOBS_ENABLED
+  }
+
+  /**
+   * The mode one operation runs in, latched on first read. `llmobs.enable()` and `llmobs.disable()`
+   * flip the flag while operations are in flight, and an operation that switches track halfway
+   * reports neither: the tagger rejects a span the start never registered, and the reduced path
+   * has no start tags for its end hook to update. Every hook for a given operation reads it here
+   * so they all take the branch its start took.
+   *
+   * @param {object} ctx
+   */
+  _llmobsEnabledFor (ctx) {
+    ctx.llmobsEnabled ??= this._llmobsEnabled
+    return ctx.llmobsEnabled
+  }
+
   setLLMObsTags (ctx) {
     throw new Error('setLLMObsTags must be implemented by the subclass')
   }
 
+  /**
+   * The `gen_ai.*` values an integration can only resolve once the operation finished, such as
+   * token usage or a session id the response carries. Only used while LLMObs is disabled; the
+   * LLMObs layer reads them off the span event instead. Fields left out keep their start value.
+   *
+   * @param {object} ctx
+   * @param {string} spanKind LLMObs span kind resolved at span start
+   * @returns {import('../gen-ai-tags').GenAiApmTags | void}
+   */
+  getGenAiApmEndTags (ctx, spanKind) {}
+
+  /**
+   * @param {object} ctx
+   * @returns {LLMObsSpanRegisterOptions | undefined}
+   */
   getLLMObsSpanRegisterOptions (ctx) {
     throw new Error('getLLMObsSPanRegisterOptions must be implemented by the subclass')
   }
 
   start (ctx) {
-    // even though llmobs span events won't be enqueued if llmobs is disabled
-    // we should avoid doing any computations here (these listeners aren't disabled)
-    const enabled = this._tracerConfig.llmobs.DD_LLMOBS_ENABLED
-    if (!enabled) return
+    if (!this._llmobsEnabledFor(ctx)) {
+      this.#setGenAiApmTagsFromRegisterOptions(ctx)
+      return
+    }
 
     const parentStore = llmobsStorage.getStore()
     const apmStore = ctx.currentStore
@@ -52,8 +109,7 @@ class LLMObsPlugin extends TracingPlugin {
   }
 
   end (ctx) {
-    const enabled = this._tracerConfig.llmobs.DD_LLMOBS_ENABLED
-    if (!enabled) return
+    if (!this._llmobsEnabledFor(ctx)) return
 
     // only attempt to restore the context if the current span was an LLMObs span
     const apmStore = ctx.currentStore
@@ -65,10 +121,10 @@ class LLMObsPlugin extends TracingPlugin {
   }
 
   asyncEnd (ctx) {
-    // even though llmobs span events won't be enqueued if llmobs is disabled
-    // we should avoid doing any computations here (these listeners aren't disabled)
-    const enabled = this._tracerConfig.llmobs.DD_LLMOBS_ENABLED
-    if (!enabled) return
+    if (!this._llmobsEnabledFor(ctx)) {
+      this.#setGenAiApmEndTags(ctx)
+      return
+    }
 
     const apmStore = ctx.currentStore
     const span = apmStore?.span
@@ -83,12 +139,95 @@ class LLMObsPlugin extends TracingPlugin {
     this.setLLMObsTags(ctx)
   }
 
+  /**
+   * Resolves the LLMObs annotations the `gen_ai.*` APM attributes need from the span register
+   * options, which every integration already builds for the LLMObs layer.
+   *
+   * @param {object} ctx
+   */
+  #setGenAiApmTagsFromRegisterOptions (ctx) {
+    const span = ctx.currentStore?.span
+    if (!span) return
+
+    try {
+      const registerOptions = this.getLLMObsSpanRegisterOptions(ctx)
+      if (!registerOptions?.kind) return
+
+      // `asyncEnd` needs these back: the kind to gate the usage metrics, and the model in case an
+      // integration promotes the kind to one that must always report a model
+      ctx.genAiApmStartTags = {
+        spanKind: registerOptions.kind,
+        modelName: registerOptions.modelName,
+        modelProvider: registerOptions.modelProvider,
+        mlApp: registerOptions.mlApp,
+        sessionId: registerOptions.sessionId,
+      }
+
+      this._setGenAiApmTags(span, ctx.genAiApmStartTags)
+    } catch (e) {
+      log.debug('Failed to set gen_ai APM tags for %s:', this.constructor.name, e.message)
+    }
+  }
+
+  /**
+   * @param {object} ctx
+   */
+  #setGenAiApmEndTags (ctx) {
+    const span = ctx.currentStore?.span
+    const startTags = ctx.genAiApmStartTags
+    if (!span || !startTags) return
+
+    const { spanKind } = startTags
+
+    try {
+      const endTags = this.getGenAiApmEndTags(ctx, spanKind)
+      if (!endTags) return
+
+      // An integration may correct the kind, the way the tagger's `changeKind` does. A correction
+      // into a model-backed kind has to go back through `setGenAiApmTags`, which applies the model
+      // and provider defaults a model-backed span always reports; an update alone would leave the
+      // span claiming a kind the enabled path could never emit without a model.
+      const promotedToModelBacked = endTags.spanKind &&
+        endTags.spanKind !== spanKind &&
+        MODEL_BACKED_SPAN_KINDS.has(endTags.spanKind)
+
+      if (promotedToModelBacked) {
+        this._setGenAiApmTags(span, { ...startTags, ...endTags })
+      } else {
+        updateGenAiApmTags(span, { spanKind, ...endTags })
+      }
+    } catch (e) {
+      log.debug('Failed to set gen_ai APM end tags for %s:', this.constructor.name, e.message)
+    }
+  }
+
+  /**
+   * Writes the `gen_ai.*` APM attributes.
+   *
+   * No `gen_ai.application.name`: ml_app is an LLM Observability concept, and with LLMObs off the
+   * only value left to report is the service name the span already carries. dd-trace-py's reduced
+   * path leaves it out for the same reason.
+   *
+   * @param {import('../../opentracing/span')} span
+   * @param {import('../gen-ai-tags').GenAiApmTags} tags
+   */
+  _setGenAiApmTags (span, tags) {
+    // the in-process session default is written by the tagger, which never runs on this path, so
+    // an inherited session can only have come from an upstream service
+    const propagatedSessionId = span.context()._trace.tags[PROPAGATED_SESSION_ID_KEY]
+
+    setGenAiApmTags(span, { ...tags, sessionId: tags.sessionId || propagatedSessionId })
+  }
+
   configure (config) {
-    // we do not want to enable any LLMObs plugins if it is disabled on the tracer, or if the
-    // integration opted out via `tracer.use(<name>, { llmobs: false })`. Opting out only disables
-    // the LLMObs layer: the integration keeps emitting APM spans and propagating trace context.
-    const llmobsEnabled = this._tracerConfig.llmobs.DD_LLMOBS_ENABLED
-    if (llmobsEnabled === false || config?.llmobs === false) {
+    // an integration opt-out via `tracer.use(<name>, { llmobs: false })` disables the LLMObs layer
+    // entirely. When only LLMObs itself is disabled we stay subscribed: the handlers then emit the
+    // `gen_ai.*` APM attributes and skip the LLMObs payload, unless the integration opted out of
+    // those too.
+    const disabled = config?.llmobs === false ||
+      (!this._llmobsEnabled && !this.constructor.emitsGenAiApmTags)
+
+    if (disabled) {
       config = typeof config === 'boolean' ? false : { ...config, enabled: false } // override to false
     }
     super.configure(config)