dd-trace 6.18.0 → 6.19.0

package/packages/dd-trace/src/llmobs/plugins/langchain/handlers/chat_model.js

@@ -38,19 +38,6 @@ class LangChainLLMObsChatModelHandler extends LangChainLLMObsHandler {
     }
 
     const outputMessages = []
-    let inputTokens = 0
-    let outputTokens = 0
-    let totalTokens = 0
-    let tokensSetTopLevel = false
-    const tokensPerRunId = {}
-
-    if (!isWorkflow) {
-      const tokens = this.checkTokenUsageChatOrLLMResult(results)
-      inputTokens = tokens.inputTokens
-      outputTokens = tokens.outputTokens
-      totalTokens = tokens.totalTokens
-      tokensSetTopLevel = totalTokens > 0
-    }
 
     for (const messageSet of results.generations) {
       for (const chatCompletion of messageSet) {
@@ -59,35 +46,47 @@ class LangChainLLMObsChatModelHandler extends LangChainLLMObsHandler {
         const content = chatCompletionMessage.text || ''
         const toolCalls = this.extractToolCalls(chatCompletionMessage)
         outputMessages.push({ content, role, toolCalls })
-
-        if (!isWorkflow && !tokensSetTopLevel) {
-          const { tokens, runId } = this.checkTokenUsageFromAIMessage(chatCompletionMessage)
-          if (tokensPerRunId[runId]) {
-            tokensPerRunId[runId].inputTokens += tokens.inputTokens
-            tokensPerRunId[runId].outputTokens += tokens.outputTokens
-            tokensPerRunId[runId].totalTokens += tokens.totalTokens
-          } else {
-            tokensPerRunId[runId] = tokens
-          }
-        }
       }
     }
 
-    if (!isWorkflow && !tokensSetTopLevel) {
-      inputTokens = Object.values(tokensPerRunId).reduce((acc, val) => acc + val.inputTokens, 0)
-      outputTokens = Object.values(tokensPerRunId).reduce((acc, val) => acc + val.outputTokens, 0)
-      totalTokens = Object.values(tokensPerRunId).reduce((acc, val) => acc + val.totalTokens, 0)
-    }
-
     if (isWorkflow) {
       this._tagger.tagTextIO(span, inputMessages, outputMessages)
     } else {
       this._tagger.tagLLMIO(span, inputMessages, outputMessages)
-      this._tagger.tagMetrics(span, {
-        inputTokens,
-        outputTokens,
-        totalTokens,
-      })
+      this._tagger.tagMetrics(span, this.getTokenUsage(results))
+    }
+  }
+
+  /**
+   * @override
+   */
+  getTokenUsage (results) {
+    const tokens = this.checkTokenUsageChatOrLLMResult(results)
+    if (tokens.totalTokens > 0) return tokens
+
+    // providers that report usage on each generated message instead of on `llmOutput`; counts are
+    // summed per run so a run split across generations is totalled once
+    if (!results.generations) return tokens
+
+    const tokensPerRunId = {}
+    for (const messageSet of results.generations) {
+      for (const chatCompletion of messageSet) {
+        const { tokens: messageTokens, runId } = this.checkTokenUsageFromAIMessage(chatCompletion.message)
+        if (tokensPerRunId[runId]) {
+          tokensPerRunId[runId].inputTokens += messageTokens.inputTokens
+          tokensPerRunId[runId].outputTokens += messageTokens.outputTokens
+          tokensPerRunId[runId].totalTokens += messageTokens.totalTokens
+        } else {
+          tokensPerRunId[runId] = messageTokens
+        }
+      }
+    }
+
+    const perRun = Object.values(tokensPerRunId)
+    return {
+      inputTokens: perRun.reduce((acc, val) => acc + val.inputTokens, 0),
+      outputTokens: perRun.reduce((acc, val) => acc + val.outputTokens, 0),
+      totalTokens: perRun.reduce((acc, val) => acc + val.totalTokens, 0),
     }
   }
 

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

@@ -12,6 +12,16 @@ class LangChainLLMObsHandler {
 
   setMetaTags () {}
 
+  /**
+   * Token usage for a chat or LLM result. Subclasses widen this where the provider reports usage
+   * somewhere other than `llmOutput`.
+   *
+   * @param {object} results
+   */
+  getTokenUsage (results) {
+    return this.checkTokenUsageChatOrLLMResult(results)
+  }
+
   checkTokenUsageChatOrLLMResult (results) {
     const llmOutput = results.llmOutput
     const tokens = {

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

@@ -3,8 +3,6 @@
 const log = require('../../../log')
 const LLMObsPlugin = require('../base')
 
-const pluginManager = require('../../../../../..')._pluginManager
-
 const ANTHROPIC_PROVIDER_NAME = 'anthropic'
 const BEDROCK_PROVIDER_NAME = 'amazon_bedrock'
 const OPENAI_PROVIDER_NAME = 'openai'
@@ -76,6 +74,28 @@ class BaseLangChainLLMObsPlugin extends LLMObsPlugin {
     }
   }
 
+  /**
+   * @override
+   */
+  getGenAiApmEndTags (ctx, spanKind) {
+    // the helper reports zeros when the result carries no usage, and zeroed token metrics would
+    // read as a real measurement
+    const tokens = this._handlers[ctx.type]?.getTokenUsage(ctx.result ?? {})
+    const metrics = tokens?.totalTokens ? tokens : undefined
+
+    // langchain-openai calls an untraced beta client when `response_format` is set, so this span is
+    // the only model span for the call. `handlers/chat_model.js` applies the same correction through
+    // `changeKind` while building the LLMObs payload.
+    if (spanKind !== WORKFLOW || ctx.type !== 'chat_model' || !ctx.arguments?.[1]?.response_format) {
+      return { metrics }
+    }
+
+    const provider = ctx.currentStore?.span?.context().getTags()['langchain.request.provider']
+    const isOpenAI = this.getIntegrationName(ctx.type, provider) === OPENAI_PROVIDER_NAME
+
+    return isOpenAI ? { spanKind: LLM, metrics } : { metrics }
+  }
+
   setLLMObsTags (ctx) {
     ctx.args = ctx.arguments
     ctx.instance = ctx.self
@@ -158,6 +178,9 @@ class BaseLangChainLLMObsPlugin extends LLMObsPlugin {
   }
 
   isLLMIntegrationEnabled (integration) {
+    // read off the owning manager rather than a module-scope capture: the tracer, and with it the
+    // plugin manager, can be rebuilt after this module is first loaded
+    const pluginManager = this._tracer?._pluginManager
     return SUPPORTED_INTEGRATIONS.has(integration) && pluginManager?._pluginsByName[integration]?.llmobs?._enabled
   }
 }

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

@@ -14,15 +14,16 @@ class PregelStreamLLMObsPlugin extends LLMObsPlugin {
   getLLMObsSpanRegisterOptions (ctx) {
     const name = ctx.self.name || 'LangGraph'
 
-    const enabled = this._tracerConfig.llmobs.DD_LLMOBS_ENABLED
-    if (!enabled) return
-
     const span = ctx.currentStore?.span
     if (!span) return
-    streamDataMap.set(span, {
-      streamInputs: ctx.arguments?.[0],
-      chunks: [],
-    })
+
+    // only the LLMObs payload consumes the accumulated stream
+    if (this._llmobsEnabledFor(ctx)) {
+      streamDataMap.set(span, {
+        streamInputs: ctx.arguments?.[0],
+        chunks: [],
+      })
+    }
 
     return {
       kind: 'workflow',

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

@@ -74,6 +74,19 @@ class OpenAiLLMObsPlugin extends LLMObsPlugin {
     }
   }
 
+  /**
+   * @override
+   */
+  getGenAiApmEndTags (ctx) {
+    const response = ctx.result?.data
+
+    return {
+      // the response model is the resolved one, e.g. the dated version behind an alias
+      modelName: response?.model,
+      metrics: response && this._extractMetrics(response),
+    }
+  }
+
   setLLMObsTags (ctx) {
     const span = ctx.currentStore?.span
     const resource = ctx.methodName

package/packages/dd-trace/src/llmobs/plugins/openai/realtime.js

@@ -155,6 +155,11 @@ class RealtimeLLMObsPlugin extends LLMObsPlugin {
   static integration = 'openai'
   static system = 'openai'
 
+  // The instrumentation retains a turn's audio only while these plugins are subscribed, and only
+  // the LLM Observability payload reads those bytes. Staying subscribed for the `gen_ai.*` tags
+  // alone would buffer megabytes per turn for no consumer, so realtime opts out.
+  static emitsGenAiApmTags = false
+
   /**
    * The instrumentation replays the turn with `traceSync`, which never publishes `asyncEnd`, so tag
    * on `end` instead — before the sibling tracing plugin's `end` finishes the span, since the LLM

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

@@ -23,6 +23,13 @@ class VertexAILLMObsPlugin extends LLMObsPlugin {
     }
   }
 
+  /**
+   * @override
+   */
+  getGenAiApmEndTags (ctx) {
+    return { metrics: extractMetrics(ctx.result) }
+  }
+
   setLLMObsTags (ctx) {
     const span = ctx.currentStore?.span
     if (!span) return

package/packages/dd-trace/src/llmobs/prompts/prompt.js

@@ -2,7 +2,8 @@
 
 /** @typedef {import('../../../../../index').llmobs.FormattedPromptMessage} FormattedPromptMessage */
 
-const VARIABLE_PATTERN = /(?<!\{)(?:\{\{\s*(\w+)\s*\}\}(?!\})|\{\s*(\w+)\s*\}(?!\}))/g
+// Match double braces first; preserve surrounding braces such as the closing object in {"age": {age}}.
+const VARIABLE_PATTERN = /\{\{\s*(\w+)\s*\}\}|\{\s*(\w+)\s*\}/g
 
 function isMessage (value) {
   return typeof value?.role === 'string' &&

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

@@ -38,41 +38,13 @@ const {
   SAMPLE_RATE,
   SAMPLING_DECISION,
   TRACE_ID,
-  INPUT_TOKENS_METRIC_KEY,
-  OUTPUT_TOKENS_METRIC_KEY,
-  TOTAL_TOKENS_METRIC_KEY,
-  CACHE_READ_INPUT_TOKENS_METRIC_KEY,
-  CACHE_WRITE_INPUT_TOKENS_METRIC_KEY,
-  REASONING_OUTPUT_TOKENS_METRIC_KEY,
-  GEN_AI_OPERATION_NAME,
-  GEN_AI_REQUEST_MODEL,
-  GEN_AI_PROVIDER_NAME,
-  GEN_AI_APPLICATION_NAME,
-  GEN_AI_CONVERSATION_ID,
-  GEN_AI_USAGE_INPUT_TOKENS_METRIC_KEY,
-  GEN_AI_USAGE_OUTPUT_TOKENS_METRIC_KEY,
-  GEN_AI_USAGE_TOTAL_TOKENS_METRIC_KEY,
-  GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS_METRIC_KEY,
-  GEN_AI_USAGE_CACHE_WRITE_INPUT_TOKENS_METRIC_KEY,
-  GEN_AI_USAGE_REASONING_OUTPUT_TOKENS_METRIC_KEY,
-  ARTIFICIAL_GEN_AI_TAGS,
+  DEFAULT_MODEL,
 } = require('./constants/tags')
 const { UNSERIALIZABLE_VALUE_TEXT } = require('./constants/text')
+const { setGenAiApmTags } = require('./gen-ai-tags')
 const telemetry = require('./telemetry')
 const LLMObsTagger = require('./tagger')
 
-const DEFAULT_MODEL = 'custom'
-const MODEL_BACKED_SPAN_KINDS = new Set(['llm', 'embedding'])
-
-const GEN_AI_TOKEN_METRIC_KEYS = [
-  [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],
-]
-
 class LLMObservabilitySpan {
   /**
    * @param {string} kind span kind
@@ -320,46 +292,19 @@ class LLMObsSpanProcessor {
   }
 
   /**
-   * 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
    */
   #setGenAiApmTags (span) {
     const mlObsTags = LLMObsTagger.tagMap.get(span)
-    const spanContext = span.context()
-    const spanKind = mlObsTags[SPAN_KIND]
-
-    if (spanKind) spanContext.setTag(GEN_AI_OPERATION_NAME, spanKind)
-
-    const modelName = mlObsTags[MODEL_NAME]
-    const modelProvider = mlObsTags[MODEL_PROVIDER]
-    const modelBacked = MODEL_BACKED_SPAN_KINDS.has(spanKind)
-    if (modelBacked) {
-      spanContext.setTag(GEN_AI_REQUEST_MODEL, modelName || DEFAULT_MODEL)
-      spanContext.setTag(GEN_AI_PROVIDER_NAME, (modelProvider || DEFAULT_MODEL).toLowerCase())
-    } else {
-      if (modelName) spanContext.setTag(GEN_AI_REQUEST_MODEL, modelName)
-      if (modelProvider) spanContext.setTag(GEN_AI_PROVIDER_NAME, modelProvider.toLowerCase())
-    }
-
-    const mlApp = mlObsTags[ML_APP]
-    if (mlApp) spanContext.setTag(GEN_AI_APPLICATION_NAME, mlApp)
-
-    const sessionId = mlObsTags[SESSION_ID]
-    if (sessionId) spanContext.setTag(GEN_AI_CONVERSATION_ID, sessionId)
-
-    const metrics = mlObsTags[METRICS]
-    // Other kinds carry unrelated metrics that would be misleading under a `gen_ai.usage.*` key.
-    if (modelBacked && metrics) {
-      for (const [metricKey, genAiKey] of GEN_AI_TOKEN_METRIC_KEYS) {
-        const value = metrics[metricKey]
-        if (value != null) spanContext.setTag(genAiKey, value)
-      }
-    }
 
-    // matches the value dd-trace-py writes
-    spanContext.setTag(ARTIFICIAL_GEN_AI_TAGS, 'true')
+    setGenAiApmTags(span, {
+      spanKind: mlObsTags[SPAN_KIND],
+      modelName: mlObsTags[MODEL_NAME],
+      modelProvider: mlObsTags[MODEL_PROVIDER],
+      mlApp: mlObsTags[ML_APP],
+      sessionId: mlObsTags[SESSION_ID],
+      metrics: mlObsTags[METRICS],
+    })
   }
 
   // For now, this only applies to metadata, as we let users annotate this field with any object

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

@@ -29,14 +29,7 @@ const {
   PROPAGATED_PARENT_AGENT_ID_KEY,
   PROPAGATED_PARENT_AGENT_NAME_KEY,
   ROOT_PARENT_ID,
-  CACHE_READ_INPUT_TOKENS_METRIC_KEY,
-  CACHE_WRITE_INPUT_TOKENS_METRIC_KEY,
-  CACHE_WRITE_5M_INPUT_TOKENS_METRIC_KEY,
-  CACHE_WRITE_1H_INPUT_TOKENS_METRIC_KEY,
-  INPUT_TOKENS_METRIC_KEY,
-  OUTPUT_TOKENS_METRIC_KEY,
-  TOTAL_TOKENS_METRIC_KEY,
-  REASONING_OUTPUT_TOKENS_METRIC_KEY,
+  METRIC_KEY_ALIASES,
   INTEGRATION,
   DECORATOR,
   PROPAGATED_ML_APP_KEY,
@@ -307,35 +300,8 @@ class LLMObsTagger {
   tagMetrics (span, metrics) {
     const filterdMetrics = {}
     for (const [key, value] of Object.entries(metrics)) {
-      let processedKey = key
-
       // processing these specifically for our metrics ingestion
-      switch (key) {
-        case 'inputTokens':
-          processedKey = INPUT_TOKENS_METRIC_KEY
-          break
-        case 'outputTokens':
-          processedKey = OUTPUT_TOKENS_METRIC_KEY
-          break
-        case 'totalTokens':
-          processedKey = TOTAL_TOKENS_METRIC_KEY
-          break
-        case 'cacheReadTokens':
-          processedKey = CACHE_READ_INPUT_TOKENS_METRIC_KEY
-          break
-        case 'cacheWriteTokens':
-          processedKey = CACHE_WRITE_INPUT_TOKENS_METRIC_KEY
-          break
-        case 'cacheWrite5mTokens':
-          processedKey = CACHE_WRITE_5M_INPUT_TOKENS_METRIC_KEY
-          break
-        case 'cacheWrite1hTokens':
-          processedKey = CACHE_WRITE_1H_INPUT_TOKENS_METRIC_KEY
-          break
-        case 'reasoningOutputTokens':
-          processedKey = REASONING_OUTPUT_TOKENS_METRIC_KEY
-          break
-      }
+      const processedKey = METRIC_KEY_ALIASES[key] ?? key
 
       if (typeof value === 'number') {
         filterdMetrics[processedKey] = value

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

@@ -1,6 +1,7 @@
 'use strict'
 
 const { VERSION } = require('../../../../../version')
+const { SDK_OTLP_EXPORT_KEY, SDK_SEMANTICS_KEY } = require('../../constants')
 const { registerResourceAttributeRefresh } = require('../resource-attributes')
 const OtlpHttpTraceExporter = require('./otlp_http_trace_exporter')
 
@@ -46,6 +47,10 @@ function buildResourceAttributes (config) {
   const { service, version, env, ...filteredTags } = config.tags
   Object.assign(resourceAttributes, filteredTags)
 
+  // Tracer-owned adoption markers; set after the global tags so a user tag can't contradict them.
+  resourceAttributes[SDK_OTLP_EXPORT_KEY] = 'true'
+  resourceAttributes[SDK_SEMANTICS_KEY] = config.DD_TRACE_OTEL_SEMANTICS_ENABLED ? 'otel' : 'datadog'
+
   if (config.OTEL_TRACES_SPAN_METRICS_ENABLED) {
     resourceAttributes['_dd.stats_computed'] = 'true'
   }

package/packages/dd-trace/src/plugins/util/test.js

@@ -2025,6 +2025,10 @@ function getModifiedFilesFromDiff (diff) {
     if (lineMatch && currentFile) {
       const start = Number(lineMatch.groups.start)
       const count = lineMatch.groups.count ? Number(lineMatch.groups.count) : 1
+      if (count === 0) {
+        // Keep the surviving line before a deletion so line-based consumers can match its scope.
+        result[currentFile].push(start)
+      }
       for (let j = 0; j < count; j++) {
         result[currentFile].push(start + j)
       }

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

@@ -12,8 +12,21 @@ let activeSSIHeuristics
 /** @type {import('./profiling') | undefined} */
 let profilingModule
 
+/**
+ * Configuration published while the profiler was finishing a shutdown export, waiting for that
+ * export to settle before it is acted on.
+ *
+ * @type {import('./config/config-base') | undefined}
+ */
+let deferredConfig
+
 function getProfilingModule () {
-  profilingModule ??= require('./profiling')
+  if (profilingModule === undefined) {
+    profilingModule = require('./profiling')
+    // The profiling layer never restarts itself; it only reports that a shutdown export has
+    // settled, which is when a configuration deferred during that window gets its decision.
+    profilingModule.profiler.on('stopped', applyDeferredConfig)
+  }
   return profilingModule
 }
 
@@ -25,6 +38,12 @@ function isStarted () {
   return profilingModule !== undefined && profilingModule.profiler.enabled
 }
 
+// A stopped profiler still exports one final profile, and until that settles it reports neither
+// the state a decision would be based on nor any willingness to start again.
+function isStopping () {
+  return profilingModule !== undefined && profilingModule.profiler.isStopping()
+}
+
 /** @type {typeof import('./profiling/ssi-heuristics') | undefined} */
 let ssiHeuristicsModule
 
@@ -57,8 +76,11 @@ function start (config) {
 }
 
 function stop () {
-  // A stop command for a profiler that has never been loaded is already satisfied. Once loaded,
-  // always forward it so the profiling layer can also cancel a restart queued during shutdown.
+  // An explicit stop is the latest desired state, so it retracts a configuration still waiting
+  // for an in-flight shutdown to settle.
+  deferredConfig = undefined
+
+  // A stop command for a profiler that has never been loaded is already satisfied.
   if (profilingModule === undefined) return
 
   try {
@@ -93,7 +115,17 @@ function runWithLabels (labels, fn) {
   return getProfilingModule().profiler.runWithLabels(labels, fn)
 }
 
-configUpdateChannel.subscribe((config) => {
+function applyDeferredConfig () {
+  const config = deferredConfig
+  if (config === undefined) return
+  deferredConfig = undefined
+  applyConfig(config)
+}
+
+/**
+ * @param {import('./config/config-base')} config - Tracer configuration
+ */
+function applyConfig (config) {
   const enabled = config.profiling.DD_PROFILING_ENABLED
   if (enabled === 'true') {
     // A non-auto value means the SSI heuristics no longer get a say; disable them so a trigger that
@@ -118,7 +150,9 @@ configUpdateChannel.subscribe((config) => {
       heuristics.start()
       heuristics.onTriggered(() => {
         // Explicit true/false publishes disable the heuristics, so reaching this callback guarantees
-        // the latest valid published value is still 'auto'.
+        // the latest valid published value is still 'auto'. A heuristic is only ever created for a
+        // profiler that is neither running nor stopping, and nothing can start that profiler behind
+        // an active heuristic's back, so this start can not collide with a shutdown in flight.
         if (!isStarted()) start(config)
         // The heuristic has made its decision, so release all of its listeners and timer before
         // dropping the module-level reference. This does not stop the profiler that was just
@@ -132,6 +166,18 @@ configUpdateChannel.subscribe((config) => {
     // like 'auto' or crash the customer application.
     log.warn('Unexpected DD_PROFILING_ENABLED value: %o', enabled)
   }
+}
+
+configUpdateChannel.subscribe((config) => {
+  // A shutdown export in flight makes every decision here unsafe: the profiler can not be
+  // started, and it does not yet report the state the auto branch would branch on. Defer instead,
+  // keeping only the latest configuration, exactly as a sequence of updates outside such a window
+  // would have left it.
+  if (isStopping()) {
+    deferredConfig = config
+    return
+  }
+  applyConfig(config)
 })
 
 globalThis[Symbol.for('dd-trace')].beforeExitHandlers.add(stop)

package/packages/dd-trace/src/profiling/profiler.js

@@ -61,7 +61,6 @@ class Profiler extends EventEmitter {
   #exporters
   #flushInterval
   #lastStart
-  #pendingStart
   #profileSeq = 0
   #profilers
   #spanFinishListener
@@ -87,6 +86,14 @@ class Profiler extends EventEmitter {
     return this.#enabled
   }
 
+  /**
+   * True while a stop()'s final collection is still encoding and exporting. The profiler no
+   * longer samples, but it also can not be started again until that settles and 'stopped' fires.
+   */
+  isStopping () {
+    return this.#stopping !== undefined
+  }
+
   /**
    * Declares the set of custom label keys that will be used with
    * {@link runWithLabels}. This is used for profile upload metadata and
@@ -184,12 +191,12 @@ class Profiler extends EventEmitter {
     if (this.#startFailed) return false
 
     // A prior stop()'s shutdown collection may still be encoding/exporting via #tags,
-    // #exporters and #endpointCounts. Wait for it to finish before this start() overwrites
-    // that shared state out from under it. Record the desired config rather than chaining
-    // straight onto #stopping, so a stop() arriving before it settles can cancel this restart.
+    // #exporters and #endpointCounts, which this start() would overwrite out from under it.
+    // Refuse rather than queue: the caller owns the decision of what to do once the shutdown
+    // settles, and by then its configuration may no longer be the one requested here. This is
+    // thrown outside the setup try/catch below so it does not count as a permanent start failure.
     if (this.#stopping) {
-      this.#pendingStart = config
-      return true
+      throw new Error('Cannot start the profiler while a shutdown collection is still in flight')
     }
 
     try {
@@ -294,11 +301,12 @@ class Profiler extends EventEmitter {
     this._timeoutInterval = this.#flushInterval
   }
 
+  /**
+   * Stops the profiler after collecting and exporting one final profile. That export outlives
+   * this call: {@link isStopping} returns true and start() throws until it settles, at which
+   * point a 'stopped' event is emitted.
+   */
   stop () {
-    // A stop() always reflects the latest desired state, so it cancels any restart queued by a
-    // start() that arrived while a prior shutdown collection was still in flight.
-    this.#pendingStart = undefined
-
     if (!this.enabled) return
 
     // collect and export current profiles
@@ -311,16 +319,12 @@ class Profiler extends EventEmitter {
       })
       .finally(() => {
         this.#stopping = undefined
-        if (this.#pendingStart) {
-          const config = this.#pendingStart
-          this.#pendingStart = undefined
-          // Unlike the synchronous entry point, nothing awaits this promise, so a throw here would
-          // become an unhandled rejection instead of a caught error.
-          try {
-            this.start(config)
-          } catch (error) {
-            log.error(error)
-          }
+        // Nothing awaits this promise, so a listener throwing here would become an unhandled
+        // rejection instead of reaching whoever requested the stop.
+        try {
+          this.emit('stopped')
+        } catch (error) {
+          log.error(error)
         }
       })
     this.#stop()

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

@@ -118,17 +118,20 @@ function Hook (modules, options, onrequire) {
     if (moduleLoadStartChannel.hasSubscribers) {
       moduleLoadStartChannel.publish(payload)
     }
-    let exports = origRequire.apply(this, arguments)
-    payload.module = exports
-    if (moduleLoadEndChannel.hasSubscribers) {
-      moduleLoadEndChannel.publish(payload)
-      exports = payload.module
+    let exports
+    try {
+      exports = origRequire.apply(this, arguments)
+      payload.module = exports
+    } finally {
+      // Failed loads must close the subscriber's load stack too. Leave module
+      // unset on failure and preserve the original exception for the caller.
+      if (moduleLoadEndChannel.hasSubscribers) {
+        moduleLoadEndChannel.publish(payload)
+        exports = payload.module
+      }
+      delete patching[moduleId]
     }
 
-    // The module has already been loaded,
-    // so the patching mark can be cleaned up.
-    delete patching[moduleId]
-
     if (builtin) {
       hooks = moduleHooks[moduleId]
       if (!hooks) return exports // abort if module name isn't on whitelist

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

@@ -7,7 +7,7 @@ const SpanSampler = require('./span_sampler')
 const GitMetadataTagger = require('./git_metadata_tagger')
 const processTags = require('./process-tags')
 const { applyHttpOtelSemantics } = require('./plugins/util/http-otel-semantics')
-const { APM_TRACING_ENABLED_KEY } = require('./constants')
+const { APM_TRACING_ENABLED_KEY, SDK_OTLP_EXPORT_KEY } = require('./constants')
 
 const startedSpans = new WeakSet()
 const finishedSpans = new WeakSet()
@@ -31,6 +31,7 @@ class SpanProcessor {
     this._processTags = config.DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED
       ? processTags.serialized
       : false
+    this._nativeExport = config.OTEL_TRACES_EXPORTER !== 'otlp'
   }
 
   sample (span) {
@@ -80,6 +81,10 @@ class SpanProcessor {
           if (stampApmDisabled) {
             formattedSpan.metrics[APM_TRACING_ENABLED_KEY] = 0
           }
+          // Stamped after formatting so a span tag with the same key can't override it.
+          if (isFirstSpanInChunk && this._nativeExport) {
+            formattedSpan.meta[SDK_OTLP_EXPORT_KEY] = 'false'
+          }
           isFirstSpanInChunk = false
           // Span stats read Datadog HTTP tag names from the formatted span, so
           // record them before the OTel rename — an export-only transform.