@depup/dd-trace 5.90.0-depup.0

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

@@ -0,0 +1,35 @@
+'use strict'
+
+const { DDSketch } = require('../../../vendor/dist/@datadog/sketches-js')
+
+class Histogram {
+  constructor () {
+    this.reset()
+  }
+
+  get min () { return this._sketch.count === 0 ? 0 : this._sketch.min }
+  get max () { return this._sketch.count === 0 ? 0 : this._sketch.max }
+  get avg () { return this._sketch.count === 0 ? 0 : this._sketch.sum / this._sketch.count }
+  get sum () { return this._sketch.sum }
+  get count () { return this._sketch.count }
+  get median () { return this.percentile(50) }
+  get p95 () { return this.percentile(95) }
+
+  percentile (percentile) {
+    return this._sketch.getValueAtQuantile(percentile / 100) || 0
+  }
+
+  merge (histogram) {
+    return this._sketch.merge(histogram._sketch)
+  }
+
+  record (value) {
+    this._sketch.accept(value)
+  }
+
+  reset () {
+    this._sketch = new DDSketch()
+  }
+}
+
+module.exports = Histogram

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

@@ -0,0 +1,247 @@
+'use strict'
+
+const { randomFillSync } = require('crypto')
+
+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 {
+  /**
+   * @param {string} value
+   * @param {number} [radix]
+   */
+  constructor (value, 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)
+  }
+
+  /**
+   * @returns {bigint}
+   */
+  toBigInt () {
+    return Buffer.from(this._buffer).readBigUInt64BE(0)
+  }
+
+  /**
+   * @returns {number[] | Uint8Array}
+   */
+  toBuffer () {
+    return this._buffer
+  }
+
+  /**
+   * @returns {number[] | Uint8Array}
+   */
+  toArray () {
+    if (this._buffer.length === 8) {
+      return this._buffer
+    }
+    return this._buffer.slice(-8)
+  }
+
+  /**
+   * @returns {string}
+   */
+  toJSON () {
+    return this.toString()
+  }
+
+  /**
+   * @param {Identifier} other
+   * @returns {boolean}
+   */
+  equals (other) {
+    const length = this._buffer.length
+    const otherLength = other._buffer.length
+
+    // 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
+    }
+
+    return true
+  }
+}
+
+// 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()
+
+  const size = Math.ceil(value.length / 16) * 16
+  const bytes = size / 2
+  const buffer = []
+
+  value = value.padStart(size, '0')
+
+  for (let i = 0; i < bytes; i++) {
+    buffer[i] = Number.parseInt(value.slice(i * 2, i * 2 + 2), 16)
+  }
+
+  return buffer
+}
+
+// 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
+
+  let pos = 0
+  let high = 0
+  let low = 0
+
+  if (str[0] === '-') pos++
+
+  const sign = pos
+
+  while (pos < len) {
+    const chr = Number.parseInt(str[pos++], raddix)
+
+    if (!(chr >= 0)) break // NaN
+
+    low = low * raddix + chr
+    high = high * raddix + Math.floor(low / UINT_MAX)
+    low %= UINT_MAX
+  }
+
+  if (sign) {
+    high = ~high
+
+    if (low) {
+      low = UINT_MAX - low
+    } else {
+      high++
+    }
+  }
+
+  writeUInt32BE(buffer, high, 0)
+  writeUInt32BE(buffer, low, 4)
+
+  return buffer
+}
+
+// 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)
+  let str = ''
+
+  radix = radix || 10
+
+  while (1) {
+    const mod = (high % radix) * UINT_MAX + low
+
+    high = Math.floor(high / radix)
+    low = Math.floor(mod / radix)
+    str = (mod % radix).toString(radix) + str
+
+    if (!high && !low) break
+  }
+
+  return str
+}
+
+// Convert a buffer to a hexadecimal string.
+/**
+ * @param {number[] | Uint8Array} buffer
+ * @returns {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)
+  }
+
+  batch = (batch + 1) % 8192
+
+  const offset = batch * 8
+
+  return [
+    data[offset] & 0x7F, // only positive int64,
+    data[offset + 1],
+    data[offset + 2],
+    data[offset + 3],
+    data[offset + 4],
+    data[offset + 5],
+    data[offset + 6],
+    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) +
+    (buffer[offset + 2] << 8) +
+    buffer[offset + 3]
+}
+
+// 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
+  buffer[2 + offset] = value & 255
+  value >>= 8
+  buffer[1 + offset] = value & 255
+  value >>= 8
+  buffer[0 + offset] = value & 255
+}
+
+/**
+ * @param {string} [value]
+ * @param {number} [radix]
+ * @returns {Identifier}
+ */
+module.exports = function createIdentifier (value, radix) {
+  return new Identifier(value ?? '', radix)
+}

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

@@ -0,0 +1,15 @@
+'use strict'
+
+const { addHook } = require('import-in-the-middle')
+const dc = require('dc-polyfill')
+
+const moduleLoadStartChannel = dc.channel('dd-trace:moduleLoadStart')
+addHook((name, namespace) => {
+  if (moduleLoadStartChannel.hasSubscribers) {
+    moduleLoadStartChannel.publish({
+      filename: name,
+      module: namespace,
+    })
+  }
+})
+module.exports = require('import-in-the-middle')

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

@@ -0,0 +1,15 @@
+'use strict'
+
+const { getValueFromEnvSources } = require('./config/helper')
+const { isFalse } = require('./util')
+
+// Global `jest` is only present in Jest workers.
+const inJestWorker = typeof jest !== 'undefined'
+
+const ddTraceDisabled = getValueFromEnvSources('DD_TRACE_ENABLED')
+  ? isFalse(getValueFromEnvSources('DD_TRACE_ENABLED'))
+  : String(getValueFromEnvSources('OTEL_TRACES_EXPORTER')).toLowerCase() === 'none'
+
+module.exports = ddTraceDisabled || inJestWorker
+  ? require('./noop/proxy')
+  : require('./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.js

@@ -0,0 +1,87 @@
+'use strict'
+
+const log = require('../log')
+const { channel } = require('../../../datadog-instrumentations/src/helpers/instrument')
+const { ERROR_MESSAGE, ERROR_TYPE } = require('../constants')
+const { getValueFromEnvSources } = require('../config/helper')
+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.
+timeoutChannel.subscribe(_ => {
+  crashFlush()
+})
+
+let __lambdaTimeout
+
+/**
+ * Publishes to the `apm:aws:lambda:timeout` channel when
+ * the AWS Lambda run time is about to end.
+ *
+ * @param {object} context AWS Lambda context object.
+ */
+function checkTimeout (context) {
+  const remainingTimeInMillis = context.getRemainingTimeInMillis()
+
+  let apmFlushDeadline = Number.parseInt(getValueFromEnvSources('DD_APM_FLUSH_DEADLINE_MILLISECONDS')) || 100
+  apmFlushDeadline = apmFlushDeadline < 0 ? 100 : apmFlushDeadline
+
+  __lambdaTimeout = setTimeout(() => {
+    timeoutChannel.publish()
+  }, remainingTimeInMillis - apmFlushDeadline)
+}
+
+/**
+ * Grabs the current span, adds an error for an impending timeout.
+ *
+ * After that, it calls `killAll` on the tracer processor
+ * in order to kill remaining unfinished spans.
+ *
+ * Once that is done, it finishes the last span.
+ */
+function crashFlush () {
+  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.')
+  } else {
+    const error = new ImpendingTimeout('Datadog detected an impending timeout')
+    activeSpan.addTags({
+      [ERROR_MESSAGE]: error.message,
+      [ERROR_TYPE]: error.name,
+    })
+  }
+
+  tracer._processor.killAll()
+  if (activeSpan !== null) {
+    activeSpan.finish()
+  }
+}
+
+/**
+ * Patches your AWS Lambda handler function to add some tracing support.
+ *
+ * @param {Function} lambdaHandler a Lambda handler function.
+ */
+exports.datadog = function datadog (lambdaHandler) {
+  return (...args) => {
+    const context = extractContext(args)
+
+    if (context) {
+      checkTimeout(context)
+    }
+
+    const result = lambdaHandler.apply(this, args)
+    if (result && typeof result.then === 'function') {
+      return result.then((res) => {
+        clearTimeout(__lambdaTimeout)
+        return res
+      })
+    }
+    clearTimeout(__lambdaTimeout)
+    return result
+  }
+}

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

@@ -0,0 +1,17 @@
+'use strict'
+
+const { getValueFromEnvSources } = require('../config/helper')
+const { registerLambdaHook } = require('./runtime/ritm')
+
+/**
+ * It is safe to do it this way, since customers will never be expected to disable
+ * this specific instrumentation through the init config object.
+ */
+const _DD_TRACE_DISABLED_INSTRUMENTATIONS = getValueFromEnvSources('DD_TRACE_DISABLED_INSTRUMENTATIONS') || ''
+const _disabledInstrumentations = new Set(
+  _DD_TRACE_DISABLED_INSTRUMENTATIONS ? _DD_TRACE_DISABLED_INSTRUMENTATIONS.split(',') : []
+)
+
+if (!_disabledInstrumentations.has('lambda')) {
+  registerLambdaHook()
+}

package/packages/dd-trace/src/lambda/runtime/errors.js

@@ -0,0 +1,20 @@
+/**
+ * Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Defines custom error types throwable by the runtime.
+ */
+'use strict'
+
+class ExtendedError extends Error {
+  constructor (reason) {
+    super(reason)
+    Object.setPrototypeOf(this, new.target.prototype)
+  }
+}
+
+class ImpendingTimeout extends ExtendedError {}
+ImpendingTimeout.prototype.name = 'Impending Timeout'
+
+module.exports = {
+  ImpendingTimeout,
+}

package/packages/dd-trace/src/lambda/runtime/patch.js

@@ -0,0 +1,77 @@
+'use strict'
+
+const path = require('path')
+
+const { datadog } = require('../handler')
+const { addHook } = require('../../../../datadog-instrumentations/src/helpers/instrument')
+const shimmer = require('../../../../datadog-shimmer')
+const { getEnvironmentVariable, getValueFromEnvSources } = require('../../config/helper')
+const { _extractModuleNameAndHandlerPath, _extractModuleRootAndHandler, _getLambdaFilePaths } = require('./ritm')
+
+/**
+ * Patches a Datadog Lambda module by calling `patchDatadogLambdaHandler`
+ * with the handler name `datadog`.
+ *
+ * @param {object} datadogLambdaModule node module to be patched.
+ * @returns a Datadog Lambda module with the `datadog` function from
+ * `datadog-lambda-js` patched.
+ */
+const patchDatadogLambdaModule = (datadogLambdaModule) => {
+  shimmer.wrap(datadogLambdaModule, 'datadog', patchDatadogLambdaHandler)
+
+  return datadogLambdaModule
+}
+
+/**
+ * Patches a Datadog Lambda handler in order to do
+ * Datadog instrumentation by getting the Lambda handler from its
+ * arguments.
+ *
+ * @param {Function} datadogHandler the Datadog Lambda handler to destructure.
+ * @returns the datadogHandler with its arguments patched.
+ */
+function patchDatadogLambdaHandler (datadogHandler) {
+  return (userHandler) => {
+    return datadogHandler(datadog(userHandler))
+  }
+}
+
+/**
+ * Patches a Lambda module on the given handler path.
+ *
+ * @param {string} handlerPath path of the handler to be patched.
+ * @returns a module with the given handler path patched.
+ */
+const patchLambdaModule = (handlerPath) => (lambdaModule) => {
+  shimmer.wrap(lambdaModule, handlerPath, patchLambdaHandler)
+
+  return lambdaModule
+}
+
+/**
+ * Patches a Lambda handler in order to do Datadog instrumentation.
+ *
+ * @param {Function} lambdaHandler the Lambda handler to be patched.
+ * @returns a function which patches the given Lambda handler.
+ */
+function patchLambdaHandler (lambdaHandler) {
+  return datadog(lambdaHandler)
+}
+
+const lambdaTaskRoot = getEnvironmentVariable('LAMBDA_TASK_ROOT')
+const originalLambdaHandler = getValueFromEnvSources('DD_LAMBDA_HANDLER')
+
+if (originalLambdaHandler === undefined) {
+  // Instrumentation is done manually.
+  addHook({ name: 'datadog-lambda-js' }, patchDatadogLambdaModule)
+} else {
+  const [moduleRoot, moduleAndHandler] = _extractModuleRootAndHandler(originalLambdaHandler)
+  const [_module, handlerPath] = _extractModuleNameAndHandlerPath(moduleAndHandler)
+
+  const lambdaStylePath = path.resolve(lambdaTaskRoot, moduleRoot, _module)
+  const lambdaFilePaths = _getLambdaFilePaths(lambdaStylePath)
+
+  for (const lambdaFilePath of lambdaFilePaths) {
+    addHook({ name: lambdaFilePath }, patchLambdaModule(handlerPath))
+  }
+}

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

@@ -0,0 +1,133 @@
+/**
+ * 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')
+
+const log = require('../../log')
+const { getEnvironmentVariable, getValueFromEnvSources } = require('../../config/helper')
+const Hook = require('../../../../datadog-instrumentations/src/helpers/hook')
+const instrumentations = require('../../../../datadog-instrumentations/src/helpers/instrumentations')
+const {
+  filename,
+  pathSepExpr,
+} = require('../../../../datadog-instrumentations/src/helpers/register')
+
+/**
+ * Breaks the full handler string into two pieces: the module root
+ * and the actual handler string.
+ *
+ * @param {string} fullHandler user's lambda handler, commonly stored in `DD_LAMBDA_HANDLER`.
+ * @returns {string[]} an array containing the module root and the handler string.
+ *
+ * ```js
+ * _extractModuleRootAndHandler('./api/src/index.nested.handler')
+ * // => ['./api/src', 'index.nested.handler']
+ * ```
+ */
+function _extractModuleRootAndHandler (fullHandler) {
+  const handlerString = path.basename(fullHandler)
+  const moduleRoot = fullHandler.slice(0, Math.max(0, fullHandler.indexOf(handlerString)))
+
+  return [moduleRoot, handlerString]
+}
+
+/**
+ * Splits the handler string into two pieces: the module name
+ * and the path to the handler function.
+ *
+ * @param {string} handler a handler string containing the module and the handler path.
+ * @returns {string[]} an array containing the module name and the handler path.
+ *
+ * ```js
+ * _extractModuleNameAndHandlerPath('index.nested.handler')
+ * // => ['index', 'nested.handler']
+ * ```
+ */
+function _extractModuleNameAndHandlerPath (handler) {
+  const FUNCTION_EXPR = /^([^.]*)\.(.*)$/
+  const match = handler.match(FUNCTION_EXPR)
+  if (!match || match.length !== 3) {
+    throw new Error(`Malformed handler name: ${handler}`)
+  }
+  return [match[1], match[2]] // [module, handler-path]
+}
+
+/**
+ * Returns all possible paths of the files to be patched when required.
+ *
+ * @param {string} lambdaStylePath the path comprised of the `LAMBDA_TASK_ROOT`,
+ * the root of the module of the Lambda handler, and the module name.
+ * @returns the lambdaStylePath with appropiate extensions for the hook.
+ */
+function _getLambdaFilePaths (lambdaStylePath) {
+  return [
+    `${lambdaStylePath}.js`,
+    `${lambdaStylePath}.mjs`,
+    `${lambdaStylePath}.cjs`,
+  ]
+}
+
+/**
+ * Register a hook for the Lambda handler to be executed when
+ * the file is required.
+ */
+const registerLambdaHook = () => {
+  const lambdaTaskRoot = getEnvironmentVariable('LAMBDA_TASK_ROOT')
+  const originalLambdaHandler = getValueFromEnvSources('DD_LAMBDA_HANDLER')
+
+  if (originalLambdaHandler !== undefined && lambdaTaskRoot !== undefined) {
+    const [moduleRoot, moduleAndHandler] = _extractModuleRootAndHandler(originalLambdaHandler)
+    const [_module] = _extractModuleNameAndHandlerPath(moduleAndHandler)
+
+    const lambdaStylePath = path.resolve(lambdaTaskRoot, moduleRoot, _module)
+    const lambdaFilePaths = _getLambdaFilePaths(lambdaStylePath)
+
+    // TODO: Redo this like any other instrumentation.
+    Hook(lambdaFilePaths, (moduleExports, name) => {
+      require('./patch')
+
+      for (const { hook } of instrumentations[name]) {
+        try {
+          moduleExports = hook(moduleExports)
+        } catch (e) {
+          log.error('Error executing lambda hook', e)
+        }
+      }
+
+      return moduleExports
+    })
+  } else {
+    const moduleToPatch = 'datadog-lambda-js'
+    Hook([moduleToPatch], (moduleExports, moduleName, _) => {
+      moduleName = moduleName.replace(pathSepExpr, '/')
+
+      require('./patch')
+
+      for (const { name, file, hook } of instrumentations[moduleToPatch]) {
+        const fullFilename = filename(name, file)
+        if (moduleName === fullFilename) {
+          try {
+            moduleExports = hook(moduleExports)
+          } catch (e) {
+            log.error('Error executing lambda hook for datadog-lambda-js', e)
+          }
+        }
+      }
+
+      return moduleExports
+    })
+  }
+}
+
+module.exports = {
+  _extractModuleRootAndHandler,
+  _extractModuleNameAndHandlerPath,
+  _getLambdaFilePaths,
+  registerLambdaHook,
+}