dd-trace 6.0.0-pre-0bb1f17 → 6.1.0

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

@@ -0,0 +1,68 @@
+'use strict'
+
+const fs = require('node:fs')
+const path = require('node:path')
+
+const log = require('./log')
+const { GIT_COMMIT_SHA, GIT_REPOSITORY_URL } = require('./plugins/util/tags')
+const {
+  getGitMetadataFromGitProperties,
+  getRemoteOriginURL,
+  removeUserSensitiveInfo,
+  resolveGitHeadSHA,
+} = require('./config/git_properties')
+
+/**
+ * @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 (!config.DD_TRACE_GIT_METADATA_ENABLED) {
+    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]
+
+  if (!repositoryUrl || !commitSHA) {
+    const propertiesFile = config.DD_GIT_PROPERTIES_FILE
+    const gitPropertiesFile = propertiesFile ?? `${process.cwd()}/git.properties`
+    try {
+      const fromProperties = getGitMetadataFromGitProperties(fs.readFileSync(gitPropertiesFile, 'utf8'))
+      commitSHA ??= fromProperties.commitSHA
+      repositoryUrl ??= fromProperties.repositoryUrl
+    } catch (error) {
+      if (propertiesFile) {
+        log.error('Error reading DD_GIT_PROPERTIES_FILE: %s', gitPropertiesFile, error)
+      }
+    }
+  }
+
+  const folderPath = config.DD_GIT_FOLDER_PATH
+  const gitFolderPath = folderPath ?? path.join(process.cwd(), '.git')
+
+  if (!repositoryUrl) {
+    const gitConfigPath = path.join(gitFolderPath, 'config')
+    try {
+      repositoryUrl = getRemoteOriginURL(fs.readFileSync(gitConfigPath, 'utf8'))
+    } catch (error) {
+      if (folderPath) {
+        log.error('Error reading git config: %s', gitConfigPath, error)
+      }
+    }
+  }
+
+  commitSHA ??= resolveGitHeadSHA(gitFolderPath)
+
+  cache.enabled = { commitSHA, repositoryUrl }
+  return cache.enabled
+}
+
+module.exports = getGitMetadata

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

@@ -1,17 +1,25 @@
 'use strict'
 
 const { SCI_COMMIT_SHA, SCI_REPOSITORY_URL } = require('./constants')
+const getGitMetadata = require('./git_metadata')
 
 class GitMetadataTagger {
+  #commitSHA
+  #repositoryUrl
+  #enabled
+
   constructor (config) {
-    this._config = config
+    this.#enabled = config.DD_TRACE_GIT_METADATA_ENABLED
+    const { commitSHA, repositoryUrl } = getGitMetadata(config)
+    this.#commitSHA = commitSHA
+    this.#repositoryUrl = repositoryUrl
   }
 
   tagGitMetadata (spanContext) {
-    if (this._config.gitMetadataEnabled) {
-      // These tags are added only to the local root span
-      spanContext._trace.tags[SCI_COMMIT_SHA] = this._config.commitSHA
-      spanContext._trace.tags[SCI_REPOSITORY_URL] = this._config.repositoryUrl
+    if (this.#enabled) {
+      const tags = spanContext._trace.tags
+      tags[SCI_COMMIT_SHA] = this.#commitSHA
+      tags[SCI_REPOSITORY_URL] = this.#repositoryUrl
     }
   }
 }

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

@@ -2,10 +2,11 @@
 
 var path = require('path')
 var Module = require('module')
+
+var nodeVersion = require('../../../../version')
 var isTrue = require('./util').isTrue
 var log = require('./log')
 var telemetry = require('./telemetry')
-var nodeVersion = require('../../../../version')
 
 var NODE_MAJOR = nodeVersion.NODE_MAJOR
 
@@ -13,9 +14,13 @@ function guard (fn) {
   var initBailout = false
   var clobberBailout = false
   var forced = isTrue(process.env.DD_INJECT_FORCE)
-  var engines = require('../../../../package.json').engines
-  var minMajor = parseInt(engines.node.replace(/[^0-9]/g, ''))
+  var pkg = require('../../../../package.json')
+  var engines = pkg.engines
+  var versions = engines.node.match(/^>=(\d+)$/)
+  var minMajor = versions[1]
+  var nextMajor = pkg.nodeMaxMajor
   var version = process.versions.node
+  var supportedRange = engines.node + ' <' + nextMajor
 
   if (process.env.DD_INJECTION_ENABLED) {
     // If we're running via single-step install, and we're in the app's
@@ -40,18 +45,19 @@ function guard (fn) {
 
   // If the runtime doesn't match the engines field in package.json, then we
   // should not initialize the tracer.
-  if (!clobberBailout && NODE_MAJOR < minMajor) {
+  if (!clobberBailout && (NODE_MAJOR < minMajor || NODE_MAJOR >= nextMajor)) {
     initBailout = true
+    var runtimeInfo = 'Incompatible runtime Node.js ' + version + ', supported runtimes: Node.js ' + supportedRange
     telemetry([
       { name: 'abort', tags: ['reason:incompatible_runtime'] },
       { name: 'abort.runtime', tags: [] }
     ], undefined, {
       result: 'abort',
       result_class: 'incompatible_runtime',
-      result_reason: 'Incompatible runtime Node.js ' + version + ', supported runtimes: Node.js ' + engines.node
+      result_reason: runtimeInfo
     })
     log.info('Aborting application instrumentation due to incompatible_runtime.')
-    log.info('Found incompatible runtime Node.js %s, Supported runtimes: Node.js %s.', version, engines.node)
+    log.info('Found incompatible runtime Node.js %s, Supported runtimes: Node.js %s.', version, supportedRange)
     if (forced) {
       log.info('DD_INJECT_FORCE enabled, allowing unsupported runtimes and continuing.')
     }

package/packages/dd-trace/src/guardrails/telemetry.js

@@ -74,13 +74,13 @@ function sendTelemetry (name, tags, resultMetadata) {
     }
   }
 
-  var proc = spawn(process.env.DD_TELEMETRY_FORWARDER_PATH, ['library_entrypoint'], {
+  var proc = spawn(telemetryForwarderPath, ['library_entrypoint'], {
     stdio: 'pipe'
   })
   proc.on('error', function () {
     log.error('Failed to spawn telemetry forwarder')
   })
-  proc.on('exit', function (code) {
+  proc.once('exit', function (code) {
     if (code !== 0) {
       log.error('Telemetry forwarder exited with code', code)
     }

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

@@ -8,11 +8,11 @@ const { threadId } = require('worker_threads')
 const log = require('./log')
 
 async function scheduleSnapshot (config, total) {
-  if (total > config.heapSnapshot.count) return
+  if (total > config.DD_HEAP_SNAPSHOT_COUNT) return
 
-  await setTimeout(config.heapSnapshot.interval * 1000, null, { ref: false })
+  await setTimeout(config.DD_HEAP_SNAPSHOT_INTERVAL * 1000, null, { ref: false })
   await clearMemory()
-  writeHeapSnapshot(getName(config.heapSnapshot.destination))
+  writeHeapSnapshot(getName(config.DD_HEAP_SNAPSHOT_DESTINATION))
   await scheduleSnapshot(config, total + 1)
 }
 
@@ -45,8 +45,11 @@ function getName (destination) {
 }
 
 module.exports = {
+  /**
+   * @param {import('./config/config-base')} config - Tracer configuration
+   */
   async start (config) {
-    const destination = config.heapSnapshot.destination
+    const destination = config.DD_HEAP_SNAPSHOT_DESTINATION
 
     try {
       await scheduleSnapshot(config, 1)
@@ -54,5 +57,5 @@ module.exports = {
     } catch (e) {
       log.error('Failed to write heap snapshots to %s.', destination, e)
     }
-  }
+  },
 }

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const { DDSketch } = require('@datadog/sketches-js')
+const { DDSketch } = require('../../../vendor/dist/@datadog/sketches-js')
 
 class Histogram {
   constructor () {

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

@@ -7,51 +7,101 @@ const UINT_MAX = 4_294_967_296
 const data = new Uint8Array(8 * 8192)
 const zeroId = new Uint8Array(8)
 
-const map = Array.prototype.map
-const pad = byte => `${byte < 16 ? '0' : ''}${byte.toString(16)}`
-
 let batch = 0
 
 // Internal representation of a trace or span ID.
 class Identifier {
+  /** @type {number[] | Uint8Array} */
+  #buffer
+  /** @type {bigint | undefined} */
+  #bigInt
+  /** @type {string | undefined} */
+  #stringHex
+  /** @type {string | undefined} */
+  #stringDecimal
+
+  /**
+   * @param {string} value
+   * @param {number} [radix]
+   */
   constructor (value, radix = 16) {
-    this._buffer = radix === 16
+    this.#buffer = radix === 16
       ? createBuffer(value)
       : fromString(value, radix)
   }
 
+  /**
+   * @param {number} [radix]
+   * @returns {string}
+   */
   toString (radix = 16) {
-    return radix === 16
-      ? toHexString(this._buffer)
-      : 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
   }
 
+  /**
+   * @returns {number[] | Uint8Array}
+   */
   toBuffer () {
-    return this._buffer
+    return this.#buffer
   }
 
+  /**
+   * @returns {number[] | Uint8Array}
+   */
   toArray () {
-    if (this._buffer.length === 8) {
-      return this._buffer
+    if (this.#buffer.length === 8) {
+      return this.#buffer
     }
-    return this._buffer.slice(-8)
+    return this.#buffer.slice(-8)
   }
 
+  /**
+   * @returns {string}
+   */
   toJSON () {
     return this.toString()
   }
 
-  equals (other) {
-    const length = this._buffer.length
-    const otherLength = other._buffer.length
+  /**
+   * Returns the full hex trace ID. When this is a 64-bit identifier and `traceIdHigh`
+   * is provided, prepends it to form the 128-bit trace ID. Otherwise returns
+   * only this identifier's hex representation.
+   *
+   * @param {string | undefined} traceIdHigh - 16-char hex of the upper 64 bits, or undefined
+   * @returns {string}
+   */
+  toTraceIdHex (traceIdHigh) {
+    if (traceIdHigh && this.#buffer.length <= 8) {
+      return traceIdHigh + this.toString(16)
+    }
+    return this.toString(16)
+  }
 
-    // Only compare the bytes available in both IDs.
-    for (let i = length, j = otherLength; i >= 0 && j >= 0; i--, j--) {
-      if (this._buffer[i] !== other._buffer[j]) return false
+  /**
+   * @param {Identifier} other
+   * @returns {boolean}
+   */
+  equals (other) {
+    // Big-endian suffix compare: when buffers differ in length, only the
+    // rightmost `min(this.length, other.length)` bytes are checked.
+    for (let i = this.#buffer.length - 1, j = other.#buffer.length - 1; i >= 0 && j >= 0; i--, j--) {
+      if (this.#buffer[i] !== other.#buffer[j]) return false
     }
 
     return true
@@ -59,6 +109,10 @@ class Identifier {
 }
 
 // Create a buffer, using an optional hexadecimal value if provided.
+/**
+ * @param {string} value
+ * @returns {number[] | Uint8Array}
+ */
 function createBuffer (value) {
   if (value === '0') return zeroId
   if (!value) return pseudoRandom()
@@ -77,6 +131,11 @@ function createBuffer (value) {
 }
 
 // Convert a numerical string to a buffer using the specified radix.
+/**
+ * @param {string} str
+ * @param {number} raddix
+ * @returns {number[]}
+ */
 function fromString (str, raddix) {
   const buffer = new Array(8)
   const len = str.length
@@ -116,6 +175,11 @@ function fromString (str, raddix) {
 }
 
 // Convert a buffer to a numerical string.
+/**
+ * @param {number[] | Uint8Array} buffer
+ * @param {number} [radix]
+ * @returns {string}
+ */
 function toNumberString (buffer, radix) {
   let high = readInt32(buffer, buffer.length - 8)
   let low = readInt32(buffer, buffer.length - 4)
@@ -136,12 +200,10 @@ function toNumberString (buffer, radix) {
   return str
 }
 
-// Convert a buffer to a hexadecimal string.
-function toHexString (buffer) {
-  return map.call(buffer, pad).join('')
-}
-
 // Simple pseudo-random 64-bit ID generator.
+/**
+ * @returns {number[] | Uint8Array}
+ */
 function pseudoRandom () {
   if (batch === 0) {
     randomFillSync(data)
@@ -159,11 +221,16 @@ function pseudoRandom () {
     data[offset + 4],
     data[offset + 5],
     data[offset + 6],
-    data[offset + 7]
+    data[offset + 7],
   ]
 }
 
 // Read a buffer to unsigned integer bytes.
+/**
+ * @param {number[] | Uint8Array} buffer
+ * @param {number} offset
+ * @returns {number}
+ */
 function readInt32 (buffer, offset) {
   return (buffer[offset + 0] * 16_777_216) +
     (buffer[offset + 1] << 16) +
@@ -172,6 +239,11 @@ function readInt32 (buffer, offset) {
 }
 
 // Write unsigned integer bytes to a buffer.
+/**
+ * @param {number[] | Uint8Array} buffer
+ * @param {number} value
+ * @param {number} offset
+ */
 function writeUInt32BE (buffer, value, offset) {
   buffer[3 + offset] = value & 255
   value >>= 8
@@ -182,6 +254,13 @@ function writeUInt32BE (buffer, value, offset) {
   buffer[0 + offset] = value & 255
 }
 
+/**
+ * @param {string} [value]
+ * @param {number} [radix]
+ * @returns {Identifier}
+ */
 module.exports = function createIdentifier (value, radix) {
-  return new Identifier(value, radix)
+  return new Identifier(value ?? '', radix)
 }
+
+module.exports.Identifier = Identifier

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

@@ -8,7 +8,7 @@ addHook((name, namespace) => {
   if (moduleLoadStartChannel.hasSubscribers) {
     moduleLoadStartChannel.publish({
       filename: name,
-      module: namespace
+      module: namespace,
     })
   }
 })

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

@@ -1,14 +1,16 @@
 'use strict'
 
-const { isFalse } = require('./util')
-const { getEnvironmentVariable } = require('../../dd-trace/src/config-helper')
+const { getValueFromEnvSources } = require('./config/helper')
 
 // Global `jest` is only present in Jest workers.
 const inJestWorker = typeof jest !== 'undefined'
 
-const ddTraceDisabled = getEnvironmentVariable('DD_TRACE_ENABLED')
-  ? isFalse(getEnvironmentVariable('DD_TRACE_ENABLED'))
-  : String(getEnvironmentVariable('OTEL_TRACES_EXPORTER')).toLowerCase() === 'none'
+// skipDefault: distinguish an unset DD_TRACE_ENABLED (fall back to the OTel signal) from an
+// explicit value; the registered default would otherwise mask the OTEL_TRACES_EXPORTER check.
+const ddTraceEnabled = getValueFromEnvSources('DD_TRACE_ENABLED', true)
+const ddTraceDisabled = ddTraceEnabled === undefined
+  ? getValueFromEnvSources('OTEL_TRACES_EXPORTER') === 'none'
+  : ddTraceEnabled === false
 
 module.exports = ddTraceDisabled || inJestWorker
   ? require('./noop/proxy')

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

@@ -0,0 +1,27 @@
+'use strict'
+
+const log = require('../log')
+
+/**
+ * Extracts the context from the given Lambda handler arguments.
+ *
+ * It is possible for users to define a lambda function without specifying a
+ * context arg. In these cases, this function returns null instead of throwing
+ * an error.
+ *
+ * @param {unknown[]} args any amount of arguments
+ * @returns {object | null}
+ */
+exports.extractContext = function extractContext (args) {
+  let context = null
+  for (let i = 0; i < args.length && i < 3; i++) {
+    if (args[i] && typeof args[i].getRemainingTimeInMillis === 'function') {
+      context = args[i]
+      break
+    }
+  }
+  if (!context) {
+    log.debug('Unable to extract context object from Lambda handler arguments')
+  }
+  return context
+}

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

@@ -4,10 +4,8 @@ const log = require('../log')
 const { channel } = require('../../../datadog-instrumentations/src/helpers/instrument')
 const { ERROR_MESSAGE, ERROR_TYPE } = require('../constants')
 const { ImpendingTimeout } = require('./runtime/errors')
-const { getEnvironmentVariable } = require('../config-helper')
+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.
@@ -21,13 +19,11 @@ let __lambdaTimeout
  * Publishes to the `apm:aws:lambda:timeout` channel when
  * the AWS Lambda run time is about to end.
  *
- * @param {*} context AWS Lambda context object.
+ * @param {object} context AWS Lambda context object.
  */
 function checkTimeout (context) {
   const remainingTimeInMillis = context.getRemainingTimeInMillis()
-
-  let apmFlushDeadline = Number.parseInt(getEnvironmentVariable('DD_APM_FLUSH_DEADLINE_MILLISECONDS')) || 100
-  apmFlushDeadline = apmFlushDeadline < 0 ? 100 : apmFlushDeadline
+  const apmFlushDeadline = global._ddtrace._tracer._config.DD_APM_FLUSH_DEADLINE_MILLISECONDS
 
   __lambdaTimeout = setTimeout(() => {
     timeoutChannel.publish()
@@ -43,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.')
@@ -50,7 +47,7 @@ function crashFlush () {
     const error = new ImpendingTimeout('Datadog detected an impending timeout')
     activeSpan.addTags({
       [ERROR_MESSAGE]: error.message,
-      [ERROR_TYPE]: error.name
+      [ERROR_TYPE]: error.name,
     })
   }
 
@@ -60,33 +57,19 @@ function crashFlush () {
   }
 }
 
-/**
- * Extracts the context from the given Lambda handler arguments.
- *
- * @param {*} args any amount of arguments
- * @returns the context, if extraction was succesful.
- */
-function extractContext (args) {
-  let context = args.length > 1 ? args[1] : undefined
-  if (context === undefined || context.getRemainingTimeInMillis === undefined) {
-    context = args.length > 2 ? args[2] : undefined
-    if (context === undefined || context.getRemainingTimeInMillis === undefined) {
-      throw new Error('Could not extract context')
-    }
-  }
-  return context
-}
-
 /**
  * Patches your AWS Lambda handler function to add some tracing support.
  *
- * @param {*} lambdaHandler a Lambda handler function.
+ * @param {Function} lambdaHandler a Lambda handler function.
  */
 exports.datadog = function datadog (lambdaHandler) {
   return (...args) => {
     const context = extractContext(args)
 
-    checkTimeout(context)
+    if (context) {
+      checkTimeout(context)
+    }
+
     const result = lambdaHandler.apply(this, args)
     if (result && typeof result.then === 'function') {
       return result.then((res) => {