dd-trace 5.46.0 → 5.47.0

package/packages/dd-trace/src/appsec/iast/taint-tracking/rewriter.js

@@ -4,44 +4,48 @@ const Module = require('module')
 const { pathToFileURL } = require('url')
 const { MessageChannel } = require('worker_threads')
 const shimmer = require('../../../../../datadog-shimmer')
-const { isPrivateModule, isNotLibraryFile } = require('./filter')
+const { isPrivateModule, isDdTrace } = require('./filter')
 const { csiMethods } = require('./csi-methods')
 const { getName } = require('../telemetry/verbosity')
-const { getRewriteFunction, incrementTelemetryIfNeeded } = require('./rewriter-telemetry')
+const telemetry = require('../telemetry')
+const { incrementTelemetryIfNeeded } = require('./rewriter-telemetry')
 const dc = require('dc-polyfill')
 const log = require('../../../log')
 const { isMainThread } = require('worker_threads')
 const { LOG_MESSAGE, REWRITTEN_MESSAGE } = require('./constants')
+const orchestrionConfig = require('../../../../../datadog-instrumentations/src/orchestrion-config')
 
+let config
 const hardcodedSecretCh = dc.channel('datadog:secrets:result')
 let rewriter
+let unwrapCompile = () => {}
 let getPrepareStackTrace, cacheRewrittenSourceMap
 let kSymbolPrepareStackTrace
 let esmRewriterEnabled = false
 
-let getRewriterOriginalPathAndLineFromSourceMap = function (path, line, column) {
-  return { path, line, column }
-}
-
 function isFlagPresent (flag) {
   return process.env.NODE_OPTIONS?.includes(flag) ||
     process.execArgv?.some(arg => arg.includes(flag))
 }
 
-function getGetOriginalPathAndLineFromSourceMapFunction (chainSourceMap, getOriginalPathAndLineFromSourceMap) {
-  if (chainSourceMap) {
-    return function (path, line, column) {
+let getRewriterOriginalPathAndLineFromSourceMap = function (path, line, column) {
+  return { path, line, column }
+}
+
+function setGetOriginalPathAndLineFromSourceMapFunction (chainSourceMap, { getOriginalPathAndLineFromSourceMap }) {
+  if (!getOriginalPathAndLineFromSourceMap) return
+
+  getRewriterOriginalPathAndLineFromSourceMap = chainSourceMap
+    ? (path, line, column) => {
       // if --enable-source-maps is present stacktraces of the rewritten files contain the original path, file and
       // column because the sourcemap chaining is done during the rewriting process so we can skip it
-      if (isPrivateModule(path) && isNotLibraryFile(path)) {
-        return { path, line, column }
-      } else {
-        return getOriginalPathAndLineFromSourceMap(path, line, column)
+        if (isPrivateModule(path) && !isDdTrace(path)) {
+          return { path, line, column }
+        } else {
+          return getOriginalPathAndLineFromSourceMap(path, line, column)
+        }
       }
-    }
-  } else {
-    return getOriginalPathAndLineFromSourceMap
-  }
+    : getOriginalPathAndLineFromSourceMap
 }
 
 function getRewriter (telemetryVerbosity) {
@@ -54,19 +58,16 @@ function getRewriter (telemetryVerbosity) {
       cacheRewrittenSourceMap = iastRewriter.cacheRewrittenSourceMap
 
       const chainSourceMap = isFlagPresent('--enable-source-maps')
-      const getOriginalPathAndLineFromSourceMap = iastRewriter.getOriginalPathAndLineFromSourceMap
-      if (getOriginalPathAndLineFromSourceMap) {
-        getRewriterOriginalPathAndLineFromSourceMap =
-          getGetOriginalPathAndLineFromSourceMapFunction(chainSourceMap, getOriginalPathAndLineFromSourceMap)
-      }
+      setGetOriginalPathAndLineFromSourceMapFunction(chainSourceMap, iastRewriter)
 
       rewriter = new Rewriter({
         csiMethods,
         telemetryVerbosity: getName(telemetryVerbosity),
-        chainSourceMap
+        chainSourceMap,
+        orchestrion: orchestrionConfig
       })
     } catch (e) {
-      log.error('[ASM] Unable to initialize TaintTracking Rewriter', e)
+      log.error('Unable to initialize Rewriter', e)
     }
   }
   return rewriter
@@ -74,6 +75,9 @@ function getRewriter (telemetryVerbosity) {
 
 let originalPrepareStackTrace
 function getPrepareStackTraceAccessor () {
+  if (!getPrepareStackTrace) {
+    getPrepareStackTrace = require('@datadog/wasm-js-rewriter/js/stack-trace').getPrepareStackTrace
+  }
   originalPrepareStackTrace = Error.prepareStackTrace
   let actual = getPrepareStackTrace(originalPrepareStackTrace)
   return {
@@ -89,25 +93,42 @@ function getPrepareStackTraceAccessor () {
 }
 
 function getCompileMethodFn (compileMethod) {
-  const rewriteFn = getRewriteFunction(rewriter)
-  return function (content, filename) {
+  let delegate = function (content, filename) {
     try {
-      if (isPrivateModule(filename) && isNotLibraryFile(filename)) {
-        const rewritten = rewriteFn(content, filename)
+      if (isDdTrace(filename)) {
+        return compileMethod.apply(this, [content, filename])
+      }
+      if (!isPrivateModule(filename) || !config.iast?.enabled) {
+        return compileMethod.apply(this, [content, filename])
+      }
+      // TODO when we have CJS support for orchestrion and taint-tracking, add
+      // them here as appropriate
+      const rewritten = rewriter.rewrite(content, filename, ['iast'])
 
-        if (rewritten?.literalsResult && hardcodedSecretCh.hasSubscribers) {
-          hardcodedSecretCh.publish(rewritten.literalsResult)
-        }
+      incrementTelemetryIfNeeded(rewritten.metrics)
 
-        if (rewritten?.content) {
-          return compileMethod.apply(this, [rewritten.content, filename])
-        }
+      if (rewritten?.literalsResult && hardcodedSecretCh.hasSubscribers) {
+        hardcodedSecretCh.publish(rewritten.literalsResult)
+      }
+
+      if (rewritten?.content) {
+        return compileMethod.apply(this, [rewritten.content, filename])
       }
     } catch (e) {
-      log.error('[ASM] Error rewriting file %s', filename, e)
+      log.error('Error rewriting file %s', filename, e)
     }
     return compileMethod.apply(this, [content, filename])
   }
+
+  const shim = function () {
+    return delegate.apply(this, arguments)
+  }
+
+  unwrapCompile = function () {
+    delegate = compileMethod
+  }
+
+  return shim
 }
 
 function esmRewritePostProcess (rewritten, filename) {
@@ -128,20 +149,31 @@ function esmRewritePostProcess (rewritten, filename) {
   }
 }
 
+let shimmedPrepareStackTrace = false
+function shimPrepareStackTrace () {
+  if (shimmedPrepareStackTrace) {
+    return
+  }
+  const pstDescriptor = Object.getOwnPropertyDescriptor(global.Error, 'prepareStackTrace')
+  if (!pstDescriptor || pstDescriptor.configurable) {
+    Object.defineProperty(global.Error, 'prepareStackTrace', getPrepareStackTraceAccessor())
+  }
+  shimmedPrepareStackTrace = true
+}
+
 function enableRewriter (telemetryVerbosity) {
   try {
-    const rewriter = getRewriter(telemetryVerbosity)
-    if (rewriter) {
-      const pstDescriptor = Object.getOwnPropertyDescriptor(global.Error, 'prepareStackTrace')
-      if (!pstDescriptor || pstDescriptor.configurable) {
-        Object.defineProperty(global.Error, 'prepareStackTrace', getPrepareStackTraceAccessor())
+    if (config.iast?.enabled) {
+      const rewriter = getRewriter(telemetryVerbosity)
+      if (rewriter) {
+        shimPrepareStackTrace()
+        shimmer.wrap(Module.prototype, '_compile', compileMethod => getCompileMethodFn(compileMethod))
       }
-      shimmer.wrap(Module.prototype, '_compile', compileMethod => getCompileMethodFn(compileMethod))
     }
 
     enableEsmRewriter(telemetryVerbosity)
   } catch (e) {
-    log.error('[ASM] Error enabling TaintTracking Rewriter', e)
+    log.error('Error enabling Rewriter', e)
   }
 }
 
@@ -155,6 +187,8 @@ function isEsmConfigured () {
 
 function enableEsmRewriter (telemetryVerbosity) {
   if (isMainThread && Module.register && !esmRewriterEnabled && isEsmConfigured()) {
+    shimPrepareStackTrace()
+
     esmRewriterEnabled = true
 
     const { port1, port2 } = new MessageChannel()
@@ -175,30 +209,31 @@ function enableEsmRewriter (telemetryVerbosity) {
     port1.unref()
     port2.unref()
 
-    const chainSourceMap = isFlagPresent('--enable-source-maps')
-    const data = {
-      port: port2,
-      csiMethods,
-      telemetryVerbosity,
-      chainSourceMap
-    }
-
     try {
       Module.register('./rewriter-esm.mjs', {
         parentURL: pathToFileURL(__filename),
         transferList: [port2],
-        data
+        data: {
+          port: port2,
+          csiMethods,
+          telemetryVerbosity,
+          chainSourceMap: isFlagPresent('--enable-source-maps'),
+          orchestrionConfig,
+          iastEnabled: config?.iast?.enabled
+        }
       })
     } catch (e) {
-      log.error('[ASM] Error enabling ESM Rewriter', e)
+      log.error('Error enabling ESM Rewriter', e)
       port1.close()
       port2.close()
     }
+
+    cacheRewrittenSourceMap = require('@datadog/wasm-js-rewriter/js/source-map').cacheRewrittenSourceMap
   }
 }
 
-function disableRewriter () {
-  shimmer.unwrap(Module.prototype, '_compile')
+function disable () {
+  unwrapCompile()
 
   if (!Error.prepareStackTrace?.[kSymbolPrepareStackTrace]) return
 
@@ -206,8 +241,10 @@ function disableRewriter () {
     delete Error.prepareStackTrace
 
     Error.prepareStackTrace = originalPrepareStackTrace
+
+    shimmedPrepareStackTrace = false
   } catch (e) {
-    log.warn('[ASM] Error disabling TaintTracking rewriter', e)
+    log.warn('Error disabling Rewriter', e)
   }
 }
 
@@ -215,6 +252,11 @@ function getOriginalPathAndLineFromSourceMap ({ path, line, column }) {
   return getRewriterOriginalPathAndLineFromSourceMap(path, line, column)
 }
 
+function enable (configArg) {
+  config = configArg
+  enableRewriter(telemetry.verbosity || 'OFF')
+}
+
 module.exports = {
-  enableRewriter, disableRewriter, getOriginalPathAndLineFromSourceMap
+  enable, disable, getOriginalPathAndLineFromSourceMap
 }

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

@@ -63,6 +63,8 @@ const otelDdEnvMapping = {
 
 const VALID_PROPAGATION_STYLES = new Set(['datadog', 'tracecontext', 'b3', 'b3 single header', 'none'])
 
+const VALID_PROPAGATION_BEHAVIOR_EXTRACT = new Set(['continue', 'restart', 'ignore'])
+
 const VALID_LOG_LEVELS = new Set(['debug', 'info', 'warn', 'error'])
 
 function getFromOtelSamplerMap (otelTracesSampler, otelTracesSamplerArg) {
@@ -584,6 +586,7 @@ class Config {
     this._setValue(defaults, 'traceId128BitGenerationEnabled', true)
     this._setValue(defaults, 'traceId128BitLoggingEnabled', true)
     this._setValue(defaults, 'tracePropagationExtractFirst', false)
+    this._setValue(defaults, 'tracePropagationBehaviorExtract', 'continue')
     this._setValue(defaults, 'tracePropagationStyle.inject', ['datadog', 'tracecontext', 'baggage'])
     this._setValue(defaults, 'tracePropagationStyle.extract', ['datadog', 'tracecontext', 'baggage'])
     this._setValue(defaults, 'tracePropagationStyle.otelPropagators', false)
@@ -746,6 +749,7 @@ class Config {
       DD_TRACE_PARTIAL_FLUSH_MIN_SPANS,
       DD_TRACE_PEER_SERVICE_MAPPING,
       DD_TRACE_PROPAGATION_EXTRACT_FIRST,
+      DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT,
       DD_TRACE_PROPAGATION_STYLE,
       DD_TRACE_PROPAGATION_STYLE_INJECT,
       DD_TRACE_PROPAGATION_STYLE_EXTRACT,
@@ -967,6 +971,11 @@ class Config {
     this._setBoolean(env, 'traceId128BitGenerationEnabled', DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED)
     this._setBoolean(env, 'traceId128BitLoggingEnabled', DD_TRACE_128_BIT_TRACEID_LOGGING_ENABLED)
     this._setBoolean(env, 'tracePropagationExtractFirst', DD_TRACE_PROPAGATION_EXTRACT_FIRST)
+    const stringPropagationBehaviorExtract = String(DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT)
+    this._setValue(env, 'tracePropagationBehaviorExtract',
+      VALID_PROPAGATION_BEHAVIOR_EXTRACT.has(stringPropagationBehaviorExtract)
+        ? stringPropagationBehaviorExtract
+        : 'continue')
     this._setBoolean(env, 'tracePropagationStyle.otelPropagators',
       DD_TRACE_PROPAGATION_STYLE ||
       DD_TRACE_PROPAGATION_STYLE_INJECT ||

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

@@ -2,34 +2,64 @@
 
 const fs = require('fs')
 
+const { DD_EXTERNAL_ENV } = process.env
+
 // The second part is the PCF / Garden regexp. We currently assume no suffix($) to avoid matching pod UIDs
 // See https://github.com/DataDog/datadog-agent/blob/7.40.x/pkg/util/cgroups/reader.go#L50
 const uuidSource =
 '[0-9a-f]{8}[-_][0-9a-f]{4}[-_][0-9a-f]{4}[-_][0-9a-f]{4}[-_][0-9a-f]{12}|[0-9a-f]{8}(?:-[0-9a-f]{4}){4}$'
 const containerSource = '[0-9a-f]{64}'
 const taskSource = '[0-9a-f]{32}-\\d+'
+const lineReg = /^(\d+):([^:]*):(.+)$/
 const entityReg = new RegExp(`.*(${uuidSource}|${containerSource}|${taskSource})(?:\\.scope)?$`, 'm')
 
+const cgroup = readControlGroup()
 const entityId = getEntityId()
+const inode = getInode()
 
 function getEntityId () {
-  const cgroup = readControlGroup() || ''
-  const match = cgroup.trim().match(entityReg) || []
+  const match = cgroup.match(entityReg) || []
 
   return match[1]
 }
 
+function getInode () {
+  const match = cgroup.match(lineReg) || []
+
+  return readInode(match[3])
+}
+
 function readControlGroup () {
   try {
-    return fs.readFileSync('/proc/self/cgroup').toString()
+    return fs.readFileSync('/proc/self/cgroup').toString().trim()
+  } catch (err) {
+    return ''
+  }
+}
+
+function readInode (path) {
+  if (!path) return 0
+
+  const strippedPath = path.replace(/^\//, '').replace(/\/$/, '')
+
+  try {
+    return fs.statSync(`/sys/fs/cgroup/${strippedPath}`).ino
   } catch (err) {
-    // ignore
+    return 0
   }
 }
 
 module.exports = {
-  // can be the container ID but not always depending on the orchestrator
-  id () {
-    return entityId
+  inject (carrier) {
+    if (entityId) {
+      carrier['Datadog-Container-Id'] = entityId
+      carrier['Datadog-Entity-ID'] = `ci-${entityId}`
+    } else if (inode) {
+      carrier['Datadog-Entity-ID'] = `in-${inode}`
+    }
+
+    if (DD_EXTERNAL_ENV) {
+      carrier['Datadog-External-Env'] = DD_EXTERNAL_ENV
+    }
   }
 }

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

@@ -15,7 +15,6 @@ const { storage } = require('../../../../datadog-core')
 const log = require('../../log')
 
 const maxActiveRequests = 8
-const containerId = docker.id()
 
 let activeRequests = 0
 
@@ -63,9 +62,7 @@ function request (data, options, callback) {
     options.headers['Content-Length'] = byteLength(dataArray)
   }
 
-  if (containerId) {
-    options.headers['Datadog-Container-ID'] = containerId
-  }
+  docker.inject(options.headers)
 
   options.agent = isSecure ? httpsAgent : httpAgent
 

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

@@ -37,13 +37,13 @@ class LLMObsPlugin extends TracingPlugin {
     // register options may not be set for operations we do not trace with llmobs
     // ie OpenAI fine tuning jobs, file jobs, etc.
     if (registerOptions) {
-      telemetry.incrementLLMObsSpanStartCount({ autoinstrumented: true, integration: this.constructor.id })
+      telemetry.incrementLLMObsSpanStartCount({ autoinstrumented: true, integration: this.constructor.integration })
 
       ctx.llmobs = {} // initialize context-based namespace
       llmobsStorage.enterWith({ span })
       ctx.llmobs.parent = parent
 
-      this._tagger.registerLLMObsSpan(span, { parent, integration: this.constructor.id, ...registerOptions })
+      this._tagger.registerLLMObsSpan(span, { parent, integration: this.constructor.integration, ...registerOptions })
     }
   }
 

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

@@ -20,7 +20,8 @@ const ChatModelHandler = require('./handlers/chat_model')
 const LlmHandler = require('./handlers/llm')
 const EmbeddingHandler = require('./handlers/embedding')
 
-class LangChainLLMObsPlugin extends LLMObsPlugin {
+class BaseLangChainLLMObsPlugin extends LLMObsPlugin {
+  static get integration () { return 'langchain' }
   static get id () { return 'langchain' }
   static get prefix () {
     return 'tracing:apm:langchain:invoke'
@@ -55,8 +56,11 @@ class LangChainLLMObsPlugin extends LLMObsPlugin {
   }
 
   setLLMObsTags (ctx) {
+    ctx.args = ctx.arguments
+    ctx.instance = ctx.self
+
     const span = ctx.currentStore?.span
-    const type = ctx.type // langchain operation type (oneof chain,chat_model,llm,embedding)
+    const type = ctx.type = this.constructor.lcType // langchain operation type (oneof chain,chat_model,llm,embedding)
 
     if (!Object.keys(this._handlers).includes(type)) {
       log.warn(`Unsupported LangChain operation type: ${type}`)
@@ -129,4 +133,59 @@ class LangChainLLMObsPlugin extends LLMObsPlugin {
   }
 }
 
-module.exports = LangChainLLMObsPlugin
+class RunnableSequenceInvokePlugin extends BaseLangChainLLMObsPlugin {
+  static get id () { return 'llmobs_langchain_rs_invoke' }
+  static get lcType () { return 'chain' }
+  static get prefix () {
+    return 'tracing:orchestrion:@langchain/core:RunnableSequence_invoke'
+  }
+}
+
+class RunnableSequenceBatchPlugin extends BaseLangChainLLMObsPlugin {
+  static get id () { return 'llmobs_langchain_rs_batch' }
+  static get lcType () { return 'chain' }
+  static get prefix () {
+    return 'tracing:orchestrion:@langchain/core:RunnableSequence_batch'
+  }
+}
+
+class BaseChatModelGeneratePlugin extends BaseLangChainLLMObsPlugin {
+  static get id () { return 'llmobs_langchain_chat_model_generate' }
+  static get lcType () { return 'chat_model' }
+  static get prefix () {
+    return 'tracing:orchestrion:@langchain/core:BaseChatModel_generate'
+  }
+}
+
+class BaseLLMGeneratePlugin extends BaseLangChainLLMObsPlugin {
+  static get id () { return 'llmobs_langchain_llm_generate' }
+  static get lcType () { return 'llm' }
+  static get prefix () {
+    return 'tracing:orchestrion:@langchain/core:BaseLLM_generate'
+  }
+}
+
+class EmbeddingsEmbedQueryPlugin extends BaseLangChainLLMObsPlugin {
+  static get id () { return 'llmobs_langchain_embeddings_embed_query' }
+  static get lcType () { return 'embedding' }
+  static get prefix () {
+    return 'tracing:apm:@langchain/core:Embeddings_embedQuery'
+  }
+}
+
+class EmbeddingsEmbedDocumentsPlugin extends BaseLangChainLLMObsPlugin {
+  static get id () { return 'llmobs_langchain_embeddings_embed_documents' }
+  static get lcType () { return 'embedding' }
+  static get prefix () {
+    return 'tracing:apm:@langchain/core:Embeddings_embedDocuments'
+  }
+}
+
+module.exports = [
+  RunnableSequenceInvokePlugin,
+  RunnableSequenceBatchPlugin,
+  BaseChatModelGeneratePlugin,
+  BaseLLMGeneratePlugin,
+  EmbeddingsEmbedQueryPlugin,
+  EmbeddingsEmbedDocumentsPlugin
+]

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

@@ -11,6 +11,7 @@ function isIterable (obj) {
 
 class OpenAiLLMObsPlugin extends LLMObsPlugin {
   static get id () { return 'openai' }
+  static get integration () { return 'openai' }
   static get prefix () {
     return 'tracing:apm:openai:request'
   }

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

@@ -7,7 +7,8 @@ const {
 } = require('../../../../datadog-plugin-google-cloud-vertexai/src/utils')
 
 class VertexAILLMObsPlugin extends LLMObsPlugin {
-  static get id () { return 'vertexai' } // used for llmobs telemetry
+  static get integration () { return 'vertexai' } // used for llmobs telemetry
+  static get id () { return 'vertexai' }
   static get prefix () {
     return 'tracing:apm:vertexai:request'
   }

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

@@ -121,6 +121,8 @@ const log = {
   }
 }
 
+logWriter.setStackTraceLimitFunction(log.error)
+
 log.reset()
 
 log.toggle(log.isEnabled(), log.getLogLevel())

package/packages/dd-trace/src/log/writer.js

@@ -13,6 +13,7 @@ const defaultLogger = {
 let enabled = false
 let logger = defaultLogger
 let logChannel = new LogChannel()
+let stackTraceLimitFunction = onError
 
 function withNoop (fn) {
   const store = storage('legacy').getStore()
@@ -61,12 +62,28 @@ function getErrorLog (err) {
   }
 }
 
+function setStackTraceLimitFunction (fn) {
+  if (typeof fn !== 'function') {
+    throw new TypeError('stackTraceLimitFunction must be a function')
+  }
+  stackTraceLimitFunction = fn
+}
+
 function onError (err) {
   const { formatted, cause } = getErrorLog(err)
 
   // calling twice logger.error() because Error cause is only available in nodejs v16.9.0
   // TODO: replace it with Error(message, { cause }) when cause has broad support
-  if (formatted) withNoop(() => logger.error(new Error(formatted)))
+  if (formatted) {
+    withNoop(() => {
+      const l = Error.stackTraceLimit
+      Error.stackTraceLimit = 0
+      const e = new Error(formatted)
+      Error.stackTraceLimit = l
+      Error.captureStackTrace(e, stackTraceLimitFunction)
+      logger.error(e)
+    })
+  }
   if (cause) withNoop(() => logger.error(cause))
 }
 
@@ -122,4 +139,4 @@ function trace (...args) {
   onTrace(Log.parse(...args))
 }
 
-module.exports = { use, toggle, reset, error, warn, info, debug, trace }
+module.exports = { use, toggle, reset, error, warn, info, debug, trace, setStackTraceLimitFunction }

package/packages/dd-trace/src/opentracing/propagation/text_map.js

@@ -298,6 +298,7 @@ class TextMapPropagator {
 
   _extractSpanContext (carrier) {
     let context = null
+    let style = ''
     for (const extractor of this._config.tracePropagationStyle.extract) {
       let extractedContext = null
       switch (extractor) {
@@ -331,9 +332,9 @@ class TextMapPropagator {
 
       if (context === null) {
         context = extractedContext
+        style = extractor
         if (this._config.tracePropagationExtractFirst) {
-          this._extractBaggageItems(carrier, context)
-          return context
+          break
         }
       } else {
         // If extractor is tracecontext, add tracecontext specific information to the context
@@ -342,7 +343,7 @@ class TextMapPropagator {
             this._extractTraceparentContext(carrier), context, carrier)
         }
         if (extractedContext._traceId && extractedContext._spanId &&
-           extractedContext.toTraceId(true) !== context.toTraceId(true)) {
+          extractedContext.toTraceId(true) !== context.toTraceId(true)) {
           const link = {
             context: extractedContext,
             attributes: { reason: 'terminated_context', context_headers: extractor }
@@ -354,6 +355,19 @@ class TextMapPropagator {
 
     this._extractBaggageItems(carrier, context)
 
+    if (this._config.tracePropagationBehaviorExtract === 'ignore') {
+      context._links = []
+    } else if (this._config.tracePropagationBehaviorExtract === 'restart') {
+      context._links = []
+      context._links.push({
+        context,
+        attributes:
+        {
+          reason: 'propagation_behavior_extract', context_headers: style
+        }
+      })
+    }
+
     return context || this._extractSqsdContext(carrier)
   }
 

package/packages/dd-trace/src/opentracing/span.js

@@ -319,6 +319,12 @@ class DatadogSpan {
     let spanContext
     let startTime
 
+    let baggage = {}
+    if (parent && parent._isRemote && this._parentTracer?._config?.tracePropagationBehaviorExtract !== 'continue') {
+      baggage = parent._baggageItems
+      parent = null
+    }
+
     if (fields.context) {
       spanContext = fields.context
       if (!spanContext._trace.startTime) {
@@ -352,6 +358,10 @@ class DatadogSpan {
           .padStart(8, '0')
           .padEnd(16, '0')
       }
+
+      if (this._parentTracer?._config?.tracePropagationBehaviorExtract === 'restart') {
+        spanContext._baggageItems = baggage
+      }
     }
 
     spanContext._trace.ticks = spanContext._trace.ticks || now()

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

@@ -120,6 +120,12 @@ const TEST_LEVEL_EVENT_TYPES = [
   'test_module_end',
   'test_session_end'
 ]
+const TEST_RETRY_REASON_TYPES = {
+  efd: 'early_flake_detection',
+  atr: 'auto_test_retry',
+  atf: 'attempt_to_fix',
+  ext: 'external'
+}
 
 const DD_TEST_IS_USER_PROVIDED_SERVICE = '_dd.test.is_user_provided_service'
 
@@ -227,6 +233,7 @@ module.exports = {
   DD_CAPABILITIES_TEST_MANAGEMENT_DISABLE,
   DD_CAPABILITIES_TEST_MANAGEMENT_ATTEMPT_TO_FIX,
   TEST_LEVEL_EVENT_TYPES,
+  TEST_RETRY_REASON_TYPES,
   getNumFromKnownTests,
   getFileAndLineNumberFromError,
   DI_ERROR_DEBUG_INFO_CAPTURED,