@depup/dd-trace 5.90.0-depup.0

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

@@ -0,0 +1,61 @@
+'use strict'
+
+module.exports = {
+  SAMPLING_PRIORITY_KEY: '_sampling_priority_v1',
+  ANALYTICS_KEY: '_dd1.sr.eausr',
+  ORIGIN_KEY: '_dd.origin',
+  HOSTNAME_KEY: '_dd.hostname',
+  TOP_LEVEL_KEY: '_dd.top_level',
+  SAMPLING_RULE_DECISION: '_dd.rule_psr',
+  SAMPLING_LIMIT_DECISION: '_dd.limit_psr',
+  SAMPLING_AGENT_DECISION: '_dd.agent_psr',
+  SAMPLING_MECHANISM_DEFAULT: 0,
+  SAMPLING_MECHANISM_AGENT: 1,
+  SAMPLING_MECHANISM_RULE: 3,
+  SAMPLING_MECHANISM_MANUAL: 4,
+  SAMPLING_MECHANISM_APPSEC: 5,
+  SAMPLING_MECHANISM_SPAN: 8,
+  SAMPLING_MECHANISM_REMOTE_USER: 11,
+  SAMPLING_MECHANISM_REMOTE_DYNAMIC: 12,
+  SAMPLING_MECHANISM_AI_GUARD: 13,
+  SPAN_SAMPLING_MECHANISM: '_dd.span_sampling.mechanism',
+  SPAN_SAMPLING_RULE_RATE: '_dd.span_sampling.rule_rate',
+  SPAN_SAMPLING_MAX_PER_SECOND: '_dd.span_sampling.max_per_second',
+  DATADOG_LAMBDA_EXTENSION_PATH: '/opt/extensions/datadog-agent',
+  DECISION_MAKER_KEY: '_dd.p.dm',
+  PROCESS_ID: 'process_id',
+  ERROR_TYPE: 'error.type',
+  ERROR_MESSAGE: 'error.message',
+  ERROR_STACK: 'error.stack',
+  IGNORE_OTEL_ERROR: Symbol('ignore.otel.error'),
+  COMPONENT: 'component',
+  CLIENT_PORT_KEY: 'network.destination.port',
+  PEER_SERVICE_KEY: 'peer.service',
+  PEER_SERVICE_SOURCE_KEY: '_dd.peer.service.source',
+  PEER_SERVICE_REMAP_KEY: '_dd.peer.service.remapped_from',
+  SCI_REPOSITORY_URL: '_dd.git.repository_url',
+  SCI_COMMIT_SHA: '_dd.git.commit.sha',
+  APM_TRACING_ENABLED_KEY: '_dd.apm.enabled',
+  TRACE_SOURCE_PROPAGATION_KEY: '_dd.p.ts',
+  PAYLOAD_TAG_REQUEST_PREFIX: 'aws.request.body',
+  PAYLOAD_TAG_RESPONSE_PREFIX: 'aws.response.body',
+  PAYLOAD_TAGGING_MAX_TAGS: 758,
+  SCHEMA_DEFINITION: 'schema.definition',
+  SCHEMA_WEIGHT: 'schema.weight',
+  SCHEMA_TYPE: 'schema.type',
+  SCHEMA_ID: 'schema.id',
+  SCHEMA_TOPIC: 'schema.topic',
+  SCHEMA_OPERATION: 'schema.operation',
+  SCHEMA_NAME: 'schema.name',
+  DYNAMODB_PTR_KIND: 'aws.dynamodb.item',
+  S3_PTR_KIND: 'aws.s3.object',
+  WEBSOCKET_PTR_KIND: 'websocket',
+  SPAN_POINTER_DIRECTION: Object.freeze({
+    UPSTREAM: 'u',
+    DOWNSTREAM: 'd',
+  }),
+  SPAN_POINTER_DIRECTION_NAME: Object.freeze({
+    UPSTREAM: 'span-pointer-up',
+    DOWNSTREAM: 'span-pointer-down',
+  }),
+}

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

@@ -0,0 +1,120 @@
+'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 { getAgentUrl } = require('../agent/url')
+const pkg = require('../../../../package.json')
+const processTags = require('../process-tags')
+
+class Crashtracker {
+  #started = false
+
+  configure (config) {
+    if (!this.#started) return
+
+    try {
+      binding.updateConfig(this.#getConfig(config))
+      binding.updateMetadata(this.#getMetadata(config))
+    } catch (e) {
+      log.error('Error configuring crashtracker', e)
+    }
+  }
+
+  start (config) {
+    if (this.#started) return this.configure(config)
+
+    this.#started = true
+
+    try {
+      binding.init(
+        this.#getConfig(config),
+        this.#getReceiverConfig(),
+        this.#getMetadata(config)
+      )
+    } catch (e) {
+      log.error('Error initialising crashtracker', e)
+    }
+  }
+
+  withProfilerSerializing (f) {
+    binding.beginProfilerSerializing()
+    try {
+      return f()
+    } finally {
+      binding.endProfilerSerializing()
+    }
+  }
+
+  // TODO: Send only configured values when defaults are fixed.
+  #getConfig (config) {
+    const url = getAgentUrl(config)
+
+    // Out-of-process symbolication currently (crashtracker 27.0.0) works on
+    // Linux only, does not work on Mac.
+    const resolveMode = require('os').platform === 'linux'
+      ? 'EnabledWithSymbolsInReceiver'
+      : 'EnabledWithInprocessSymbols'
+
+    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: { secs: 5, nanos: 0 },
+      demangle_names: false,
+      signals: [],
+      resolve_frames: resolveMode,
+    }
+  }
+
+  #getMetadata (config) {
+    const tags = Object.keys(config.tags).map(key => `${key}:${config.tags[key]}`)
+
+    // Add process tags to the tags array
+    for (const [key, value] of processTags.tags) {
+      if (value !== undefined) {
+        tags.push(`${key}:${value}`)
+      }
+    }
+
+    return {
+      library_name: pkg.name,
+      library_version: pkg.version,
+      family: 'nodejs',
+      tags: [
+        ...tags,
+        'is_crash:true',
+        'language:javascript',
+        `library_version:${pkg.version}`,
+        'runtime:nodejs',
+        `runtime_version:${process.versions.node}`,
+        '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,11 @@
+'use strict'
+
+class NoopCrashtracker {
+  configure () {}
+  start () {}
+  withProfilerSerializing (f) {
+    return f()
+  }
+}
+
+module.exports = new NoopCrashtracker()

package/packages/dd-trace/src/datastreams/checkpointer.js

@@ -0,0 +1,80 @@
+'use strict'
+
+const DataStreamsContext = require('./context')
+
+class DataStreamsCheckpointer {
+  constructor (tracer) {
+    this.tracer = tracer
+    this.config = tracer._config
+    this.dsmProcessor = tracer._dataStreamsProcessor
+  }
+
+  /**
+   * @param {string} type - The type of the checkpoint, usually the streaming technology being used.
+   *                       Examples include kafka, kinesis, sns etc.
+   * @param {string} target - The target of data. This can be a topic, exchange or stream name.
+   * @param {object} carrier - The carrier object to inject context into.
+   */
+  setProduceCheckpoint (type, target, carrier) {
+    if (!this.config.dsmEnabled) return
+
+    const ctx = this.dsmProcessor.setCheckpoint(
+      ['type:' + type, 'topic:' + target, 'direction:out', 'manual_checkpoint:true'],
+      null,
+      DataStreamsContext.getDataStreamsContext(),
+      null
+    )
+    DataStreamsContext.setDataStreamsContext(ctx)
+
+    this.tracer.inject(ctx, 'text_map_dsm', carrier)
+  }
+
+  /**
+   * @param {string} type - The type of the checkpoint, usually the streaming technology being used.
+   *                       Examples include kafka, kinesis, sns etc.
+   * @param {string} source - The source of data. This can be a topic, exchange or stream name.
+   * @param {object} carrier - The carrier object to extract context from.
+   * @param {boolean} [manualCheckpoint=true] - Whether this checkpoint was manually set. Keep true if manually
+   *                                           instrumenting. Manual instrumentation always overrides automatic
+   *                                           instrumentation in the case a call is both manually and automatically
+   *                                           instrumented.
+   */
+  setConsumeCheckpoint (type, source, carrier, manualCheckpoint = true) {
+    if (!this.config.dsmEnabled) return
+
+    const parentCtx = this.tracer.extract('text_map_dsm', carrier)
+    DataStreamsContext.setDataStreamsContext(parentCtx)
+
+    const tags = ['type:' + type, 'topic:' + source, 'direction:in']
+    if (manualCheckpoint) {
+      tags.push('manual_checkpoint:true')
+    }
+
+    const ctx = this.dsmProcessor.setCheckpoint(
+      tags,
+      null,
+      parentCtx,
+      null
+    )
+    DataStreamsContext.setDataStreamsContext(ctx)
+
+    return ctx
+  }
+
+  /**
+   * Records a transaction ID at a named checkpoint without pathway propagation.
+   * Tags the active span (or the provided span) with the transaction ID and checkpoint name.
+   * @param {string} transactionId - The transaction identifier to track.
+   * @param {string} checkpointName - The logical checkpoint name.
+   * @param {object|null} [span=null] - Span to tag. Defaults to the currently active span.
+   */
+  trackTransaction (transactionId, checkpointName, span = null) {
+    if (!this.config.dsmEnabled) return
+    const activeSpan = span ?? this.tracer.scope().active()
+    this.dsmProcessor.trackTransaction(transactionId, checkpointName, activeSpan)
+  }
+}
+
+module.exports = {
+  DataStreamsCheckpointer,
+}

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

@@ -0,0 +1,20 @@
+'use strict'
+
+const { storage } = require('../../../datadog-core')
+const log = require('../log')
+
+function getDataStreamsContext () {
+  const store = storage('legacy').getStore()
+  return (store && store.dataStreamsContext) || null
+}
+
+function setDataStreamsContext (dataStreamsContext) {
+  log.debug('Setting new DSM Context: %j.', dataStreamsContext)
+
+  if (dataStreamsContext) storage('legacy').enterWith({ ...(storage('legacy').getStore()), dataStreamsContext })
+}
+
+module.exports = {
+  getDataStreamsContext,
+  setDataStreamsContext,
+}

package/packages/dd-trace/src/datastreams/encoding.js

@@ -0,0 +1,99 @@
+'use strict'
+
+/**
+ * Encodes positive and negative numbers, using zig zag encoding to reduce the size of the variable length encoding.
+ * Uses high and low part to ensure those parts are under the limit for byte operations in javascript (32 bits)
+ * Maximum number possible to encode is MAX_SAFE_INTEGER/2 (using zig zag shifts the bits by 1 to the left)
+ * @param {number} v
+ * @returns {Uint8Array|undefined}
+ */
+function encodeVarint (v) {
+  const sign = v >= 0 ? 0 : 1
+  // We leave the least significant bit for the sign.
+  const double = Math.abs(v) * 2
+  if (double > Number.MAX_SAFE_INTEGER) {
+    return
+  }
+  const high = Math.floor(double / 0x1_00_00_00_00)
+  const low = (double & 0xFF_FF_FF_FF) | sign
+  return encodeUvarint64(low, high)
+}
+
+/**
+ * Decodes positive and negative numbers, using zig zag encoding to reduce the size of the variable length encoding.
+ * Uses high and low part to ensure those parts are under the limit for byte operations in javascript (32 bits)
+ * @param {Uint8Array} b
+ * @returns {[number|undefined, Uint8Array]}
+ */
+function decodeVarint (b) {
+  const [low, high, bytes] = decodeUvarint64(b)
+  if (low === undefined || high === undefined) {
+    return [undefined, bytes]
+  }
+  const positive = (low & 1) === 0
+  const abs = (low >>> 1) + high * 0x80_00_00_00
+  return [positive ? abs : -abs, bytes]
+}
+
+const maxVarLen64 = 9
+
+/**
+ * @param {number} low
+ * @param {number} high
+ * @returns {Uint8Array}
+ */
+function encodeUvarint64 (low, high) {
+  const result = new Uint8Array(maxVarLen64)
+  let i = 0
+  // if first byte is 1, the number is negative in javascript, but we want to interpret it as positive
+  while ((high !== 0 || low < 0 || low > 0x80) && i < maxVarLen64 - 1) {
+    result[i] = (low & 0x7F) | 0x80
+    low >>>= 7
+    low |= (high & 0x7F) << 25
+    high >>>= 7
+    i++
+  }
+  result[i] = low & 0x7F
+  return result.slice(0, i + 1)
+}
+
+/**
+ * @param {Uint8Array} bytes
+ * @returns {[number|undefined, number|undefined, Uint8Array]}
+ */
+function decodeUvarint64 (
+  bytes
+) {
+  let low = 0
+  let high = 0
+  let s = 0
+  for (let i = 0; ; i++) {
+    if (bytes.length <= i) {
+      return [undefined, undefined, bytes.slice(bytes.length)]
+    }
+    const n = bytes[i]
+    if (n < 0x80 || i === maxVarLen64 - 1) {
+      bytes = bytes.slice(i + 1)
+      if (s < 32) {
+        low |= n << s
+      }
+      if (s > 0) {
+        high |= s - 32 > 0 ? n << (s - 32) : n >> (32 - s)
+      }
+      return [low, high, bytes]
+    }
+    if (s < 32) {
+      low |= (n & 0x7F) << s
+    }
+    if (s > 0) {
+      high |=
+        s - 32 > 0 ? (n & 0x7F) << (s - 32) : (n & 0x7F) >> (32 - s)
+    }
+    s += 7
+  }
+}
+
+module.exports = {
+  encodeVarint,
+  decodeVarint,
+}

package/packages/dd-trace/src/datastreams/fnv.js

@@ -0,0 +1,25 @@
+'use strict'
+
+const FNV_64_PRIME = 0x1_00_00_00_01_B3n
+const FNV1_64_INIT = 0xCB_F2_9C_E4_84_22_23_25n
+
+function fnv (data, hvalInit, fnvPrime, fnvSize) {
+  let hval = hvalInit
+  for (const byte of data) {
+    hval = (hval * fnvPrime) % fnvSize
+    hval ^= BigInt(byte)
+  }
+  return hval
+}
+
+function fnv64 (data) {
+  if (!Buffer.isBuffer(data)) {
+    data = Buffer.from(data, 'utf8')
+  }
+  const byteArray = new Uint8Array(data)
+  return fnv(byteArray, FNV1_64_INIT, FNV_64_PRIME, 2n ** 64n)
+}
+
+module.exports = {
+  fnv64,
+}

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

@@ -0,0 +1,129 @@
+'use strict'
+
+const {
+  getAmqpMessageSize,
+  getHeadersSize,
+  getMessageSize,
+  getSizeOrZero,
+} = require('./size')
+
+// This is only needed because DSM code is spread across existing tracing
+// plugins instead of having dedicated DSM plugins that are themselves
+// lazy loaded.
+//
+// TODO: Remove this when DSM has been moved to dedicated plugins.
+/**
+ * @template T extends new (...args: unknown[]) => unknown
+ * @param {() => T} classGetter
+ * @param {string[]} methods
+ * @param {string[]} staticMethods
+ * @returns {T}
+ */
+function lazyClass (classGetter, methods = [], staticMethods = []) {
+  let constructorArgs
+  let ActiveClass
+
+  const LazyClass = function (...args) {
+    constructorArgs = args
+  }
+
+  const activate = () => {
+    return (ActiveClass = ActiveClass || classGetter())
+  }
+
+  for (const method of methods) {
+    LazyClass.prototype[method] = function (...args) {
+      const instance = activate() && new ActiveClass(...constructorArgs)
+
+      // Replace the whole prototype instead of only the method itself whenever
+      // any individual method is called to avoid running through this code
+      // again every time another method is called. This is not only more
+      // efficient but it also means that the class instance does not need to be
+      // stored for future calls to other methods.
+      Object.setPrototypeOf(this, instance)
+
+      return this[method](...args)
+    }
+  }
+
+  for (const method of staticMethods) {
+    LazyClass[method] = function (...args) {
+      LazyClass[method] = activate() && ActiveClass[method]
+
+      return LazyClass[method](...args)
+    }
+  }
+
+  return LazyClass
+}
+
+/**
+ * @type {typeof import('./pathway').DsmPathwayCodec}
+ */
+const DsmPathwayCodec = lazyClass(() => require('./pathway').DsmPathwayCodec, [], [
+  'encode',
+  'decode',
+])
+
+/**
+ * @type {typeof import('./checkpointer').DataStreamsCheckpointer}
+ */
+const DataStreamsCheckpointer = lazyClass(() => require('./checkpointer').DataStreamsCheckpointer, [
+  'setProduceCheckpoint',
+  'setConsumeCheckpoint',
+  'trackTransaction',
+])
+
+/**
+ * @type {typeof import('./manager').DataStreamsManager}
+ */
+const DataStreamsManager = lazyClass(() => require('./manager').DataStreamsManager, [
+  'setCheckpoint',
+  'decodeDataStreamsContext',
+  'trackTransaction',
+])
+
+// TODO: Are all those methods actually public?
+/**
+ * @type {typeof import('./processor').DataStreamsProcessor}
+ */
+const DataStreamsProcessor = lazyClass(() => require('./processor').DataStreamsProcessor, [
+  'onInterval',
+  'bucketFromTimestamp',
+  'recordCheckpoint',
+  'setCheckpoint',
+  'recordOffset',
+  'setOffset',
+  'trackTransaction',
+  'setUrl',
+  'trySampleSchema',
+  'canSampleSchema',
+  'getSchema',
+])
+
+/**
+ * @type {typeof import('./schemas/schema_builder').SchemaBuilder}
+ */
+const SchemaBuilder = lazyClass(() => require('./schemas/schema_builder').SchemaBuilder, [
+  'build',
+  'addProperty',
+  'shouldExtractSchema',
+], [
+  'getCache',
+  'getSchemaDefinition',
+  'getSchema',
+])
+
+module.exports = {
+  DsmPathwayCodec,
+  DataStreamsCheckpointer,
+  DataStreamsManager,
+  DataStreamsProcessor,
+  SchemaBuilder,
+
+  // These are small functions so they are exposed directly and not lazy loaded.
+  getAmqpMessageSize,
+  getHeadersSize,
+  getMessageSize,
+  getSizeOrZero,
+}

package/packages/dd-trace/src/datastreams/manager.js

@@ -0,0 +1,36 @@
+'use strict'
+
+const { DsmPathwayCodec } = require('./pathway')
+const DataStreamsContext = require('./context')
+
+class DataStreamsManager {
+  constructor (processor) {
+    this._dataStreamsProcessor = processor
+  }
+
+  setCheckpoint (edgeTags, span, payloadSize = 0) {
+    const ctx = this._dataStreamsProcessor.setCheckpoint(
+      edgeTags, span, DataStreamsContext.getDataStreamsContext(), payloadSize
+    )
+    DataStreamsContext.setDataStreamsContext(ctx)
+    return ctx
+  }
+
+  decodeDataStreamsContext (carrier) {
+    const ctx = DsmPathwayCodec.decode(carrier)
+    // we erase the previous context everytime we decode a new one
+    DataStreamsContext.setDataStreamsContext(ctx)
+    return ctx
+  }
+
+  /**
+   * @param {string} transactionId
+   * @param {string} checkpointName
+   * @param {object|null} [span=null]
+   */
+  trackTransaction (transactionId, checkpointName, span = null) {
+    this._dataStreamsProcessor.trackTransaction(transactionId, checkpointName, span)
+  }
+}
+
+module.exports = { DataStreamsManager }