dd-trace 5.25.0 → 5.26.0

package/packages/dd-trace/src/appsec/remote_config/capabilities.js

@@ -11,7 +11,7 @@ module.exports = {
   ASM_CUSTOM_RULES: 1n << 8n,
   ASM_CUSTOM_BLOCKING_RESPONSE: 1n << 9n,
   ASM_TRUSTED_IPS: 1n << 10n,
-  ASM_API_SECURITY_SAMPLE_RATE: 1n << 11n,
+  ASM_API_SECURITY_SAMPLE_RATE: 1n << 11n, // deprecated
   APM_TRACING_SAMPLE_RATE: 1n << 12n,
   APM_TRACING_LOGS_INJECTION: 1n << 13n,
   APM_TRACING_HTTP_HEADER_TAGS: 1n << 14n,

package/packages/dd-trace/src/appsec/remote_config/index.js

@@ -4,7 +4,6 @@ const Activation = require('../activation')
 
 const RemoteConfigManager = require('./manager')
 const RemoteConfigCapabilities = require('./capabilities')
-const apiSecuritySampler = require('../api_security_sampler')
 
 let rc
 
@@ -24,18 +23,12 @@ function enable (config, appsec) {
       rc.updateCapabilities(RemoteConfigCapabilities.ASM_ACTIVATION, true)
     }
 
-    if (config.appsec.apiSecurity?.enabled) {
-      rc.updateCapabilities(RemoteConfigCapabilities.ASM_API_SECURITY_SAMPLE_RATE, true)
-    }
-
     rc.setProductHandler('ASM_FEATURES', (action, rcConfig) => {
       if (!rcConfig) return
 
       if (activation === Activation.ONECLICK) {
         enableOrDisableAppsec(action, rcConfig, config, appsec)
       }
-
-      apiSecuritySampler.setRequestSampling(rcConfig.api_security?.request_sample_rate)
     })
   }
 

package/packages/dd-trace/src/appsec/reporter.js

@@ -32,6 +32,7 @@ const contentHeaderList = [
 
 const EVENT_HEADERS_MAP = mapHeaderAndTags([
   ...ipHeaderList,
+  'x-forwarded',
   'forwarded',
   'via',
   ...contentHeaderList,

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

@@ -444,7 +444,7 @@ class Config {
     const defaults = setHiddenProperty(this, '_defaults', {})
 
     this._setValue(defaults, 'appsec.apiSecurity.enabled', true)
-    this._setValue(defaults, 'appsec.apiSecurity.requestSampling', 0.1)
+    this._setValue(defaults, 'appsec.apiSecurity.sampleDelay', 30)
     this._setValue(defaults, 'appsec.blockedTemplateGraphql', undefined)
     this._setValue(defaults, 'appsec.blockedTemplateHtml', undefined)
     this._setValue(defaults, 'appsec.blockedTemplateJson', undefined)
@@ -467,6 +467,7 @@ class Config {
     this._setValue(defaults, 'ciVisibilityTestSessionName', '')
     this._setValue(defaults, 'clientIpEnabled', false)
     this._setValue(defaults, 'clientIpHeader', null)
+    this._setValue(defaults, 'crashtracking.enabled', false)
     this._setValue(defaults, 'codeOriginForSpans.enabled', false)
     this._setValue(defaults, 'dbmPropagationMode', 'disabled')
     this._setValue(defaults, 'dogstatsd.hostname', '127.0.0.1')
@@ -513,6 +514,7 @@ class Config {
     this._setValue(defaults, 'isTestDynamicInstrumentationEnabled', false)
     this._setValue(defaults, 'logInjection', false)
     this._setValue(defaults, 'lookup', undefined)
+    this._setValue(defaults, 'inferredProxyServicesEnabled', false)
     this._setValue(defaults, 'memcachedCommandEnabled', false)
     this._setValue(defaults, 'openAiLogsEnabled', false)
     this._setValue(defaults, 'openaiSpanCharLimit', 128)
@@ -569,7 +571,7 @@ class Config {
       AWS_LAMBDA_FUNCTION_NAME,
       DD_AGENT_HOST,
       DD_API_SECURITY_ENABLED,
-      DD_API_SECURITY_REQUEST_SAMPLE_RATE,
+      DD_API_SECURITY_SAMPLE_DELAY,
       DD_APPSEC_AUTOMATED_USER_EVENTS_TRACKING,
       DD_APPSEC_ENABLED,
       DD_APPSEC_GRAPHQL_BLOCKED_TEMPLATE_JSON,
@@ -585,6 +587,7 @@ class Config {
       DD_APPSEC_RASP_ENABLED,
       DD_APPSEC_TRACE_RATE_LIMIT,
       DD_APPSEC_WAF_TIMEOUT,
+      DD_CRASHTRACKING_ENABLED,
       DD_CODE_ORIGIN_FOR_SPANS_ENABLED,
       DD_DATA_STREAMS_ENABLED,
       DD_DBM_PROPAGATION_MODE,
@@ -675,6 +678,7 @@ class Config {
       DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH,
       DD_TRACING_ENABLED,
       DD_VERSION,
+      DD_TRACE_INFERRED_PROXY_SERVICES_ENABLED,
       OTEL_METRICS_EXPORTER,
       OTEL_PROPAGATORS,
       OTEL_RESOURCE_ATTRIBUTES,
@@ -696,7 +700,7 @@ class Config {
       DD_API_SECURITY_ENABLED && isTrue(DD_API_SECURITY_ENABLED),
       DD_EXPERIMENTAL_API_SECURITY_ENABLED && isTrue(DD_EXPERIMENTAL_API_SECURITY_ENABLED)
     ))
-    this._setUnit(env, 'appsec.apiSecurity.requestSampling', DD_API_SECURITY_REQUEST_SAMPLE_RATE)
+    this._setValue(env, 'appsec.apiSecurity.sampleDelay', maybeFloat(DD_API_SECURITY_SAMPLE_DELAY))
     this._setValue(env, 'appsec.blockedTemplateGraphql', maybeFile(DD_APPSEC_GRAPHQL_BLOCKED_TEMPLATE_JSON))
     this._setValue(env, 'appsec.blockedTemplateHtml', maybeFile(DD_APPSEC_HTTP_BLOCKED_TEMPLATE_HTML))
     this._envUnprocessed['appsec.blockedTemplateHtml'] = DD_APPSEC_HTTP_BLOCKED_TEMPLATE_HTML
@@ -728,6 +732,7 @@ class Config {
     this._setValue(env, 'baggageMaxItems', DD_TRACE_BAGGAGE_MAX_ITEMS)
     this._setBoolean(env, 'clientIpEnabled', DD_TRACE_CLIENT_IP_ENABLED)
     this._setString(env, 'clientIpHeader', DD_TRACE_CLIENT_IP_HEADER)
+    this._setBoolean(env, 'crashtracking.enabled', DD_CRASHTRACKING_ENABLED)
     this._setBoolean(env, 'codeOriginForSpans.enabled', DD_CODE_ORIGIN_FOR_SPANS_ENABLED)
     this._setString(env, 'dbmPropagationMode', DD_DBM_PROPAGATION_MODE)
     this._setString(env, 'dogstatsd.hostname', DD_DOGSTATSD_HOSTNAME)
@@ -862,6 +867,7 @@ class Config {
         : !!OTEL_PROPAGATORS)
     this._setBoolean(env, 'tracing', DD_TRACING_ENABLED)
     this._setString(env, 'version', DD_VERSION || tags.version)
+    this._setBoolean(env, 'inferredProxyServicesEnabled', DD_TRACE_INFERRED_PROXY_SERVICES_ENABLED)
   }
 
   _applyOptions (options) {
@@ -874,7 +880,6 @@ class Config {
     tagger.add(tags, options.tags)
 
     this._setBoolean(opts, 'appsec.apiSecurity.enabled', options.appsec.apiSecurity?.enabled)
-    this._setUnit(opts, 'appsec.apiSecurity.requestSampling', options.appsec.apiSecurity?.requestSampling)
     this._setValue(opts, 'appsec.blockedTemplateGraphql', maybeFile(options.appsec.blockedTemplateGraphql))
     this._setValue(opts, 'appsec.blockedTemplateHtml', maybeFile(options.appsec.blockedTemplateHtml))
     this._optsUnprocessed['appsec.blockedTemplateHtml'] = options.appsec.blockedTemplateHtml
@@ -980,6 +985,7 @@ class Config {
     this._setBoolean(opts, 'traceId128BitGenerationEnabled', options.traceId128BitGenerationEnabled)
     this._setBoolean(opts, 'traceId128BitLoggingEnabled', options.traceId128BitLoggingEnabled)
     this._setString(opts, 'version', options.version || tags.version)
+    this._setBoolean(opts, 'inferredProxyServicesEnabled', options.inferredProxyServicesEnabled)
 
     // For LLMObs, we want the environment variable to take precedence over the options.
     // This is reliant on environment config being set before options.
@@ -1134,6 +1140,9 @@ class Config {
     if (iastEnabled || ['auto', 'true'].includes(profilingEnabled) || injectionIncludesProfiler) {
       this._setBoolean(calc, 'telemetry.logCollection', true)
     }
+    if (this._env.injectionEnabled?.length > 0) {
+      this._setBoolean(calc, 'crashtracking.enabled', true)
+    }
   }
 
   _applyRemote (options) {

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

@@ -46,5 +46,10 @@ module.exports = {
   SCHEMA_OPERATION: 'schema.operation',
   SCHEMA_NAME: 'schema.name',
   GRPC_CLIENT_ERROR_STATUSES: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
-  GRPC_SERVER_ERROR_STATUSES: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
+  GRPC_SERVER_ERROR_STATUSES: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
+  S3_PTR_KIND: 'aws.s3.object',
+  SPAN_POINTER_DIRECTION: Object.freeze({
+    UPSTREAM: 'u',
+    DOWNSTREAM: 'd'
+  })
 }

package/packages/dd-trace/src/crashtracking/crashtracker.js

@@ -0,0 +1,98 @@
+'use strict'
+
+// Load binding first to not import other modules if it throws
+const libdatadog = require('@datadog/libdatadog')
+const binding = libdatadog.load('crashtracker')
+
+const log = require('../log')
+const { URL } = require('url')
+const pkg = require('../../../../package.json')
+
+class Crashtracker {
+  constructor () {
+    this._started = false
+  }
+
+  configure (config) {
+    if (!this._started) return
+
+    try {
+      binding.updateConfig(this._getConfig(config))
+      binding.updateMetadata(this._getMetadata(config))
+    } catch (e) {
+      log.error(e)
+    }
+  }
+
+  start (config) {
+    if (this._started) return this.configure(config)
+
+    this._started = true
+
+    try {
+      binding.init(
+        this._getConfig(config),
+        this._getReceiverConfig(config),
+        this._getMetadata(config)
+      )
+    } catch (e) {
+      log.error(e)
+    }
+  }
+
+  // TODO: Send only configured values when defaults are fixed.
+  _getConfig (config) {
+    const { hostname = '127.0.0.1', port = 8126 } = config
+    const url = config.url || new URL(`http://${hostname}:${port}`)
+
+    return {
+      additional_files: [],
+      create_alt_stack: true,
+      use_alt_stack: true,
+      endpoint: {
+        // TODO: Use the string directly when deserialization is fixed.
+        url: {
+          scheme: url.protocol.slice(0, -1),
+          authority: url.protocol === 'unix'
+            ? Buffer.from(url.pathname).toString('hex')
+            : url.host,
+          path_and_query: ''
+        },
+        timeout_ms: 3000
+      },
+      timeout_ms: 0,
+      // TODO: Use `EnabledWithSymbolsInReceiver` instead for Linux when fixed.
+      resolve_frames: 'EnabledWithInprocessSymbols'
+    }
+  }
+
+  _getMetadata (config) {
+    const tags = Object.keys(config.tags).map(key => `${key}:${config.tags[key]}`)
+
+    return {
+      library_name: pkg.name,
+      library_version: pkg.version,
+      family: 'nodejs',
+      tags: [
+        ...tags,
+        'is_crash:true',
+        'language:javascript',
+        `library_version:${pkg.version}`,
+        'runtime:nodejs',
+        'severity:crash'
+      ]
+    }
+  }
+
+  _getReceiverConfig () {
+    return {
+      args: [],
+      env: [],
+      path_to_receiver_binary: libdatadog.find('crashtracker-receiver', true),
+      stderr_filename: null,
+      stdout_filename: null
+    }
+  }
+}
+
+module.exports = new Crashtracker()

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

@@ -0,0 +1,15 @@
+'use strict'
+
+const { isMainThread } = require('worker_threads')
+const log = require('../log')
+
+if (isMainThread) {
+  try {
+    module.exports = require('./crashtracker')
+  } catch (e) {
+    log.warn(e.message)
+    module.exports = require('./noop')
+  }
+} else {
+  module.exports = require('./noop')
+}

package/packages/dd-trace/src/crashtracking/noop.js

@@ -0,0 +1,8 @@
+'use strict'
+
+class NoopCrashtracker {
+  configure () {}
+  start () {}
+}
+
+module.exports = new NoopCrashtracker()

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

@@ -291,7 +291,7 @@ class LLMObs extends NoopLLMObs {
     }
 
     const evaluationTags = {
-      'dd-trace.version': tracerVersion,
+      'ddtrace.version': tracerVersion,
       ml_app: mlApp
     }
 

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

@@ -179,7 +179,7 @@ class LLMObsSpanProcessor {
       service: this._config.service,
       source: 'integration',
       ml_app: mlApp,
-      'dd-trace.version': tracerVersion,
+      'ddtrace.version': tracerVersion,
       error: Number(!!error) || 0,
       language: 'javascript'
     }

package/packages/dd-trace/src/llmobs/writers/spans/base.js

@@ -6,6 +6,8 @@ const { DROPPED_IO_COLLECTION_ERROR } = require('../../constants/tags')
 const BaseWriter = require('../base')
 const logger = require('../../../log')
 
+const tracerVersion = require('../../../../../../package.json').version
+
 class LLMObsSpanWriter extends BaseWriter {
   constructor (options) {
     super({
@@ -32,6 +34,7 @@ class LLMObsSpanWriter extends BaseWriter {
   makePayload (events) {
     return {
       '_dd.stage': 'raw',
+      '_dd.tracer_version': tracerVersion,
       event_type: this._eventType,
       spans: events
     }

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

@@ -4,6 +4,7 @@ const coalesce = require('koalas')
 const { isTrue } = require('../util')
 const { debugChannel, infoChannel, warnChannel, errorChannel } = require('./channels')
 const logWriter = require('./writer')
+const { Log } = require('./log')
 
 const memoize = func => {
   const cache = {}
@@ -18,10 +19,6 @@ const memoize = func => {
   return memoized
 }
 
-function processMsg (msg) {
-  return typeof msg === 'function' ? msg() : msg
-}
-
 const config = {
   enabled: false,
   logger: undefined,
@@ -52,37 +49,37 @@ const log = {
   reset () {
     logWriter.reset()
     this._deprecate = memoize((code, message) => {
-      errorChannel.publish(message)
+      errorChannel.publish(Log.parse(message))
       return true
     })
 
     return this
   },
 
-  debug (message) {
+  debug (...args) {
     if (debugChannel.hasSubscribers) {
-      debugChannel.publish(processMsg(message))
+      debugChannel.publish(Log.parse(...args))
     }
     return this
   },
 
-  info (message) {
+  info (...args) {
     if (infoChannel.hasSubscribers) {
-      infoChannel.publish(processMsg(message))
+      infoChannel.publish(Log.parse(...args))
     }
     return this
   },
 
-  warn (message) {
+  warn (...args) {
     if (warnChannel.hasSubscribers) {
-      warnChannel.publish(processMsg(message))
+      warnChannel.publish(Log.parse(...args))
     }
     return this
   },
 
-  error (err) {
+  error (...args) {
     if (errorChannel.hasSubscribers) {
-      errorChannel.publish(processMsg(err))
+      errorChannel.publish(Log.parse(...args))
     }
     return this
   },

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

@@ -0,0 +1,52 @@
+'use strict'
+
+const { format } = require('util')
+
+class Log {
+  constructor (message, args, cause, delegate) {
+    this.message = message
+    this.args = args
+    this.cause = cause
+    this.delegate = delegate
+  }
+
+  get formatted () {
+    const { message, args } = this
+
+    let formatted = message
+    if (message && args && args.length) {
+      formatted = format(message, ...args)
+    }
+    return formatted
+  }
+
+  static parse (...args) {
+    let message, cause, delegate
+
+    const lastArg = args[args.length - 1]
+    if (lastArg && typeof lastArg === 'object' && lastArg.stack) { // lastArg instanceof Error?
+      cause = args.pop()
+    }
+
+    const firstArg = args.shift()
+    if (firstArg) {
+      if (typeof firstArg === 'string') {
+        message = firstArg
+      } else if (typeof firstArg === 'object') {
+        message = String(firstArg.message || firstArg)
+      } else if (typeof firstArg === 'function') {
+        delegate = firstArg
+      } else {
+        message = String(firstArg)
+      }
+    } else if (!cause) {
+      message = String(firstArg)
+    }
+
+    return new Log(message, args, cause, delegate)
+  }
+}
+
+module.exports = {
+  Log
+}

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

@@ -2,6 +2,7 @@
 
 const { storage } = require('../../../datadog-core')
 const { LogChannel } = require('./channels')
+const { Log } = require('./log')
 const defaultLogger = {
   debug: msg => console.debug(msg), /* eslint-disable-line no-console */
   info: msg => console.info(msg), /* eslint-disable-line no-console */
@@ -22,7 +23,7 @@ function withNoop (fn) {
 }
 
 function unsubscribeAll () {
-  logChannel.unsubscribe({ debug, info, warn, error })
+  logChannel.unsubscribe({ debug: onDebug, info: onInfo, warn: onWarn, error: onError })
 }
 
 function toggleSubscription (enable, level) {
@@ -30,7 +31,7 @@ function toggleSubscription (enable, level) {
 
   if (enable) {
     logChannel = new LogChannel(level)
-    logChannel.subscribe({ debug, info, warn, error })
+    logChannel.subscribe({ debug: onDebug, info: onInfo, warn: onWarn, error: onError })
   }
 }
 
@@ -51,32 +52,62 @@ function reset () {
   toggleSubscription(false)
 }
 
-function error (err) {
-  if (typeof err !== 'object' || !err) {
-    err = String(err)
-  } else if (!err.stack) {
-    err = String(err.message || err)
+function getErrorLog (err) {
+  if (err && typeof err.delegate === 'function') {
+    const result = err.delegate()
+    return Array.isArray(result) ? Log.parse(...result) : Log.parse(result)
+  } else {
+    return err
   }
+}
 
-  if (typeof err === 'string') {
-    err = new Error(err)
-  }
+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 (cause) withNoop(() => logger.error(cause))
+}
+
+function onWarn (log) {
+  const { formatted, cause } = getErrorLog(log)
+  if (formatted) withNoop(() => logger.warn(formatted))
+  if (cause) withNoop(() => logger.warn(cause))
+}
 
-  withNoop(() => logger.error(err))
+function onInfo (log) {
+  const { formatted, cause } = getErrorLog(log)
+  if (formatted) withNoop(() => logger.info(formatted))
+  if (cause) withNoop(() => logger.info(cause))
 }
 
-function warn (message) {
-  if (!logger.warn) return debug(message)
-  withNoop(() => logger.warn(message))
+function onDebug (log) {
+  const { formatted, cause } = getErrorLog(log)
+  if (formatted) withNoop(() => logger.debug(formatted))
+  if (cause) withNoop(() => logger.debug(cause))
 }
 
-function info (message) {
-  if (!logger.info) return debug(message)
-  withNoop(() => logger.info(message))
+function error (...args) {
+  onError(Log.parse(...args))
+}
+
+function warn (...args) {
+  const log = Log.parse(...args)
+  if (!logger.warn) return onDebug(log)
+
+  onWarn(log)
+}
+
+function info (...args) {
+  const log = Log.parse(...args)
+  if (!logger.info) return onDebug(log)
+
+  onInfo(log)
 }
 
-function debug (message) {
-  withNoop(() => logger.debug(message))
+function debug (...args) {
+  onDebug(Log.parse(...args))
 }
 
 module.exports = { use, toggle, reset, error, warn, info, debug }

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

@@ -22,6 +22,7 @@ class NoopSpan {
   setTag (key, value) { return this }
   addTags (keyValueMap) { return this }
   addLink (link) { return this }
+  addSpanPointer (ptrKind, ptrDir, ptrHash) { return this }
   log () { return this }
   logEvent () {}
   finish (finishTime) {}

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

@@ -14,6 +14,7 @@ const { SERVICE_NAME, RESOURCE_NAME } = require('../../../../ext/tags')
 const kinds = require('../../../../ext/kinds')
 
 const SpanContext = require('./span_context')
+const id = require('../id')
 
 // The one built into OTel rounds so we lose sub-millisecond precision.
 function hrTimeToMilliseconds (time) {
@@ -217,6 +218,20 @@ class Span {
     return this
   }
 
+  addSpanPointer (ptrKind, ptrDir, ptrHash) {
+    const zeroContext = new SpanContext({
+      traceId: id('0'),
+      spanId: id('0')
+    })
+    const attributes = {
+      'ptr.kind': ptrKind,
+      'ptr.dir': ptrDir,
+      'ptr.hash': ptrHash,
+      'link.kind': 'span-pointer'
+    }
+    return this.addLink(zeroContext, attributes)
+  }
+
   setStatus ({ code, message }) {
     if (!this.ended && !this._hasStatus && code) {
       this._hasStatus = true

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

@@ -290,50 +290,63 @@ class TextMapPropagator {
   }
 
   _extractSpanContext (carrier) {
-    let spanContext = null
+    let context = null
     for (const extractor of this._config.tracePropagationStyle.extract) {
-      // add logic to ensure tracecontext headers takes precedence over other extracted headers
-      if (spanContext !== null) {
-        if (this._config.tracePropagationExtractFirst) {
-          return spanContext
-        }
-        if (extractor !== 'tracecontext') {
-          continue
-        }
-        spanContext = this._resolveTraceContextConflicts(
-          this._extractTraceparentContext(carrier), spanContext, carrier)
-        break
-      }
-
+      let extractedContext = null
       switch (extractor) {
         case 'datadog':
-          spanContext = this._extractDatadogContext(carrier)
+          extractedContext = this._extractDatadogContext(carrier)
           break
         case 'tracecontext':
-          spanContext = this._extractTraceparentContext(carrier)
+          extractedContext = this._extractTraceparentContext(carrier)
           break
         case 'b3' && this
           ._config
           .tracePropagationStyle
           .otelPropagators: // TODO: should match "b3 single header" in next major
         case 'b3 single header': // TODO: delete in major after singular "b3"
-          spanContext = this._extractB3SingleContext(carrier)
+          extractedContext = this._extractB3SingleContext(carrier)
           break
         case 'b3':
         case 'b3multi':
-          spanContext = this._extractB3MultiContext(carrier)
+          extractedContext = this._extractB3MultiContext(carrier)
           break
         default:
-          log.warn(`Unknown propagation style: ${extractor}`)
+          if (extractor !== 'baggage') log.warn(`Unknown propagation style: ${extractor}`)
+      }
+
+      if (extractedContext === null) { // If the current extractor was invalid, continue to the next extractor
+        continue
+      }
+
+      if (context === null) {
+        context = extractedContext
+        if (this._config.tracePropagationExtractFirst) {
+          return context
+        }
+      } else {
+        // If extractor is tracecontext, add tracecontext specific information to the context
+        if (extractor === 'tracecontext') {
+          context = this._resolveTraceContextConflicts(
+            this._extractTraceparentContext(carrier), context, carrier)
+        }
+        if (extractedContext._traceId && extractedContext._spanId &&
+           extractedContext.toTraceId(true) !== context.toTraceId(true)) {
+          const link = {
+            context: extractedContext,
+            attributes: { reason: 'terminated_context', context_headers: extractor }
+          }
+          context._links.push(link)
+        }
       }
 
       if (this._config.tracePropagationStyle.extract.includes('baggage') && carrier.baggage) {
-        spanContext = spanContext || new DatadogSpanContext()
-        this._extractBaggageItems(carrier, spanContext)
+        context = context || new DatadogSpanContext()
+        this._extractBaggageItems(carrier, context)
       }
     }
 
-    return spanContext || this._extractSqsdContext(carrier)
+    return context || this._extractSqsdContext(carrier)
   }
 
   _extractDatadogContext (carrier) {