dd-trace 5.61.1 → 5.63.0

package/packages/dd-trace/src/profiling/exporters/event_serializer.js

@@ -5,23 +5,7 @@
 const os = require('os')
 const perf = require('perf_hooks').performance
 const version = require('../../../../../package.json').version
-const { getEnvironmentVariable } = require('../../config-helper')
-
-const libuvThreadPoolSize = (() => {
-  const ss = getEnvironmentVariable('UV_THREADPOOL_SIZE')
-  if (ss === undefined) {
-    // Backend will apply the default size based on Node version.
-    return
-  }
-  // libuv uses atoi to parse the value, which is almost the same as parseInt, except that parseInt
-  // will return NaN on invalid input, while atoi will return 0. This is handled at return.
-  const s = Number.parseInt(ss)
-  // We don't interpret the value further here in the library. Backend will interpret the number
-  // based on Node version. In all currently known Node versions, 0 results in 1 worker thread,
-  // negative values (because they're assigned to an unsigned int) become very high positive values,
-  // and the value is finally capped at 1024.
-  return Number.isNaN(s) ? 0 : s
-})()
+const { availableParallelism, libuvThreadPoolSize } = require('../libuv-size')
 
 class EventSerializer {
   constructor ({ env, host, service, version, libraryInjected, activation } = {}) {
@@ -77,10 +61,7 @@ class EventSerializer {
           version
         },
         runtime: {
-          // os.availableParallelism only available in node 18.14.0/19.4.0 and above
-          available_processors: typeof os.availableParallelism === 'function'
-            ? os.availableParallelism()
-            : os.cpus().length,
+          available_processors: availableParallelism(),
           // Using `nodejs` for consistency with the existing `runtime` tag.
           // Note that the event `family` property uses `node`, as that's what's
           // proscribed by the Intake API, but that's an internal enum and is

package/packages/dd-trace/src/profiling/libuv-size.js

@@ -0,0 +1,49 @@
+'use strict'
+
+const { getEnvironmentVariable } = require('../config-helper')
+const os = require('node:os')
+
+function getLibuvThreadPoolSize (envVar) {
+  if (envVar === undefined) {
+    return
+  }
+  // libuv uses atoi to parse the value, which is almost the same as parseInt, except that parseInt
+  // will return NaN on invalid input, while atoi will return 0. This is handled at return.
+  const s = Number.parseInt(envVar, 10)
+  // We don't interpret the value further here in the library. Backend will interpret the number
+  // based on Node version.
+  return Number.isNaN(s) ? 0 : s
+}
+
+const libuvThreadPoolSize = getLibuvThreadPoolSize(getEnvironmentVariable('UV_THREADPOOL_SIZE'))
+
+function getEffectiveLibuvThreadCount (size) {
+  // In all currently known Node versions, 0 results in 1 worker thread, negative values (because
+  // they're assigned to an unsigned int) become very high positive values, and the value is finally
+  // capped at 1024.
+  if (size === undefined) {
+    return 4
+  } else if (size < 0 || size > 1024) {
+    return 1024
+  } else if (size === 0) {
+    return 1
+  }
+  return size
+}
+
+const effectiveLibuvThreadCount = getEffectiveLibuvThreadCount(libuvThreadPoolSize)
+
+function availableParallelism () {
+  // os.availableParallelism only available in node 18.14.0/19.4.0 and above
+  // eslint-disable-next-line n/no-unsupported-features/node-builtins
+  return typeof os.availableParallelism === 'function' ? os.availableParallelism() : os.cpus().length
+}
+
+module.exports = {
+  availableParallelism,
+  effectiveLibuvThreadCount,
+  libuvThreadPoolSize,
+  // Only used for testing
+  getLibuvThreadPoolSize,
+  getEffectiveLibuvThreadCount
+}

package/packages/dd-trace/src/profiling/profilers/event_plugins/dns.js

@@ -3,13 +3,9 @@
 const EventPlugin = require('./event')
 
 class DNSPlugin extends EventPlugin {
-  static get id () {
-    return 'dns'
-  }
+  static id = 'dns'
 
-  static get entryType () {
-    return 'dns'
-  }
+  static entryType = 'dns'
 }
 
 module.exports = DNSPlugin

package/packages/dd-trace/src/profiling/profilers/event_plugins/dns_lookup.js

@@ -3,9 +3,7 @@
 const DNSPlugin = require('./dns')
 
 class DNSLookupPlugin extends DNSPlugin {
-  static get operation () {
-    return 'lookup'
-  }
+  static operation = 'lookup'
 
   extendEvent (event, startEvent) {
     event.name = 'lookup'

package/packages/dd-trace/src/profiling/profilers/event_plugins/dns_lookupservice.js

@@ -3,9 +3,7 @@
 const DNSPlugin = require('./dns')
 
 class DNSLookupServicePlugin extends DNSPlugin {
-  static get operation () {
-    return 'lookup_service'
-  }
+  static operation = 'lookup_service'
 
   extendEvent (event, startEvent) {
     event.name = 'lookupService'

package/packages/dd-trace/src/profiling/profilers/event_plugins/dns_resolve.js

@@ -5,9 +5,7 @@ const DNSPlugin = require('./dns')
 const queryNames = new Map()
 
 class DNSResolvePlugin extends DNSPlugin {
-  static get operation () {
-    return 'resolve'
-  }
+  static operation = 'resolve'
 
   extendEvent (event, startEvent) {
     const rrtype = startEvent.args[1]

package/packages/dd-trace/src/profiling/profilers/event_plugins/dns_reverse.js

@@ -3,9 +3,7 @@
 const DNSPlugin = require('./dns')
 
 class DNSReversePlugin extends DNSPlugin {
-  static get operation () {
-    return 'reverse'
-  }
+  static operation = 'reverse'
 
   extendEvent (event, startEvent) {
     event.name = 'getHostByAddr'

package/packages/dd-trace/src/profiling/profilers/event_plugins/event.js

@@ -7,54 +7,55 @@ const { performance } = require('perf_hooks')
 // start/error/finish methods to the appropriate diagnostic channels.
 // TODO: Decouple this from TracingPlugin.
 class EventPlugin extends TracingPlugin {
+  #eventHandler
+  #eventFilter
+  #dataSymbol
+  #entryType
+
   constructor (eventHandler, eventFilter) {
     super()
-    this.eventHandler = eventHandler
-    this.eventFilter = eventFilter
-    this.contextData = new WeakMap()
-    this.entryType = this.constructor.entryType
+    this.#eventHandler = eventHandler
+    this.#eventFilter = eventFilter
+    this.#entryType = this.constructor.entryType
+    this.#dataSymbol = Symbol(`dd-trace.profiling.event.${this.#entryType}.${this.constructor.operation}`)
   }
 
   start (ctx) {
-    this.contextData.set(ctx, {
-      startEvent: ctx,
-      startTime: performance.now()
-    })
+    ctx[this.#dataSymbol] = performance.now()
   }
 
   error (ctx) {
-    const data = this.contextData.get(ctx)
-    if (data) {
-      data.error = true
-    }
+    // We don't emit perf events for failed operations
+    ctx[this.#dataSymbol] = undefined
   }
 
   finish (ctx) {
-    const data = this.contextData.get(ctx)
-
-    if (!data) return
+    const startTime = ctx[this.#dataSymbol]
+    if (startTime === undefined) {
+      return
+    }
+    ctx[this.#dataSymbol] = undefined
 
-    const { startEvent, startTime, error } = data
-    if (error || this.ignoreEvent(startEvent)) {
-      return // don't emit perf events for failed operations or ignored events
+    if (this.ignoreEvent(ctx)) {
+      return // don't emit perf events for ignored events
     }
 
     const duration = performance.now() - startTime
     const event = {
-      entryType: this.entryType,
+      entryType: this.#entryType,
       startTime,
       duration
     }
 
-    if (!this.eventFilter(event)) {
+    if (!this.#eventFilter(event)) {
       return
     }
 
     const context = (ctx.currentStore?.span || this.activeSpan)?.context()
-    event._ddSpanId = context?.toSpanId()
-    event._ddRootSpanId = context?._trace.started[0]?.context().toSpanId() || event._ddSpanId
+    event._ddSpanId = context?.toBigIntSpanId()
+    event._ddRootSpanId = context?._trace.started[0]?.context().toBigIntSpanId() || event._ddSpanId
 
-    this.eventHandler(this.extendEvent(event, startEvent))
+    this.#eventHandler(this.extendEvent(event, ctx))
   }
 
   ignoreEvent () {

package/packages/dd-trace/src/profiling/profilers/event_plugins/fs.js

@@ -19,17 +19,11 @@ const allowedParams = new Set([
 ])
 
 class FilesystemPlugin extends EventPlugin {
-  static get id () {
-    return 'fs'
-  }
+  static id = 'fs'
 
-  static get operation () {
-    return 'operation'
-  }
+  static operation = 'operation'
 
-  static get entryType () {
-    return 'fs'
-  }
+  static entryType = 'fs'
 
   ignoreEvent (event) {
     // Don't care about sync events, they show up in the event loop samples anyway

package/packages/dd-trace/src/profiling/profilers/event_plugins/net.js

@@ -3,17 +3,11 @@
 const EventPlugin = require('./event')
 
 class NetPlugin extends EventPlugin {
-  static get id () {
-    return 'net'
-  }
+  static id = 'net'
 
-  static get operation () {
-    return 'tcp'
-  }
+  static operation = 'tcp'
 
-  static get entryType () {
-    return 'net'
-  }
+  static entryType = 'net'
 
   extendEvent (event, { options }) {
     event.name = 'connect'

package/packages/dd-trace/src/profiling/profilers/events.js

@@ -3,9 +3,12 @@
 const { performance, constants, PerformanceObserver } = require('perf_hooks')
 const { END_TIMESTAMP_LABEL, SPAN_ID_LABEL, LOCAL_ROOT_SPAN_ID_LABEL, encodeProfileAsync } = require('./shared')
 const { Function, Label, Line, Location, Profile, Sample, StringTable, ValueType } = require('pprof-format')
-
+const PoissonProcessSamplingFilter = require('./poisson')
+const { availableParallelism, effectiveLibuvThreadCount } = require('../libuv-size')
 // perf_hooks uses millis, with fractional part representing nanos. We emit nanos into the pprof file.
 const MS_TO_NS = 1_000_000
+// The number of sampling intervals that need to pass before we reset the Poisson process sampling instant.
+const POISSON_RESET_FACTOR = 2
 
 // While this is an "events profiler", meaning it emits a pprof file based on events observed as
 // perf_hooks events, the emitted pprof file uses the type "timeline".
@@ -38,6 +41,24 @@ function labelFromStrStr (stringTable, keyStr, valStr) {
   return labelFromStr(stringTable, stringTable.dedup(keyStr), valStr)
 }
 
+function getSamplingIntervalMillis (options) {
+  return (options.samplingInterval || 1e3 / 99) // 99Hz
+}
+
+function getMaxSamples (options) {
+  const cpuSamplingInterval = getSamplingIntervalMillis(options)
+  const flushInterval = options.flushInterval || 65 * 1e3 // 60 seconds
+  const maxCpuSamples = flushInterval / cpuSamplingInterval
+
+  // The lesser of max parallelism and libuv thread pool size, plus one so we can detect
+  // oversubscription on libuv thread pool, plus another one for GC.
+  const factor = Math.max(1, Math.min(availableParallelism(), effectiveLibuvThreadCount)) + 2
+
+  // Let's not go overboard with too large limit and cap it at 100k. With current defaults, the
+  // value will be 65000/10.1*(4+2) = 38613.
+  return Math.min(100_000, Math.floor(maxCpuSamples * factor))
+}
+
 class GCDecorator {
   constructor (stringTable) {
     this.stringTable = stringTable
@@ -181,12 +202,15 @@ const decoratorTypes = {
 
 // Translates performance entries into pprof samples.
 class EventSerializer {
-  constructor () {
+  #sampleCount = 0
+
+  constructor (maxSamples) {
     this.stringTable = new StringTable()
     this.samples = []
     this.locations = []
     this.functions = []
     this.decorators = {}
+    this.maxSamples = maxSamples
 
     // A synthetic single-frame location to serve as the location for timeline
     // samples. We need these as the profiling backend (mimicking official pprof
@@ -204,6 +228,31 @@ class EventSerializer {
   }
 
   addEvent (item) {
+    if (this.samples.length < this.maxSamples) {
+      const sample = this.#createSample(item)
+      if (sample !== undefined) {
+        this.samples.push(sample)
+        this.#sampleCount++
+      }
+    } else {
+      this.#sampleCount++
+      // Reservoir sampling
+      const replacementIndex = Math.floor(Math.random() * this.#sampleCount)
+      if (replacementIndex < this.maxSamples) {
+        const sample = this.#createSample(item)
+        if (sample === undefined) {
+          this.#sampleCount-- // unlikely
+        } else {
+          // This will cause the samples to no longer be sorted in their array
+          // by their end time. This is fine as the backend has no ordering
+          // expectations.
+          this.samples[replacementIndex] = sample
+        }
+      }
+    }
+  }
+
+  #createSample (item) {
     const { entryType, startTime, duration, _ddSpanId, _ddRootSpanId } = item
     let decorator = this.decorators[entryType]
     if (!decorator) {
@@ -224,10 +273,11 @@ class EventSerializer {
       new Label({ key: this.timestampLabelKey, num: dateOffset + BigInt(Math.round(endTime * MS_TO_NS)) })
     ]
     if (_ddSpanId) {
-      label.push(labelFromStr(this.stringTable, this.spanIdKey, _ddSpanId))
+      label.push(
+        new Label({ key: this.spanIdKey, num: _ddSpanId }))
     }
     if (_ddRootSpanId) {
-      label.push(labelFromStr(this.stringTable, this.rootSpanIdKey, _ddRootSpanId))
+      label.push(new Label({ key: this.rootSpanIdKey, num: _ddRootSpanId }))
     }
 
     const sampleInput = {
@@ -236,7 +286,7 @@ class EventSerializer {
       label
     }
     decorator.decorateSample(sampleInput, item)
-    this.samples.push(new Sample(sampleInput))
+    return new Sample(sampleInput)
   }
 
   createProfile (startDate, endDate) {
@@ -324,50 +374,13 @@ class DatadogInstrumentationEventSource {
   }
 }
 
-class CompositeEventSource {
-  constructor (sources) {
-    this.sources = sources
-  }
-
-  start () {
-    this.sources.forEach(s => s.start())
-  }
-
-  stop () {
-    this.sources.forEach(s => s.stop())
-  }
-}
-
-function createPossionProcessSamplingFilter (samplingIntervalMillis) {
-  let nextSamplingInstant = performance.now()
-  let currentSamplingInstant = 0
-  setNextSamplingInstant()
-
-  return event => {
-    const endTime = event.startTime + event.duration
-    while (endTime >= nextSamplingInstant) {
-      setNextSamplingInstant()
-    }
-    // An event is sampled if it started before, and ended on or after a sampling instant. The above
-    // while loop will ensure that the ending invariant is always true for the current sampling
-    // instant so we don't have to test for it below. Across calls, the invariant also holds as long
-    // as the events arrive in endTime order. This is true for events coming from
-    // DatadogInstrumentationEventSource; they will be ordered by endTime by virtue of this method
-    // being invoked synchronously with the plugins' finish() handler which evaluates
-    // performance.now(). OTOH, events coming from NodeAPIEventSource (GC in typical setup) might be
-    // somewhat delayed as they are queued by Node, so they can arrive out of order with regard to
-    // events coming from the non-queued source. By omitting the endTime check, we will pass through
-    // some short events that started and ended before the current sampling instant. OTOH, if we
-    // were to check for this.currentSamplingInstant <= endTime, we would discard some long events
-    // that also ended before the current sampling instant. We'd rather err on the side of including
-    // some short events than excluding some long events.
-    return event.startTime < currentSamplingInstant
-  }
-
-  function setNextSamplingInstant () {
-    currentSamplingInstant = nextSamplingInstant
-    nextSamplingInstant -= Math.log(1 - Math.random()) * samplingIntervalMillis
-  }
+function createPoissonProcessSamplingFilter (samplingIntervalMillis) {
+  const poissonFilter = new PoissonProcessSamplingFilter({
+    samplingInterval: samplingIntervalMillis,
+    resetInterval: samplingIntervalMillis * POISSON_RESET_FACTOR,
+    now: performance.now.bind(performance)
+  })
+  return poissonFilter.filter.bind(poissonFilter)
 }
 
 /**
@@ -376,45 +389,51 @@ function createPossionProcessSamplingFilter (samplingIntervalMillis) {
  */
 class EventsProfiler {
   type = 'events'
-  eventSerializer = new EventSerializer()
+  #maxSamples
+  #eventSerializer
+  #eventSources
 
   constructor (options = {}) {
-    const eventHandler = event => this.eventSerializer.addEvent(event)
+    this.#maxSamples = getMaxSamples(options)
+    this.#eventSerializer = new EventSerializer(this.#maxSamples)
+
+    const eventHandler = event => this.#eventSerializer.addEvent(event)
     const eventFilter = options.timelineSamplingEnabled
-      // options.samplingInterval comes in microseconds, we need millis
-      ? createPossionProcessSamplingFilter((options.samplingInterval ?? 1e6 / 99) / 1000)
-      : _ => true
+      ? createPoissonProcessSamplingFilter(getSamplingIntervalMillis(options))
+      : () => true
     const filteringEventHandler = event => {
       if (eventFilter(event)) {
         eventHandler(event)
       }
     }
 
-    this.eventSource = options.codeHotspotsEnabled
+    this.#eventSources = options.codeHotspotsEnabled
       // Use Datadog instrumentation to collect events with span IDs. Still use
       // Node API for GC events.
-      ? new CompositeEventSource([
-        new DatadogInstrumentationEventSource(eventHandler, eventFilter),
-        new NodeApiEventSource(filteringEventHandler, ['gc'])
-      ])
+      ? [
+          new DatadogInstrumentationEventSource(eventHandler, eventFilter),
+          new NodeApiEventSource(filteringEventHandler, ['gc']),
+        ]
       // Use Node API instrumentation to collect events without span IDs
-      : new NodeApiEventSource(filteringEventHandler)
+      : [
+          new NodeApiEventSource(filteringEventHandler)
+        ]
   }
 
   start () {
-    this.eventSource.start()
+    this.#eventSources.forEach(s => s.start())
   }
 
   stop () {
-    this.eventSource.stop()
+    this.#eventSources.forEach(s => s.stop())
   }
 
   profile (restart, startDate, endDate) {
     if (!restart) {
       this.stop()
     }
-    const thatEventSerializer = this.eventSerializer
-    this.eventSerializer = new EventSerializer()
+    const thatEventSerializer = this.#eventSerializer
+    this.#eventSerializer = new EventSerializer(this.#maxSamples)
     return () => thatEventSerializer.createProfile(startDate, endDate)
   }
 

package/packages/dd-trace/src/profiling/profilers/poisson.js

@@ -0,0 +1,105 @@
+'use strict'
+
+class PoissonProcessSamplingFilter {
+  #currentSamplingInstant = 0
+  #nextSamplingInstant
+  #samplingInterval
+  #resetInterval
+  #now
+  #lastNow = Number.NEGATIVE_INFINITY
+  #samplingInstantCount = 0
+
+  constructor ({ samplingInterval, now, resetInterval }) {
+    if (samplingInterval <= 0) {
+      throw new RangeError(`samplingInterval (${samplingInterval}) must be greater than 0`)
+    }
+    if (resetInterval < samplingInterval) {
+      throw new RangeError(
+        `resetInterval (${resetInterval}) must be greater than samplingInterval (${samplingInterval})`
+      )
+    }
+    if (typeof now !== 'function') {
+      throw new TypeError('now must be a function')
+    }
+    this.#samplingInterval = samplingInterval
+    this.#resetInterval = resetInterval
+    this.#now = now
+    this.#nextSamplingInstant = this.#callNow()
+    this.#setNextSamplingInstant()
+  }
+
+  get currentSamplingInstant () {
+    return this.#currentSamplingInstant
+  }
+
+  get nextSamplingInstant () {
+    return this.#nextSamplingInstant
+  }
+
+  get samplingInstantCount () {
+    return this.#samplingInstantCount
+  }
+
+  #callNow () {
+    const nowValue = this.#now()
+    if (typeof nowValue !== 'number') {
+      throw new TypeError('now() must return a number')
+    }
+    if (nowValue < this.#lastNow) {
+      throw new RangeError('now() must return a value greater than or equal to the last returned value')
+    }
+    this.#lastNow = nowValue
+    return nowValue
+  }
+
+  filter (event) {
+    const endTime = event.startTime + event.duration
+    // We're using the end times of events as an approximation of current time as events are
+    // expected to be reported close to where they ended. If the end time (and thus, presumably, the
+    // current time) is past the next sampling instant, we make it the current sampling instant and
+    // compute the next sampling instant in its future.
+    if (endTime >= this.#nextSamplingInstant) {
+      // All observed events are supposed to have happened in the past. For purposes of advancing
+      // the next sampling instant, we cap endTime to now(). This protects us from advancing it far
+      // into future if we receive an event with erroneously long duration, which would also take
+      // many iterations of the below "while" loop.
+      const cappedEndTime = Math.min(endTime, this.#callNow())
+
+      // If nextSamplingInstant is far in cappedEndTime's past, first advance it close to it. This
+      // can happen if we didn't receive any events for a while. Since a Poisson process has no
+      // memory, we can reset it anytime. This will ensure that the "while" loop below runs at most
+      // few iterations.
+      const earliestContinuousPast = cappedEndTime - this.#resetInterval
+      if (this.#nextSamplingInstant < earliestContinuousPast) {
+        this.#nextSamplingInstant = earliestContinuousPast
+      }
+
+      // Advance the next sampling instant until it is in cappedEndTime's future.
+      while (cappedEndTime >= this.#nextSamplingInstant) {
+        this.#setNextSamplingInstant()
+      }
+    }
+    // An event is sampled if it started before, and ended on or after a sampling instant. The above
+    // while loop will ensure that the ending invariant is always true for the current sampling
+    // instant so we don't have to test for it below. Across calls, the invariant also holds as long
+    // as the events arrive in endTime order. This is true for events coming from
+    // DatadogInstrumentationEventSource; they will be ordered by endTime by virtue of this method
+    // being invoked synchronously with the plugins' finish() handler which evaluates
+    // performance.now(). OTOH, events coming from NodeAPIEventSource (GC in typical setup) might be
+    // somewhat delayed as they are queued by Node, so they can arrive out of order with regard to
+    // events coming from the non-queued source. By omitting the endTime check, we will pass through
+    // some short events that started and ended before the current sampling instant. OTOH, if we
+    // were to check for this.currentSamplingInstant <= endTime, we would discard some long events
+    // that also ended before the current sampling instant. We'd rather err on the side of including
+    // some short events than excluding some long events.
+    return event.startTime < this.#currentSamplingInstant
+  }
+
+  #setNextSamplingInstant () {
+    this.#currentSamplingInstant = this.#nextSamplingInstant
+    this.#nextSamplingInstant -= Math.log(1 - Math.random()) * this.#samplingInterval
+    this.#samplingInstantCount++
+  }
+}
+
+module.exports = PoissonProcessSamplingFilter

package/packages/dd-trace/src/profiling/profilers/wall.js

@@ -75,7 +75,7 @@ class NativeWallProfiler {
   _started = false
 
   constructor (options = {}) {
-    this._samplingIntervalMicros = options.samplingInterval || 1e6 / 99 // 99hz
+    this._samplingIntervalMicros = (options.samplingInterval || 1e3 / 99) * 1000 // 99hz
     this._flushIntervalMillis = options.flushInterval || 60 * 1e3 // 60 seconds
     this._codeHotspotsEnabled = !!options.codeHotspotsEnabled
     this._endpointCollectionEnabled = !!options.endpointCollectionEnabled
@@ -215,10 +215,10 @@ class NativeWallProfiler {
 
   _updateContext (context) {
     if (context.spanId !== null && typeof context.spanId === 'object') {
-      context.spanId = context.spanId.toString(10)
+      context.spanId = context.spanId.toBigInt()
     }
     if (context.rootSpanId !== null && typeof context.rootSpanId === 'object') {
-      context.rootSpanId = context.rootSpanId.toString(10)
+      context.rootSpanId = context.rootSpanId.toBigInt()
     }
     if (context.webTags !== undefined && context.endpoint === undefined) {
       // endpoint may not be determined yet, but keep it as fallback

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

@@ -22,7 +22,7 @@ const kSupportsAckCallback = Symbol('kSupportsAckCallback')
 // There MUST NOT exist separate instances of RC clients in a tracer making separate ClientGetConfigsRequest
 // with their own separated Client.ClientState.
 class RemoteConfigManager extends EventEmitter {
-  static get kPreUpdate () { return kPreUpdate }
+  static kPreUpdate = kPreUpdate
 
   constructor (config) {
     super()

package/packages/dd-trace/src/supported-configurations.json

@@ -129,6 +129,7 @@
     "DD_PROFILING_HEAP_ENABLED": ["A"],
     "DD_PROFILING_PROFILERS": ["A"],
     "DD_PROFILING_SOURCE_MAP": ["A"],
+    "DD_PROFILING_TIMELINE_ENABLED": ["A"],
     "DD_PROFILING_UPLOAD_PERIOD": ["A"],
     "DD_PROFILING_V8_PROFILER_BUG_WORKAROUND": ["A"],
     "DD_PROFILING_WALLTIME_ENABLED": ["A"],
@@ -160,6 +161,7 @@
     "DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED": ["A"],
     "DD_TRACE_128_BIT_TRACEID_LOGGING_ENABLED": ["A"],
     "DD_TRACE_AEROSPIKE_ENABLED": ["A"],
+    "DD_TRACE_AI_ENABLED": ["A"],
     "DD_TRACE_AGENT_PORT": ["A"],
     "DD_TRACE_AGENT_PROTOCOL_VERSION": ["A"],
     "DD_TRACE_AGENT_URL": ["A"],