@depup/dd-trace 5.90.0-depup.0

package/packages/dd-trace/src/msgpack/encoder.js

@@ -0,0 +1,308 @@
+'use strict'
+
+const MsgpackChunk = require('./chunk')
+
+class MsgpackEncoder {
+  encode (value) {
+    const bytes = new MsgpackChunk()
+    this.encodeValue(bytes, value)
+
+    return bytes.buffer.subarray(0, bytes.length)
+  }
+
+  encodeValue (bytes, value) {
+    switch (typeof value) {
+      case 'bigint':
+        this.encodeBigInt(bytes, value)
+        break
+      case 'boolean':
+        this.encodeBoolean(bytes, value)
+        break
+      case 'number':
+        this.encodeNumber(bytes, value)
+        break
+      case 'object':
+        if (value === null) {
+          this.encodeNull(bytes, value)
+        } else if (Array.isArray(value)) {
+          this.encodeArray(bytes, value)
+        } else if (Buffer.isBuffer(value) || ArrayBuffer.isView(value)) {
+          this.encodeBin(bytes, value)
+        } else {
+          this.encodeMap(bytes, value)
+        }
+        break
+      case 'string':
+        this.encodeString(bytes, value)
+        break
+      case 'symbol':
+        this.encodeString(bytes, value.toString())
+        break
+      default: // function, symbol, undefined
+        this.encodeNull(bytes, value)
+        break
+    }
+  }
+
+  encodeNull (bytes) {
+    const offset = bytes.length
+
+    bytes.reserve(1)
+    bytes.buffer[offset] = 0xC0
+  }
+
+  encodeBoolean (bytes, value) {
+    const offset = bytes.length
+
+    bytes.reserve(1)
+    bytes.buffer[offset] = value ? 0xC3 : 0xC2
+  }
+
+  encodeString (bytes, value) {
+    bytes.write(value)
+  }
+
+  encodeFixArray (bytes, size = 0) {
+    const offset = bytes.length
+
+    bytes.reserve(1)
+    bytes.buffer[offset] = 0x90 + size
+  }
+
+  encodeArrayPrefix (bytes, value) {
+    const length = value.length
+    const offset = bytes.length
+
+    bytes.reserve(5)
+    bytes.buffer[offset] = 0xDD
+    bytes.buffer[offset + 1] = length >> 24
+    bytes.buffer[offset + 2] = length >> 16
+    bytes.buffer[offset + 3] = length >> 8
+    bytes.buffer[offset + 4] = length
+  }
+
+  encodeArray (bytes, value) {
+    if (value.length < 16) {
+      this.encodeFixArray(bytes, value.length)
+    } else {
+      this.encodeArrayPrefix(bytes, value)
+    }
+
+    for (const item of value) {
+      this.encodeValue(bytes, item)
+    }
+  }
+
+  encodeFixMap (bytes, size = 0) {
+    const offset = bytes.length
+
+    bytes.reserve(1)
+    bytes.buffer[offset] = 0x80 + size
+  }
+
+  encodeMapPrefix (bytes, keysLength) {
+    const offset = bytes.length
+
+    bytes.reserve(5)
+    bytes.buffer[offset] = 0xDF
+    bytes.buffer[offset + 1] = keysLength >> 24
+    bytes.buffer[offset + 2] = keysLength >> 16
+    bytes.buffer[offset + 3] = keysLength >> 8
+    bytes.buffer[offset + 4] = keysLength
+  }
+
+  encodeByte (bytes, value) {
+    bytes.reserve(1)
+    bytes.buffer[bytes.length - 1] = value
+  }
+
+  encodeBin (bytes, value) {
+    const offset = bytes.length
+
+    if (value.byteLength < 256) {
+      bytes.reserve(2)
+      bytes.buffer[offset] = 0xC4
+      bytes.buffer[offset + 1] = value.byteLength
+    } else if (value.byteLength < 65_536) {
+      bytes.reserve(3)
+      bytes.buffer[offset] = 0xC5
+      bytes.buffer[offset + 1] = value.byteLength >> 8
+      bytes.buffer[offset + 2] = value.byteLength
+    } else {
+      bytes.reserve(5)
+      bytes.buffer[offset] = 0xC6
+      bytes.buffer[offset + 1] = value.byteLength >> 24
+      bytes.buffer[offset + 2] = value.byteLength >> 16
+      bytes.buffer[offset + 3] = value.byteLength >> 8
+      bytes.buffer[offset + 4] = value.byteLength
+    }
+
+    bytes.set(value)
+  }
+
+  encodeInteger (bytes, value) {
+    const offset = bytes.length
+
+    bytes.reserve(5)
+    bytes.buffer[offset] = 0xCE
+    bytes.buffer[offset + 1] = value >> 24
+    bytes.buffer[offset + 2] = value >> 16
+    bytes.buffer[offset + 3] = value >> 8
+    bytes.buffer[offset + 4] = value
+  }
+
+  encodeShort (bytes, value) {
+    const offset = bytes.length
+
+    bytes.reserve(3)
+    bytes.buffer[offset] = 0xCD
+    bytes.buffer[offset + 1] = value >> 8
+    bytes.buffer[offset + 2] = value
+  }
+
+  encodeLong (bytes, value) {
+    const offset = bytes.length
+    const hi = (value / 2 ** 32) >> 0
+    const lo = value >>> 0
+
+    bytes.reserve(9)
+    bytes.buffer[offset] = 0xCF
+    bytes.buffer[offset + 1] = hi >> 24
+    bytes.buffer[offset + 2] = hi >> 16
+    bytes.buffer[offset + 3] = hi >> 8
+    bytes.buffer[offset + 4] = hi
+    bytes.buffer[offset + 5] = lo >> 24
+    bytes.buffer[offset + 6] = lo >> 16
+    bytes.buffer[offset + 7] = lo >> 8
+    bytes.buffer[offset + 8] = lo
+  }
+
+  encodeNumber (bytes, value) {
+    if (Number.isNaN(value)) {
+      value = 0
+    }
+    if (Number.isInteger(value)) {
+      if (value >= 0) {
+        this.encodeUnsigned(bytes, value)
+      } else {
+        this.encodeSigned(bytes, value)
+      }
+    } else {
+      this.encodeFloat(bytes, value)
+    }
+  }
+
+  encodeSigned (bytes, value) {
+    const offset = bytes.length
+
+    if (value >= -0x20) {
+      bytes.reserve(1)
+      bytes.buffer[offset] = value
+    } else if (value >= -0x80) {
+      bytes.reserve(2)
+      bytes.buffer[offset] = 0xD0
+      bytes.buffer[offset + 1] = value
+    } else if (value >= -0x80_00) {
+      bytes.reserve(3)
+      bytes.buffer[offset] = 0xD1
+      bytes.buffer[offset + 1] = value >> 8
+      bytes.buffer[offset + 2] = value
+    } else if (value >= -0x80_00_00_00) {
+      bytes.reserve(5)
+      bytes.buffer[offset] = 0xD2
+      bytes.buffer[offset + 1] = value >> 24
+      bytes.buffer[offset + 2] = value >> 16
+      bytes.buffer[offset + 3] = value >> 8
+      bytes.buffer[offset + 4] = value
+    } else {
+      const hi = Math.floor(value / 2 ** 32)
+      const lo = value >>> 0
+
+      bytes.reserve(9)
+      bytes.buffer[offset] = 0xD3
+      bytes.buffer[offset + 1] = hi >> 24
+      bytes.buffer[offset + 2] = hi >> 16
+      bytes.buffer[offset + 3] = hi >> 8
+      bytes.buffer[offset + 4] = hi
+      bytes.buffer[offset + 5] = lo >> 24
+      bytes.buffer[offset + 6] = lo >> 16
+      bytes.buffer[offset + 7] = lo >> 8
+      bytes.buffer[offset + 8] = lo
+    }
+  }
+
+  encodeUnsigned (bytes, value) {
+    const offset = bytes.length
+
+    if (value <= 0x7F) {
+      bytes.reserve(1)
+      bytes.buffer[offset] = value
+    } else if (value <= 0xFF) {
+      bytes.reserve(2)
+      bytes.buffer[offset] = 0xCC
+      bytes.buffer[offset + 1] = value
+    } else if (value <= 0xFF_FF) {
+      bytes.reserve(3)
+      bytes.buffer[offset] = 0xCD
+      bytes.buffer[offset + 1] = value >> 8
+      bytes.buffer[offset + 2] = value
+    } else if (value <= 0xFF_FF_FF_FF) {
+      bytes.reserve(5)
+      bytes.buffer[offset] = 0xCE
+      bytes.buffer[offset + 1] = value >> 24
+      bytes.buffer[offset + 2] = value >> 16
+      bytes.buffer[offset + 3] = value >> 8
+      bytes.buffer[offset + 4] = value
+    } else {
+      const hi = (value / 2 ** 32) >> 0
+      const lo = value >>> 0
+
+      bytes.reserve(9)
+      bytes.buffer[offset] = 0xCF
+      bytes.buffer[offset + 1] = hi >> 24
+      bytes.buffer[offset + 2] = hi >> 16
+      bytes.buffer[offset + 3] = hi >> 8
+      bytes.buffer[offset + 4] = hi
+      bytes.buffer[offset + 5] = lo >> 24
+      bytes.buffer[offset + 6] = lo >> 16
+      bytes.buffer[offset + 7] = lo >> 8
+      bytes.buffer[offset + 8] = lo
+    }
+  }
+
+  // TODO: Support BigInt larger than 64bit.
+  encodeBigInt (bytes, value) {
+    const offset = bytes.length
+
+    bytes.reserve(9)
+
+    if (value >= 0n) {
+      bytes.buffer[offset] = 0xCF
+      bytes.view.setBigUint64(offset + 1, value)
+    } else {
+      bytes.buffer[offset] = 0xD3
+      bytes.view.setBigInt64(offset + 1, value)
+    }
+  }
+
+  encodeMap (bytes, value) {
+    const keys = Object.keys(value)
+
+    this.encodeMapPrefix(bytes, keys.length)
+
+    for (const key of keys) {
+      this.encodeValue(bytes, key)
+      this.encodeValue(bytes, value[key])
+    }
+  }
+
+  encodeFloat (bytes, value) {
+    const offset = bytes.length
+
+    bytes.reserve(9)
+    bytes.buffer[offset] = 0xCB
+    bytes.view.setFloat64(offset + 1, value)
+  }
+}
+
+module.exports = { MsgpackEncoder }

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

@@ -0,0 +1,6 @@
+'use strict'
+
+const MsgpackChunk = require('./chunk')
+const { MsgpackEncoder } = require('./encoder')
+
+module.exports = { MsgpackChunk, MsgpackEncoder }

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

@@ -0,0 +1,19 @@
+'use strict'
+
+/**
+ * @import { DogStatsD } from "../../../../index.d.ts"
+ * @implements {DogStatsD}
+ */
+module.exports = class NoopDogStatsDClient {
+  increment () {}
+
+  decrement () {}
+
+  gauge () {}
+
+  distribution () {}
+
+  histogram () {}
+
+  flush () {}
+}

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

@@ -0,0 +1,106 @@
+'use strict'
+
+const NoopAppsecSdk = require('../appsec/sdk/noop')
+const NoopLLMObsSDK = require('../llmobs/noop')
+const NoopFlaggingProvider = require('../openfeature/noop')
+const NoopAIGuardSDK = require('../aiguard/noop')
+const NoopDogStatsDClient = require('./dogstatsd')
+const NoopTracer = require('./tracer')
+
+const noop = new NoopTracer()
+const noopAppsec = new NoopAppsecSdk()
+const noopDogStatsDClient = new NoopDogStatsDClient()
+const noopLLMObs = new NoopLLMObsSDK(noop)
+const noopOpenFeatureProvider = new NoopFlaggingProvider()
+const noopAIGuard = new NoopAIGuardSDK()
+
+/** @type {import('../../src/index')} Proxy */
+class NoopProxy {
+  constructor () {
+    this._tracer = noop
+    this.appsec = noopAppsec
+    this.dogstatsd = noopDogStatsDClient
+    this.llmobs = noopLLMObs
+    this.openfeature = noopOpenFeatureProvider
+    this.aiguard = noopAIGuard
+    this.setBaggageItem = (key, value) => {}
+    this.getBaggageItem = (key) => {}
+    this.getAllBaggageItems = () => {}
+    this.removeBaggageItem = (keyToRemove) => {}
+    this.removeAllBaggageItems = () => {}
+  }
+
+  init () {
+    return this
+  }
+
+  use () {
+    return this
+  }
+
+  profilerStarted () {
+    return Promise.resolve(false)
+  }
+
+  trace (name, options, fn) {
+    if (!fn) {
+      fn = options
+      options = {}
+    }
+
+    if (typeof fn !== 'function') return
+
+    options = options || {}
+
+    return this._tracer.trace(name, options, fn)
+  }
+
+  wrap (name, options, fn) {
+    if (!fn) {
+      fn = options
+      options = {}
+    }
+
+    if (typeof fn !== 'function') return fn
+
+    options = options || {}
+
+    return this._tracer.wrap(name, options, fn)
+  }
+
+  setUrl () {
+    this._tracer.setUrl.apply(this._tracer, arguments)
+    return this
+  }
+
+  startSpan () {
+    return this._tracer.startSpan.apply(this._tracer, arguments)
+  }
+
+  inject () {
+    return this._tracer.inject.apply(this._tracer, arguments)
+  }
+
+  extract () {
+    return this._tracer.extract.apply(this._tracer, arguments)
+  }
+
+  scope () {
+    return this._tracer.scope.apply(this._tracer, arguments)
+  }
+
+  getRumData () {
+    return this._tracer.getRumData.apply(this._tracer, arguments)
+  }
+
+  setUser (user) {
+    this.appsec.setUser(user)
+    return this
+  }
+
+  get TracerProvider () {
+    return require('../opentelemetry/tracer_provider')
+  }
+}
+
+module.exports = NoopProxy

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

@@ -0,0 +1,19 @@
+'use strict'
+
+class Scope {
+  active () {
+    return null
+  }
+
+  activate (span, callback) {
+    if (typeof callback !== 'function') return callback
+
+    return callback()
+  }
+
+  bind (fn, span) {
+    return fn
+  }
+}
+
+module.exports = Scope

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

@@ -0,0 +1,50 @@
+'use strict'
+
+const id = require('../id')
+const { storage } = require('../../../datadog-core') // TODO: noop storage?
+const NoopSpanContext = require('./span_context')
+
+class NoopSpan {
+  constructor (tracer, parent) {
+    this._store = storage('legacy').getHandle()
+    this._noopTracer = tracer
+    this._noopContext = this._createContext(parent)
+  }
+
+  context () { return this._noopContext }
+  tracer () { return this._noopTracer }
+  setOperationName (name) { return this }
+  setBaggageItem (key, value) { return this }
+  getBaggageItem (key) {}
+  getAllBaggageItems () {}
+  removeBaggageItem (key) { return this }
+  removeAllBaggageItems () { return this }
+  setTag (key, value) { return this }
+  addTags (keyValueMap) { return this }
+  addLink (link) { return this }
+  addLinks (links) { return this }
+  addSpanPointer (ptrKind, ptrDir, ptrHash) { return this }
+  log () { return this }
+  logEvent () {}
+  finish (finishTime) {}
+
+  _createContext (parent) {
+    const spanId = id()
+
+    return parent
+      ? new NoopSpanContext({
+        noop: this,
+        traceId: parent._traceId,
+        spanId,
+        parentId: parent._spanId,
+        baggageItems: { ...parent._baggageItems },
+      })
+      : new NoopSpanContext({
+        noop: this,
+        traceId: spanId,
+        spanId,
+      })
+  }
+}
+
+module.exports = NoopSpan

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

@@ -0,0 +1,16 @@
+'use strict'
+
+const DatadogSpanContext = require('../opentracing/span_context')
+const priority = require('../../../../ext/priority')
+
+const USER_REJECT = priority.USER_REJECT
+
+class NoopSpanContext extends DatadogSpanContext {
+  constructor (props) {
+    super(props)
+
+    this._sampling.priority = USER_REJECT
+  }
+}
+
+module.exports = NoopSpanContext

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

@@ -0,0 +1,47 @@
+'use strict'
+
+const Scope = require('../noop/scope')
+const Span = require('./span')
+
+class NoopTracer {
+  constructor (config) {
+    this._scope = new Scope()
+    this._span = new Span(this)
+  }
+
+  configure (options) {}
+
+  trace (name, options, fn) {
+    return fn(this._span, () => {})
+  }
+
+  wrap (name, options, fn) {
+    return fn
+  }
+
+  scope () {
+    return this._scope
+  }
+
+  getRumData () {
+    return ''
+  }
+
+  setUrl () {}
+
+  startSpan (name, options) {
+    return this._span
+  }
+
+  inject (spanContext, format, carrier) {}
+
+  extract (format, carrier) {
+    return this._span.context()
+  }
+
+  setUser () {
+    return this
+  }
+}
+
+module.exports = NoopTracer

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

@@ -0,0 +1,51 @@
+'use strict'
+
+module.exports = {
+  /**
+   * @constant
+   * @type {string} Base path for EVP proxy agent endpoint
+   */
+  EVP_PROXY_AGENT_BASE_PATH: '/evp_proxy/v2/',
+
+  /**
+   * @constant
+   * @type {string} HTTP header name for EVP subdomain routing
+   */
+  EVP_SUBDOMAIN_HEADER_NAME: 'X-Datadog-EVP-Subdomain',
+
+  /**
+   * @constant
+   * @type {string} EVP subdomain value for event platform intake
+   */
+  EVP_SUBDOMAIN_VALUE: 'event-platform-intake',
+
+  /**
+   * @constant
+   * @type {string} API endpoint for exposure events EVP track
+   */
+  EXPOSURES_ENDPOINT: '/api/v2/exposures',
+
+  /**
+   * @constant
+   * @type {number} Maximum payload size for EVP intake (5MB, actual limit is 5.1MB)
+   */
+  EVP_PAYLOAD_SIZE_LIMIT: 5 << 20,
+
+  /**
+   * @constant
+   * @type {number} Maximum individual event size (999KB, actual limit is 1MB)
+   */
+  EVP_EVENT_SIZE_LIMIT: (1 << 20) - 1024,
+
+  /**
+   * @constant
+   * @type {string} Channel name for exposure event submission
+   */
+  EXPOSURE_CHANNEL: 'ffe:exposure:submit',
+
+  /**
+   * @constant
+   * @type {string} Reason code for noop provider evaluations
+   */
+  NOOP_REASON: 'STATIC',
+}

package/packages/dd-trace/src/openfeature/flagging_provider.js

@@ -0,0 +1,47 @@
+'use strict'
+
+const { DatadogNodeServerProvider } = require('@datadog/openfeature-node-server')
+const { channel } = require('dc-polyfill')
+const log = require('../log')
+const { EXPOSURE_CHANNEL } = require('./constants/constants')
+
+/**
+ * OpenFeature provider that integrates with Datadog's feature flagging system.
+ * Extends DatadogNodeServerProvider to add tracer integration and configuration management.
+ */
+class FlaggingProvider extends DatadogNodeServerProvider {
+  /**
+   * @param {import('../tracer')} tracer - Datadog tracer instance
+   * @param {import('../config')} config - Tracer configuration object
+   */
+  constructor (tracer, config) {
+    // Call parent constructor with required options and timeout
+    super({
+      exposureChannel: channel(EXPOSURE_CHANNEL),
+      initializationTimeoutMs: config.experimental.flaggingProvider.initializationTimeoutMs,
+    })
+
+    this._tracer = tracer
+    this._config = config
+
+    log.debug('%s created with timeout: %dms', this.constructor.name,
+      config.experimental.flaggingProvider.initializationTimeoutMs)
+  }
+
+  /**
+   * Internal method to update flag configuration from Remote Config.
+   * This method is called automatically when Remote Config delivers UFC updates.
+   *
+   * @internal
+   * @param {import('@datadog/openfeature-node-server').UniversalFlagConfigurationV1} ufc
+   * - Universal Flag Configuration object
+   */
+  _setConfiguration (ufc) {
+    if (typeof this.setConfiguration === 'function') {
+      this.setConfiguration(ufc)
+    }
+    log.debug('%s provider configuration updated', this.constructor.name)
+  }
+}
+
+module.exports = FlaggingProvider