dd-trace 5.102.0 → 5.104.0

package/packages/dd-trace/src/encode/0.4.js

@@ -40,14 +40,14 @@ const KEY_TYPE = buildKey('type')
 const KEY_NAME = buildKey('name')
 const KEY_RESOURCE = buildKey('resource')
 const KEY_SERVICE = buildKey('service')
+const KEY_ERROR = buildKey('error')
+const KEY_START = buildKey('start')
+const KEY_DURATION = buildKey('duration')
 const KEY_SPAN_EVENTS = buildKey('span_events')
 const KEY_META_STRUCT = buildKey('meta_struct')
 const KEY_TRACE_ID_PREFIX = buildKeyWithPrefix('trace_id', 0xCF)
 const KEY_SPAN_ID_PREFIX = buildKeyWithPrefix('span_id', 0xCF)
 const KEY_PARENT_ID_PREFIX = buildKeyWithPrefix('parent_id', 0xCF)
-const KEY_ERROR_PREFIX = buildKeyWithPrefix('error', 0xCE)
-const KEY_START_PREFIX = buildKeyWithPrefix('start', 0xCF)
-const KEY_DURATION_PREFIX = buildKeyWithPrefix('duration', 0xCF)
 const KEY_META_PREFIX = buildKeyWithPrefix('meta', 0xDF)
 const KEY_METRICS_PREFIX = buildKeyWithPrefix('metrics', 0xDF)
 
@@ -344,9 +344,12 @@ class AgentEncoder {
       cursor += KEY_SERVICE.length
       target.set(serviceEntry, cursor)
 
-      this.#writeIntegerField(bytes, KEY_ERROR_PREFIX, span.error)
-      this.#writeLongField(bytes, KEY_START_PREFIX, span.start)
-      this.#writeLongField(bytes, KEY_DURATION_PREFIX, span.duration)
+      bytes.set(KEY_ERROR)
+      this._encodeIntOrFloat(bytes, span.error)
+      bytes.set(KEY_START)
+      this._encodeIntOrFloat(bytes, span.start)
+      bytes.set(KEY_DURATION)
+      this._encodeIntOrFloat(bytes, span.duration)
 
       this.#encodeMetaEntries(bytes, KEY_META_PREFIX, span.meta)
       this.#encodeMetaEntries(bytes, KEY_METRICS_PREFIX, span.metrics)
@@ -448,6 +451,8 @@ class AgentEncoder {
   }
 
   // Single pass: reserve the count slot, encode entries while counting, patch the count.
+  // Subclasses (0.5, CI visibility encoders) inherit this; the wire stays on float64
+  // for numeric values to keep their established trace / events intake unchanged.
   _encodeMap (bytes, value) {
     const offset = bytes.length
     bytes.reserve(5)
@@ -542,12 +547,9 @@ class AgentEncoder {
         target.set(keyEntry, writeOffset)
         target.set(valueEntry, writeOffset + keyEntryLen)
       } else {
-        bytes.reserve(keyEntryLen + 9)
-        const target = bytes.buffer
-        target.set(keyEntry, writeOffset)
-        const valueOffset = writeOffset + keyEntryLen
-        target[valueOffset] = 0xCB
-        bytes.view.setFloat64(valueOffset + 1, entryValue)
+        bytes.reserve(keyEntryLen)
+        bytes.buffer.set(keyEntry, writeOffset)
+        this._encodeIntOrFloat(bytes, entryValue)
       }
       count++
     }
@@ -588,49 +590,38 @@ class AgentEncoder {
   }
 
   /**
+   * Emit `value` as the smallest valid msgpack number encoding: compact
+   * unsigned/signed int when integer, float64 otherwise. Unlike
+   * `MsgpackEncoder#encodeNumber`, NaN keeps its float64 bits instead of
+   * coercing to fixint 0.
+   *
+   * Underscore-protected so the 0.5 subclass can call it from its own
+   * `_encode` / `_encodeMap` overrides.
+   *
    * @param {MsgpackChunk} bytes
-   * @param {Buffer} keyPrefix Precomputed `[key, 0xCE]`.
    * @param {number} value
    */
-  #writeIntegerField (bytes, keyPrefix, value) {
-    const keyPrefixLen = keyPrefix.length
-    const offset = bytes.length
-    bytes.reserve(keyPrefixLen + 4)
-
-    const target = bytes.buffer
-    target.set(keyPrefix, offset)
-
-    const valueOffset = offset + keyPrefixLen
-    target[valueOffset] = value >> 24
-    target[valueOffset + 1] = value >> 16
-    target[valueOffset + 2] = value >> 8
-    target[valueOffset + 3] = value
-  }
-
-  /**
-   * @param {MsgpackChunk} bytes
-   * @param {Buffer} keyPrefix Precomputed `[key, 0xCF]`.
-   * @param {number} value Up to a 53-bit safe integer.
-   */
-  #writeLongField (bytes, keyPrefix, value) {
-    const high = (value / 2 ** 32) >> 0
-    const low = value >>> 0
-    const keyPrefixLen = keyPrefix.length
-    const offset = bytes.length
-    bytes.reserve(keyPrefixLen + 8)
-
-    const target = bytes.buffer
-    target.set(keyPrefix, offset)
-
-    const valueOffset = offset + keyPrefixLen
-    target[valueOffset] = high >> 24
-    target[valueOffset + 1] = high >> 16
-    target[valueOffset + 2] = high >> 8
-    target[valueOffset + 3] = high
-    target[valueOffset + 4] = low >> 24
-    target[valueOffset + 5] = low >> 16
-    target[valueOffset + 6] = low >> 8
-    target[valueOffset + 7] = low
+  _encodeIntOrFloat (bytes, value) {
+    // Fast path: positive fixint (0..127). `value === (value & 0x7F)` is true
+    // iff `value` is an exact integer in that range — covers `error: 0/1`,
+    // priority flags, attribute counts, HTTP status codes mapped to numbers,
+    // and most small metrics. NaN, ±Infinity, negatives, and any non-integer
+    // float fall through.
+    if (value === (value & 0x7F)) {
+      const offset = bytes.length
+      bytes.reserve(1)
+      bytes.buffer[offset] = value
+      return
+    }
+    if (Number.isInteger(value)) {
+      if (value >= 0) {
+        this.#msgpack.encodeUnsigned(bytes, value)
+      } else {
+        this.#msgpack.encodeSigned(bytes, value)
+      }
+    } else {
+      this.#encodeFloat(bytes, value)
+    }
   }
 
   /**
@@ -853,7 +844,7 @@ class AgentEncoder {
     if (typeof value === 'number') {
       this._encodeString(bytes, key)
       bytes.set(Number.isInteger(value) ? ATTR_PREFIX_INT : ATTR_PREFIX_DOUBLE)
-      this.#encodeFloat(bytes, value)
+      this._encodeIntOrFloat(bytes, value)
       return true
     }
     if (typeof value === 'boolean') {
@@ -923,7 +914,7 @@ class AgentEncoder {
     }
     if (typeof value === 'number') {
       bytes.set(Number.isInteger(value) ? ATTR_PREFIX_INT : ATTR_PREFIX_DOUBLE)
-      this.#encodeFloat(bytes, value)
+      this._encodeIntOrFloat(bytes, value)
       return true
     }
     if (typeof value === 'boolean') {

package/packages/dd-trace/src/encode/0.5.js

@@ -46,15 +46,46 @@ class AgentEncoder extends BaseEncoder {
       this._encodeId(bytes, span.trace_id)
       this._encodeId(bytes, span.span_id)
       this._encodeId(bytes, span.parent_id)
-      this._encodeLong(bytes, span.start || 0)
-      this._encodeLong(bytes, span.duration || 0)
-      this._encodeInteger(bytes, span.error)
+      this._encodeIntOrFloat(bytes, span.start || 0)
+      this._encodeIntOrFloat(bytes, span.duration || 0)
+      this._encodeIntOrFloat(bytes, span.error)
       this._encodeMap(bytes, span.meta || {})
       this._encodeMap(bytes, span.metrics || {})
       this._encodeString(bytes, span.type)
     }
   }
 
+  // Override the inherited 0.4 `_encodeMap` so the v0.5 wire emits each numeric
+  // value via `_encodeIntOrFloat` (compact unsigned/signed int when integer,
+  // float64 otherwise) instead of always float64. The 0.4 base method stays on
+  // float64 because the CI-visibility encoders inherit it and target a
+  // different intake.
+  _encodeMap (bytes, value) {
+    const offset = bytes.length
+    bytes.reserve(5)
+    bytes.buffer[offset] = 0xDF
+
+    let count = 0
+    for (const key of Object.keys(value)) {
+      const entryValue = value[key]
+      if (typeof entryValue === 'string') {
+        this._encodeString(bytes, key)
+        this._encodeString(bytes, entryValue)
+        count++
+      } else if (typeof entryValue === 'number') {
+        this._encodeString(bytes, key)
+        this._encodeIntOrFloat(bytes, entryValue)
+        count++
+      }
+    }
+
+    const target = bytes.buffer
+    target[offset + 1] = count >>> 24
+    target[offset + 2] = count >>> 16
+    target[offset + 3] = count >>> 8
+    target[offset + 4] = count
+  }
+
   _encodeString (bytes, value = '') {
     let index = this._stringMap[value]
     if (index === undefined) {

package/packages/dd-trace/src/encode/agentless-ci-visibility.js

@@ -7,6 +7,7 @@ const {
   TELEMETRY_ENDPOINT_PAYLOAD_SERIALIZATION_MS,
   TELEMETRY_ENDPOINT_PAYLOAD_EVENTS_COUNT,
 } = require('../ci-visibility/telemetry')
+const { MsgpackChunk } = require('../msgpack')
 const { AgentEncoder } = require('./0.4')
 const { truncateSpan, normalizeSpan } = require('./tags-processors')
 
@@ -20,6 +21,9 @@ const TEST_AND_SPAN_KEYS_LENGTH = 11
 
 const INTAKE_SOFT_LIMIT = 2 * 1024 * 1024 // 2MB
 
+// Prefix is ~1 KB in practice; `MsgpackChunk` resizes on overflow.
+const PREFIX_CHUNK_INITIAL_SIZE = 2048
+
 function formatSpan (span) {
   let encodingVersion = ENCODING_VERSION
   if (span.type === 'test' && span.meta && span.meta.test_session_id) {
@@ -259,10 +263,6 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
   }
 
   _encode (bytes, trace) {
-    if (this._isReset) {
-      this._encodePayloadStart(bytes)
-      this._isReset = false
-    }
     const startTime = Date.now()
 
     const events = trace.map(formatSpan)
@@ -281,20 +281,28 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
 
   makePayload () {
     distributionMetric(TELEMETRY_ENDPOINT_PAYLOAD_EVENTS_COUNT, { endpoint: 'test_cycle' }, this._eventCount)
-    const bytes = this._traceBytes
-    const eventsOffset = this._eventsOffset
-    const eventsCount = this._eventCount
 
-    bytes.buffer[eventsOffset] = 0xDD
-    bytes.buffer[eventsOffset + 1] = eventsCount >> 24
-    bytes.buffer[eventsOffset + 2] = eventsCount >> 16
-    bytes.buffer[eventsOffset + 3] = eventsCount >> 8
-    bytes.buffer[eventsOffset + 4] = eventsCount
+    // Encode the payload prefix (version + metadata + events-array header) at flush time,
+    // not on the first `_encode`. The CI Visibility flow adds metadata across multiple
+    // diagnostic channels (`session:start` adds `test_session.name`, the async
+    // `library-configuration` callback adds capability tags). Any span finished between
+    // those calls would otherwise freeze the prefix with stale metadata.
+    const prefixBytes = new MsgpackChunk(PREFIX_CHUNK_INITIAL_SIZE)
+    this._encodePayloadStart(prefixBytes)
 
-    const traceSize = bytes.length
-    const buffer = Buffer.allocUnsafe(traceSize)
-
-    bytes.buffer.copy(buffer, 0, 0, traceSize)
+    const eventsOffset = this._eventsOffset
+    const eventsCount = this._eventCount
+    prefixBytes.buffer[eventsOffset] = 0xDD
+    prefixBytes.buffer[eventsOffset + 1] = eventsCount >> 24
+    prefixBytes.buffer[eventsOffset + 2] = eventsCount >> 16
+    prefixBytes.buffer[eventsOffset + 3] = eventsCount >> 8
+    prefixBytes.buffer[eventsOffset + 4] = eventsCount
+
+    const eventsBytes = this._traceBytes
+    const totalSize = prefixBytes.length + eventsBytes.length
+    const buffer = Buffer.allocUnsafe(totalSize)
+    prefixBytes.buffer.copy(buffer, 0, 0, prefixBytes.length)
+    eventsBytes.buffer.copy(buffer, prefixBytes.length, 0, eventsBytes.length)
 
     this.reset()
 
@@ -302,7 +310,8 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
   }
 
   _encodePayloadStart (bytes) {
-    // encodes the payload up to `events`. `events` will be encoded via _encode
+    // Encodes the payload up to (and including) the `events` array prefix. The 5 reserved
+    // bytes for the array length are patched in `makePayload`.
     const payload = {
       version: ENCODING_VERSION,
       metadata: {
@@ -346,7 +355,6 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
       this._encodeMap(bytes, payload.metadata.test_session_end)
     }
     this._encodeString(bytes, 'events')
-    // Get offset of the events list to update the length of the array when calling `makePayload`
     this._eventsOffset = bytes.length
     bytes.reserve(5)
   }
@@ -354,7 +362,6 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
   reset () {
     this._reset()
     this._eventCount = 0
-    this._isReset = true
   }
 }
 

package/packages/dd-trace/src/encode/agentless-json.js

@@ -85,7 +85,7 @@ function spanToJSON (span) {
 class AgentlessJSONEncoder {
   /**
    * @param {object} writer - Writer instance with a flush() method, called when the buffer exceeds the soft limit
-   * @param {object} [metadata={}] - Shared metadata spread into each trace object (hostname, env, tracerVersion, etc.)
+   * @param {object} [metadata] - Shared metadata spread into each trace object (hostname, env, tracerVersion, etc.)
    */
   constructor (writer, metadata = {}) {
     this._writer = writer

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

@@ -7,6 +7,8 @@ const constants = require('./constants')
 
 module.exports = function getExporter (name) {
   switch (name) {
+    case exporters.ELECTRON:
+      return require('./exporters/electron')
     case exporters.LOG:
       return require('./exporters/log')
     case exporters.AGENT:

package/packages/dd-trace/src/exporters/agent/index.js

@@ -50,7 +50,8 @@ class AgentExporter {
       this.#timer = setTimeout(() => {
         this._writer.flush()
         this.#timer = undefined
-      }, flushInterval).unref()
+      }, flushInterval)
+      this.#timer.unref?.()
     }
   }
 

package/packages/dd-trace/src/exporters/agentless/index.js

@@ -18,7 +18,7 @@ class AgentlessExporter {
 
   /**
    * @param {object} config - Configuration object
-   * @param {string} [config.site='datadoghq.com'] - The Datadog site
+   * @param {string} [config.site] - The Datadog site. Defaults to 'datadoghq.com'.
    * @param {string} [config.url] - Override intake URL
    * @param {number} [config.flushInterval] - Batch flush interval in ms
    * @param {string} [config.env] - Environment name
@@ -109,7 +109,8 @@ class AgentlessExporter {
           log.error('Failed to flush traces on timer: %s', err.message)
         }
         this.#timer = undefined
-      }, flushInterval).unref()
+      }, flushInterval)
+      this.#timer.unref?.()
     }
   }
 

package/packages/dd-trace/src/exporters/agentless/writer.js

@@ -19,8 +19,8 @@ class AgentlessWriter extends BaseWriter {
   /**
    * @param {object} options - Writer options
    * @param {URL} [options.url] - The intake URL. If not provided, constructed from site.
-   * @param {string} [options.site='datadoghq.com'] - The Datadog site
-   * @param {object} [options.metadata={}] - Metadata to pass to the encoder (hostname, env, etc.)
+   * @param {string} [options.site] - The Datadog site
+   * @param {object} [options.metadata] - Metadata to pass to the encoder (hostname, env, etc.)
    */
   constructor ({ url, site = 'datadoghq.com', metadata = {} }) {
     super({ url })

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

@@ -4,6 +4,8 @@ const http = require('http')
 const https = require('https')
 const { storage } = require('../../../../datadog-core')
 
+const legacyStorage = storage('legacy')
+
 const keepAlive = true
 const maxSockets = 1
 
@@ -26,7 +28,7 @@ function createAgentClass (BaseAgent) {
     }
 
     _noop (callback) {
-      return storage('legacy').run({ noop: true }, callback)
+      return legacyStorage.run({ noop: true }, callback)
     }
   }
 

package/packages/dd-trace/src/exporters/common/buffering-exporter.js

@@ -39,7 +39,8 @@ class BufferingExporter {
       this[timerKey] = setTimeout(() => {
         writer.flush()
         this[timerKey] = undefined
-      }, flushInterval).unref()
+      }, flushInterval)
+      this[timerKey].unref?.()
     }
   }
 

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

@@ -20,6 +20,8 @@ const {
   markEndpointReached,
 } = require('./retry')
 
+const legacyStorage = storage('legacy')
+
 const maxActiveBufferSize = 1024 * 1024 * 64
 
 let activeBufferSize = 0
@@ -161,7 +163,7 @@ function request (data, options, callback) {
 
     activeBufferSize += options.headers['Content-Length'] ?? 0
 
-    storage('legacy').run({ noop: true }, () => {
+    legacyStorage.run({ noop: true }, () => {
       let finished = false
       const finalize = () => {
         if (finished) return
@@ -180,7 +182,7 @@ function request (data, options, callback) {
           // Unref so a pending retry never keeps the host process alive past
           // its natural exit point; long-running apps still retry because the
           // event loop is held open by their own work.
-          setTimeout(attempt, getRetryDelay(options, attemptIndex), attemptIndex + 1).unref()
+          setTimeout(attempt, getRetryDelay(options, attemptIndex), attemptIndex + 1).unref?.()
         } else {
           callback(error)
         }

package/packages/dd-trace/src/exporters/electron/index.js

@@ -0,0 +1,49 @@
+'use strict'
+
+const { channel } = require('dc-polyfill')
+const { truncateSpan, normalizeSpan } = require('../../encode/tags-processors')
+
+const traceChannel = channel('datadog:apm:electron:export')
+
+class ElectronExporter {
+  #timer
+  #traces = []
+
+  constructor (config) {
+    this._config = config
+
+    globalThis[Symbol.for('dd-trace')].beforeExitHandlers.add(this.flush.bind(this))
+  }
+
+  export (spans) {
+    this.#traces.push(spans)
+
+    const { flushInterval } = this._config
+
+    if (flushInterval === 0) {
+      this.flush()
+    } else if (this.#timer === undefined) {
+      this.#timer = setTimeout(() => {
+        this.flush()
+        this.#timer = undefined
+      }, flushInterval)
+      this.#timer.unref?.()
+    }
+  }
+
+  flush (done = () => {}) {
+    clearTimeout(this.#timer)
+    this.#timer = undefined
+
+    const traces = this.#traces.splice(0)
+
+    if (traces.length > 0 && traceChannel.hasSubscribers) {
+      const formattedTraces = traces.map(spans => spans.map(span => normalizeSpan(truncateSpan(span))))
+      traceChannel.publish(formattedTraces)
+    }
+
+    done()
+  }
+}
+
+module.exports = ElectronExporter

package/packages/dd-trace/src/external-logger/src/index.js

@@ -26,7 +26,8 @@ class ExternalLogger {
     }
     this.timer = setInterval(() => {
       this.flush()
-    }, this.interval).unref()
+    }, this.interval)
+    this.timer.unref?.()
 
     tracerLogger.debug(`started log writer to https://${this.intake}${this.endpoint}`)
   }

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

@@ -12,19 +12,21 @@ const {
   resolveGitHeadSHA,
 } = require('./config/git_properties')
 
-/** @type {{ commitSHA: string | undefined, repositoryUrl: string | undefined } | undefined} */
-let cached
+/**
+ * @typedef {{ commitSHA: string | undefined, repositoryUrl: string | undefined }} GitMetadata
+ * @type {{ enabled?: GitMetadata, disabled?: GitMetadata }}
+ */
+const cache = {}
 
 /**
  * @param {import('./config/config-types').ConfigProperties} config
  */
 function getGitMetadata (config) {
-  if (cached) return cached
-
   if (!config.DD_TRACE_GIT_METADATA_ENABLED) {
-    cached = { commitSHA: undefined, repositoryUrl: undefined }
-    return cached
+    cache.disabled ??= { commitSHA: undefined, repositoryUrl: undefined }
+    return cache.disabled
   }
+  if (cache.enabled) return cache.enabled
 
   let repositoryUrl = removeUserSensitiveInfo(config.DD_GIT_REPOSITORY_URL ?? config.tags[GIT_REPOSITORY_URL])
   let commitSHA = config.DD_GIT_COMMIT_SHA ?? config.tags[GIT_COMMIT_SHA]
@@ -59,8 +61,8 @@ function getGitMetadata (config) {
 
   commitSHA ??= resolveGitHeadSHA(gitFolderPath)
 
-  cached = { commitSHA, repositoryUrl }
-  return cached
+  cache.enabled = { commitSHA, repositoryUrl }
+  return cache.enabled
 }
 
 module.exports = getGitMetadata

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

@@ -13,6 +13,12 @@ let batch = 0
 class Identifier {
   /** @type {number[] | Uint8Array} */
   #buffer
+  /** @type {bigint | undefined} */
+  #bigInt
+  /** @type {string | undefined} */
+  #stringHex
+  /** @type {string | undefined} */
+  #stringDecimal
 
   /**
    * @param {string} value
@@ -29,16 +35,23 @@ class Identifier {
    * @returns {string}
    */
   toString (radix = 16) {
-    return radix === 16
-      ? Buffer.from(this.#buffer).toString('hex')
-      : toNumberString(this.#buffer, radix)
+    if (radix === 16) {
+      this.#stringHex ??= Buffer.from(this.#buffer).toString('hex')
+      return this.#stringHex
+    }
+    if (radix === 10) {
+      this.#stringDecimal ??= toNumberString(this.#buffer, 10)
+      return this.#stringDecimal
+    }
+    return toNumberString(this.#buffer, radix)
   }
 
   /**
    * @returns {bigint}
    */
   toBigInt () {
-    return Buffer.from(this.#buffer).readBigUInt64BE(0)
+    this.#bigInt ??= Buffer.from(this.#buffer).readBigUInt64BE(0)
+    return this.#bigInt
   }
 
   /**

package/packages/dd-trace/src/lambda/handler-paths.js

@@ -0,0 +1,52 @@
+/**
+ * Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Modifications copyright 2022 Datadog, Inc.
+ *
+ * Some functions are part of aws-lambda-nodejs-runtime-interface-client
+ * https://github.com/aws/aws-lambda-nodejs-runtime-interface-client/blob/v2.1.0/src/utils/UserFunction.ts
+ */
+'use strict'
+
+const path = require('path')
+
+/**
+ * Example: `'./api/src/index.nested.handler'` → `['./api/src/', 'index.nested.handler']`.
+ *
+ * @param {string} fullHandler
+ */
+function extractModuleRootAndHandler (fullHandler) {
+  const handlerString = path.basename(fullHandler)
+  const moduleRoot = fullHandler.slice(0, Math.max(0, fullHandler.indexOf(handlerString)))
+  return [moduleRoot, handlerString]
+}
+
+/**
+ * Example: `'index.nested.handler'` → `['index', 'nested.handler']`.
+ *
+ * @param {string} handler
+ * @throws {Error} When the handler is not of the form `<module>.<path>`.
+ */
+function extractModuleNameAndHandlerPath (handler) {
+  const match = handler.match(/^([^.]*)\.(.*)$/)
+  if (!match || match.length !== 3) {
+    throw new Error(`Malformed handler name: ${handler}`)
+  }
+  return [match[1], match[2]]
+}
+
+/**
+ * @param {string} lambdaStylePath `LAMBDA_TASK_ROOT` joined with the module root and module name.
+ */
+function getLambdaFilePaths (lambdaStylePath) {
+  return [
+    `${lambdaStylePath}.js`,
+    `${lambdaStylePath}.mjs`,
+    `${lambdaStylePath}.cjs`,
+  ]
+}
+
+module.exports = {
+  extractModuleRootAndHandler,
+  extractModuleNameAndHandlerPath,
+  getLambdaFilePaths,
+}

package/packages/dd-trace/src/lambda/handler.js

@@ -6,8 +6,6 @@ const { ERROR_MESSAGE, ERROR_TYPE } = require('../constants')
 const { ImpendingTimeout } = require('./runtime/errors')
 const { extractContext } = require('./context')
 
-const globalTracer = global._ddtrace
-const tracer = globalTracer._tracer
 const timeoutChannel = channel('apm:aws:lambda:timeout')
 // Always crash the flushes when a message is received
 // from this channel.
@@ -25,8 +23,7 @@ let __lambdaTimeout
  */
 function checkTimeout (context) {
   const remainingTimeInMillis = context.getRemainingTimeInMillis()
-
-  const apmFlushDeadline = tracer._config.DD_APM_FLUSH_DEADLINE_MILLISECONDS
+  const apmFlushDeadline = global._ddtrace._tracer._config.DD_APM_FLUSH_DEADLINE_MILLISECONDS
 
   __lambdaTimeout = setTimeout(() => {
     timeoutChannel.publish()
@@ -42,6 +39,7 @@ function checkTimeout (context) {
  * Once that is done, it finishes the last span.
  */
 function crashFlush () {
+  const tracer = global._ddtrace._tracer
   const activeSpan = tracer.scope().active()
   if (activeSpan === null) {
     log.debug('An impending timeout was reached, but no root span was found. No error will be tagged.')