dd-trace 5.71.0 → 5.72.0

package/packages/dd-trace/src/profiling/profiler.js

@@ -41,9 +41,16 @@ function findWebSpan (startedSpans, spanId) {
   return false
 }
 
+function processInfo (infos, info, type) {
+  if (Object.keys(info).length > 0) {
+    infos[type] = info
+  }
+}
+
 class Profiler extends EventEmitter {
   #compressionFn
   #compressionOptions
+  #config
   #enabled = false
   #endpointCounts = new Map()
   #lastStart
@@ -54,10 +61,13 @@ class Profiler extends EventEmitter {
 
   constructor () {
     super()
-    this._config = undefined
     this._timeoutInterval = undefined
   }
 
+  get flushInterval () {
+    return this.#config?.flushInterval
+  }
+
   start (options) {
     return this._start(options).catch((err) => {
       logError(options.logger, 'Error starting profiler. For troubleshooting tips, see ' +
@@ -77,7 +87,7 @@ class Profiler extends EventEmitter {
   async _start (options) {
     if (this.enabled) return true
 
-    const config = this._config = new Config(options)
+    const config = this.#config = new Config(options)
 
     this.#logger = config.logger
     this.#enabled = true
@@ -158,16 +168,18 @@ class Profiler extends EventEmitter {
     }
   }
 
-  #nearOOMExport (profileType, encodedProfile) {
+  #nearOOMExport (profileType, encodedProfile, info) {
     const start = this.#lastStart
     const end = new Date()
+    const infos = this.#createInitialInfos()
+    processInfo(infos, info, profileType)
     this.#submit({
       [profileType]: encodedProfile
-    }, start, end, snapshotKinds.ON_OUT_OF_MEMORY)
+    }, infos, start, end, snapshotKinds.ON_OUT_OF_MEMORY)
   }
 
   _setInterval () {
-    this._timeoutInterval = this._config.flushInterval
+    this._timeoutInterval = this.#config.flushInterval
   }
 
   stop () {
@@ -189,7 +201,7 @@ class Profiler extends EventEmitter {
       this.#spanFinishListener = undefined
     }
 
-    for (const profiler of this._config.profilers) {
+    for (const profiler of this.#config.profilers) {
       profiler.stop()
       this.#logger.debug(`Stopped ${profiler.type} profiler in ${threadNamePrefix} thread`)
     }
@@ -229,28 +241,34 @@ class Profiler extends EventEmitter {
     }
   }
 
+  #createInitialInfos () {
+    return {
+      settings: this.#config.systemInfoReport
+    }
+  }
+
   async _collect (snapshotKind, restart = true) {
     if (!this.enabled) return
 
-    const startDate = this.#lastStart
-    const endDate = new Date()
-    const profiles = []
-    const encodedProfiles = {}
-
     try {
-      if (this._config.profilers.length === 0) {
+      if (this.#config.profilers.length === 0) {
         throw new Error('No profile types configured.')
       }
 
+      const startDate = this.#lastStart
+      const endDate = new Date()
+      const profiles = []
+
       crashtracker.withProfilerSerializing(() => {
         // collect profiles synchronously so that profilers can be safely stopped asynchronously
-        for (const profiler of this._config.profilers) {
+        for (const profiler of this.#config.profilers) {
+          const info = profiler.getInfo()
           const profile = profiler.profile(restart, startDate, endDate)
           if (!restart) {
             this.#logger.debug(`Stopped ${profiler.type} profiler in ${threadNamePrefix} thread`)
           }
           if (!profile) continue
-          profiles.push({ profiler, profile })
+          profiles.push({ profiler, profile, info })
         }
       })
 
@@ -260,16 +278,20 @@ class Profiler extends EventEmitter {
 
       let hasEncoded = false
 
+      const encodedProfiles = {}
+      const infos = this.#createInitialInfos()
+
       // encode and export asynchronously
-      await Promise.all(profiles.map(async ({ profiler, profile }) => {
+      await Promise.all(profiles.map(async ({ profiler, profile, info }) => {
         try {
           const encoded = await profiler.encode(profile)
           const compressed = encoded instanceof Buffer && this.#compressionFn !== undefined
             ? await this.#compressionFn(encoded, this.#compressionOptions)
             : encoded
           encodedProfiles[profiler.type] = compressed
+          processInfo(infos, info, profiler.type)
           this.#logger.debug(() => {
-            const profileJson = JSON.stringify(profile, (key, value) => {
+            const profileJson = JSON.stringify(profile, (_, value) => {
               return typeof value === 'bigint' ? value.toString() : value
             })
             return `Collected ${profiler.type} profile: ` + profileJson
@@ -283,7 +305,7 @@ class Profiler extends EventEmitter {
       }))
 
       if (hasEncoded) {
-        await this.#submit(encodedProfiles, startDate, endDate, snapshotKind)
+        await this.#submit(encodedProfiles, infos, startDate, endDate, snapshotKind)
         profileSubmittedChannel.publish()
         this.#logger.debug('Submitted profiles')
       }
@@ -293,8 +315,8 @@ class Profiler extends EventEmitter {
     }
   }
 
-  #submit (profiles, start, end, snapshotKind) {
-    const { tags } = this._config
+  #submit (profiles, infos, start, end, snapshotKind) {
+    const { tags } = this.#config
 
     // Flatten endpoint counts
     const endpointCounts = {}
@@ -305,8 +327,8 @@ class Profiler extends EventEmitter {
 
     tags.snapshot = snapshotKind
     tags.profile_seq = this.#profileSeq++
-    const exportSpec = { profiles, start, end, tags, endpointCounts }
-    const tasks = this._config.exporters.map(exporter =>
+    const exportSpec = { profiles, infos, start, end, tags, endpointCounts }
+    const tasks = this.#config.exporters.map(exporter =>
       exporter.export(exportSpec).catch(err => {
         if (this.#logger) {
           this.#logger.warn(err)
@@ -336,7 +358,7 @@ class ServerlessProfiler extends Profiler {
 
   _setInterval () {
     this._timeoutInterval = this.#interval * 1000
-    this.#flushAfterIntervals = this._config.flushInterval / 1000
+    this.#flushAfterIntervals = this.flushInterval / 1000
   }
 
   async _collect (snapshotKind, restart = true) {

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

@@ -383,17 +383,20 @@ function createPoissonProcessSamplingFilter (samplingIntervalMillis) {
  * source with a sampling event filter and an event serializer.
  */
 class EventsProfiler {
-  type = 'events'
-  #maxSamples
+  #maxSamples = 0
+  #timelineSamplingEnabled = false
   #eventSerializer
   #eventSources
 
+  get type () { return 'events' }
+
   constructor (options = {}) {
     this.#maxSamples = getMaxSamples(options)
+    this.#timelineSamplingEnabled = !!options.timelineSamplingEnabled
     this.#eventSerializer = new EventSerializer(this.#maxSamples)
 
     const eventHandler = event => this.#eventSerializer.addEvent(event)
-    const eventFilter = options.timelineSamplingEnabled
+    const eventFilter = this.#timelineSamplingEnabled
       ? createPoissonProcessSamplingFilter(options.samplingInterval)
       : () => true
     const filteringEventHandler = event => {
@@ -432,6 +435,12 @@ class EventsProfiler {
     return () => thatEventSerializer.createProfile(startDate, endDate)
   }
 
+  getInfo () {
+    return {
+      maxSamples: this.#maxSamples
+    }
+  }
+
   encode (profile) {
     return encodeProfileAsync(profile())
   }

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

@@ -7,59 +7,70 @@ function strategiesToCallbackMode (strategies, callbackMode) {
   return strategies.includes(oomExportStrategies.ASYNC_CALLBACK) ? callbackMode.Async : 0
 }
 
+const STACK_DEPTH = 64
+
 class NativeSpaceProfiler {
-  type = 'space'
-  _pprof
-  _started = false
+  #mapper
+  #oomMonitoring
+  #pprof
+  #samplingInterval = 512 * 1024
+  #started = false
 
   constructor (options = {}) {
     // TODO: Remove default value. It is only used in testing.
-    this._samplingInterval = options.heapSamplingInterval || 512 * 1024
-    this._stackDepth = options.stackDepth || 64
-    this._oomMonitoring = options.oomMonitoring || {}
+    this.#samplingInterval = options.heapSamplingInterval || 512 * 1024
+    this.#oomMonitoring = options.oomMonitoring || {}
+  }
+
+  get type () {
+    return 'space'
   }
 
   start ({ mapper, nearOOMCallback } = {}) {
-    if (this._started) return
+    if (this.#started) return
 
-    this._mapper = mapper
-    this._pprof = require('@datadog/pprof')
-    this._pprof.heap.start(this._samplingInterval, this._stackDepth)
-    if (this._oomMonitoring.enabled) {
-      const strategies = this._oomMonitoring.exportStrategies
-      this._pprof.heap.monitorOutOfMemory(
-        this._oomMonitoring.heapLimitExtensionSize,
-        this._oomMonitoring.maxHeapExtensionCount,
+    this.#mapper = mapper
+    this.#pprof = require('@datadog/pprof')
+    this.#pprof.heap.start(this.#samplingInterval, STACK_DEPTH)
+    if (this.#oomMonitoring.enabled) {
+      const strategies = this.#oomMonitoring.exportStrategies
+      this.#pprof.heap.monitorOutOfMemory(
+        this.#oomMonitoring.heapLimitExtensionSize,
+        this.#oomMonitoring.maxHeapExtensionCount,
         strategies.includes(oomExportStrategies.LOGS),
-        strategies.includes(oomExportStrategies.PROCESS) ? this._oomMonitoring.exportCommand : [],
-        (profile) => nearOOMCallback(this.type, this._pprof.encodeSync(profile)),
-        strategiesToCallbackMode(strategies, this._pprof.heap.CallbackMode)
+        strategies.includes(oomExportStrategies.PROCESS) ? this.#oomMonitoring.exportCommand : [],
+        (profile) => nearOOMCallback(this.type, this.#pprof.encodeSync(profile), this.getInfo()),
+        strategiesToCallbackMode(strategies, this.#pprof.heap.CallbackMode)
       )
     }
 
-    this._started = true
+    this.#started = true
   }
 
   profile (restart) {
-    const profile = this._pprof.heap.profile(undefined, this._mapper, getThreadLabels)
+    const profile = this.#pprof.heap.profile(undefined, this.#mapper, getThreadLabels)
     if (!restart) {
       this.stop()
     }
     return profile
   }
 
+  getInfo () {
+    return {}
+  }
+
   encode (profile) {
     return encodeProfileAsync(profile)
   }
 
   stop () {
-    if (!this._started) return
-    this._pprof.heap.stop()
-    this._started = false
+    if (!this.#started) return
+    this.#pprof.heap.stop()
+    this.#started = false
   }
 
   isStarted () {
-    return this._started
+    return this.#started
   }
 }
 

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

@@ -25,7 +25,6 @@ const profilerTelemetryMetrics = telemetryMetrics.manager.namespace('profilers')
 const ProfilingContext = Symbol('NativeWallProfiler.ProfilingContext')
 
 let kSampleCount
-let kCPEDContextCount
 
 function getActiveSpan () {
   const store = storage('legacy').getStore()
@@ -167,7 +166,6 @@ class NativeWallProfiler {
     this.#mapper = mapper
     this.#pprof = require('@datadog/pprof')
     kSampleCount = this.#pprof.time.constants.kSampleCount
-    kCPEDContextCount = this.#pprof.time.constants.kCPEDContextCount
 
     // pprof otherwise crashes in worker threads
     if (!process._startProfilerIdleNotifier) {
@@ -213,12 +211,14 @@ class NativeWallProfiler {
   }
 
   #setupTelemetryMetrics () {
-    const contextCountGauge = profilerTelemetryMetrics.gauge('wall.sample_contexts')
+    const asyncContextsLiveGauge = profilerTelemetryMetrics.gauge('wall.async_contexts_live')
+    const asyncContextsUsedGauge = profilerTelemetryMetrics.gauge('wall.async_contexts_used')
 
-    const that = this
     this._contextCountGaugeUpdater = setInterval(() => {
-      contextCountGauge.mark(that._profilerState[kCPEDContextCount])
-    }, that.#telemetryHeartbeatIntervalMillis)
+      const { totalAsyncContextCount, usedAsyncContextCount } = this.#pprof.time.getMetrics()
+      asyncContextsLiveGauge.mark(totalAsyncContextCount)
+      asyncContextsUsedGauge.mark(usedAsyncContextCount)
+    }, this.#telemetryHeartbeatIntervalMillis)
     this._contextCountGaugeUpdater.unref()
   }
 
@@ -410,6 +410,14 @@ class NativeWallProfiler {
     return this.#stop(restart)
   }
 
+  getInfo () {
+    const { totalAsyncContextCount, usedAsyncContextCount } = this.#pprof.time.getMetrics()
+    return {
+      totalAsyncContextCount,
+      usedAsyncContextCount
+    }
+  }
+
   encode (profile) {
     return encodeProfileAsync(profile)
   }

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

@@ -84,7 +84,8 @@ class Tracer extends NoopProxy {
       appsec: new LazyModule(() => require('./appsec')),
       iast: new LazyModule(() => require('./appsec/iast')),
       llmobs: new LazyModule(() => require('./llmobs')),
-      rewriter: new LazyModule(() => require('./appsec/iast/taint-tracking/rewriter'))
+      rewriter: new LazyModule(() => require('./appsec/iast/taint-tracking/rewriter')),
+      openfeature: new LazyModule(() => require('./openfeature'))
     }
   }
 
@@ -158,6 +159,15 @@ class Tracer extends NoopProxy {
         if (config.dynamicInstrumentation.enabled) {
           DynamicInstrumentation.start(config, rc)
         }
+
+        if (config.experimental.flaggingProvider.enabled) {
+          rc.setProductHandler('FFE_FLAGS', (action, conf) => {
+            // Feed UFC config directly to OpenFeature provider
+            if (action === 'apply' || action === 'modify') {
+              this.openfeature._setConfiguration(conf.flag_configuration)
+            }
+          })
+        }
       }
 
       if (config.profiling.enabled === 'true') {
@@ -204,6 +214,11 @@ class Tracer extends NoopProxy {
         }
       }
 
+      if (config.otelLogsEnabled) {
+        const { initializeOpenTelemetryLogs } = require('./opentelemetry/logs')
+        initializeOpenTelemetryLogs(config)
+      }
+
       if (config.isTestDynamicInstrumentationEnabled) {
         const getDynamicInstrumentationClient = require('./ci-visibility/dynamic-instrumentation')
         // We instantiate the client but do not start the Worker here. The worker is started lazily
@@ -249,6 +264,11 @@ class Tracer extends NoopProxy {
         }
         this._tracingInitialized = true
       }
+      if (config.experimental.flaggingProvider.enabled) {
+        this._modules.openfeature.enable(config)
+        lazyProxy(this, 'openfeature', config, () =>
+          require('./openfeature/flagging_provider'), this._tracer, config)
+      }
       if (config.iast.enabled) {
         this._modules.iast.enable(config, this._tracer)
       }
@@ -257,6 +277,7 @@ class Tracer extends NoopProxy {
       this._modules.appsec.disable()
       this._modules.iast.disable()
       this._modules.llmobs.disable()
+      this._modules.openfeature.disable()
     }
 
     if (this._tracingInitialized) {

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

@@ -32,6 +32,7 @@ module.exports = {
   ASM_DD_MULTICONFIG: 1n << 42n,
   ASM_TRACE_TAGGING_RULES: 1n << 43n,
   ASM_EXTENDED_DATA_COLLECTION: 1n << 44n,
+  FFE_FLAG_CONFIGURATION_RULES: 1n << 46n,
   /*
     DO NOT ADD ARBITRARY CAPABILITIES IN YOUR CODE
     UNLESS THEY ARE ALREADY DEFINED IN THE BACKEND SOURCE OF TRUTH

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

@@ -17,6 +17,7 @@ function enable (config, appsec) {
   rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_SAMPLE_RATE, true)
   rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_ENABLED, true)
   rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_SAMPLE_RULES, true)
+  rc.updateCapabilities(RemoteConfigCapabilities.FFE_FLAG_CONFIGURATION_RULES, true)
 
   const activation = Activation.fromConfig(config)
 

package/packages/dd-trace/src/service-naming/schemas/v0/messaging.js

@@ -16,6 +16,10 @@ const messaging = {
       opName: () => 'amqp.send',
       serviceName: amqpServiceName
     },
+    'azure-event-hubs': {
+      opName: () => 'azure.eventhubs.send',
+      serviceName: ({ tracerService }) => `${tracerService}-azure-event-hubs`
+    },
     'azure-service-bus': {
       opName: () => 'azure.servicebus.send',
       serviceName: ({ tracerService }) => `${tracerService}-azure-service-bus`

package/packages/dd-trace/src/service-naming/schemas/v1/messaging.js

@@ -16,6 +16,14 @@ const messaging = {
   producer: {
     amqplib: amqpOutbound,
     amqp10: amqpOutbound,
+    'azure-service-bus': {
+      opName: () => 'azure.servicebus.send',
+      serviceName: identityService
+    },
+    'azure-event-hubs': {
+      opName: () => 'azure.eventhubs.send',
+      serviceName: identityService
+    },
     'google-cloud-pubsub': {
       opName: () => 'gcp.pubsub.send',
       serviceName: identityService

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

@@ -69,9 +69,11 @@
     "DD_DYNAMIC_INSTRUMENTATION_UPLOAD_INTERVAL_SECONDS": ["A"],
     "DD_ENV": ["A"],
     "DD_EXPERIMENTAL_APPSEC_STANDALONE_ENABLED": ["A"],
+    "DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED": ["A"],
     "DD_EXPERIMENTAL_TEST_OPT_GIT_CACHE_ENABLED": ["A"],
     "DD_EXPERIMENTAL_TEST_OPT_GIT_CACHE_DIR": ["A"],
     "DD_EXTERNAL_ENV": ["A"],
+    "DD_FLAGGING_PROVIDER_ENABLED": ["A"],
     "DD_GIT_BRANCH": ["A"],
     "DD_GIT_COMMIT_AUTHOR_DATE": ["A"],
     "DD_GIT_COMMIT_AUTHOR_EMAIL": ["A"],
@@ -82,6 +84,7 @@
     "DD_GIT_COMMIT_MESSAGE": ["A"],
     "DD_GIT_COMMIT_SHA": ["A"],
     "DD_GIT_PROPERTIES_FILE": ["A"],
+    "DD_GIT_FOLDER_PATH": ["A"],
     "DD_GIT_REPOSITORY_URL": ["A"],
     "DD_GIT_TAG": ["A"],
     "DD_GIT_PULL_REQUEST_BASE_BRANCH": ["A"],
@@ -120,6 +123,7 @@
     "DD_LLMOBS_ML_APP": ["A"],
     "DD_LOG_LEVEL": ["A"],
     "DD_LOGS_INJECTION": ["A"],
+    "DD_LOGS_OTEL_ENABLED": ["A"],
     "DD_MINI_AGENT_PATH": ["A"],
     "DD_OPENAI_LOGS_ENABLED": ["A"],
     "DD_OPENAI_SPAN_CHAR_LIMIT": ["A"],
@@ -225,6 +229,8 @@
     "DD_TRACE_AWS_SDK_STEPFUNCTIONS_BATCH_PROPAGATION_ENABLED": ["A"],
     "DD_TRACE_AWS_SDK_STEPFUNCTIONS_ENABLED": ["A"],
     "DD_TRACE_AXIOS_ENABLED": ["A"],
+    "DD_TRACE_AZURE_EVENT_HUBS_ENABLED": ["A"],
+    "DD_TRACE_AZURE_EVENTHUBS_BATCH_LINKS_ENABLED": ["A"],
     "DD_TRACE_AZURE_FUNCTIONS_ENABLED": ["A"],
     "DD_TRACE_AZURE_SERVICE_BUS_ENABLED": ["A"],
     "DD_TRACE_BAGGAGE_MAX_BYTES": ["A"],
@@ -438,6 +444,17 @@
     "DD_VERTEXAI_SPAN_PROMPT_COMPLETION_SAMPLE_RATE": ["A"],
     "OTEL_LOG_LEVEL": ["A"],
     "OTEL_LOGS_EXPORTER": ["A"],
+    "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT": ["A"],
+    "OTEL_EXPORTER_OTLP_LOGS_HEADERS": ["A"],
+    "OTEL_EXPORTER_OTLP_LOGS_PROTOCOL": ["A"],
+    "OTEL_EXPORTER_OTLP_LOGS_TIMEOUT": ["A"],
+    "OTEL_EXPORTER_OTLP_ENDPOINT": ["A"],
+    "OTEL_EXPORTER_OTLP_HEADERS": ["A"],
+    "OTEL_EXPORTER_OTLP_PROTOCOL": ["A"],
+    "OTEL_EXPORTER_OTLP_TIMEOUT": ["A"],
+    "OTEL_BSP_SCHEDULE_DELAY": ["A"],
+    "OTEL_BSP_MAX_EXPORT_BATCH_SIZE": ["A"],
+    "OTEL_BSP_MAX_QUEUE_SIZE": ["A"],
     "OTEL_METRICS_EXPORTER": ["A"],
     "OTEL_PROPAGATORS": ["A"],
     "OTEL_RESOURCE_ATTRIBUTES": ["A"],

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

@@ -328,7 +328,19 @@ const nameMapping = {
   instrumentationSource: 'instrumentation_source',
   injectionEnabled: 'ssi_injection_enabled',
   injectForce: 'ssi_forced_injection_enabled',
-  'runtimeMetrics.enabled': 'runtimeMetrics'
+  'runtimeMetrics.enabled': 'runtimeMetrics',
+  otelLogsEnabled: 'DD_LOGS_OTEL_ENABLED',
+  otelUrl: 'OTEL_EXPORTER_OTLP_ENDPOINT',
+  otelEndpoint: 'OTEL_EXPORTER_OTLP_ENDPOINT',
+  otelHeaders: 'OTEL_EXPORTER_OTLP_HEADERS',
+  otelProtocol: 'OTEL_EXPORTER_OTLP_PROTOCOL',
+  otelTimeout: 'OTEL_EXPORTER_OTLP_TIMEOUT',
+  otelLogsHeaders: 'OTEL_EXPORTER_OTLP_LOGS_HEADERS',
+  otelLogsProtocol: 'OTEL_EXPORTER_OTLP_LOGS_PROTOCOL',
+  otelLogsTimeout: 'OTEL_EXPORTER_OTLP_LOGS_TIMEOUT',
+  otelLogsUrl: 'OTEL_EXPORTER_OTLP_LOGS_ENDPOINT',
+  otelLogsBatchTimeout: 'OTEL_BSP_SCHEDULE_DELAY',
+  otelLogsMaxExportBatchSize: 'OTEL_BSP_MAX_EXPORT_BATCH_SIZE',
 }
 
 const namesNeedFormatting = new Set(['DD_TAGS', 'peerServiceMapping', 'serviceMapping'])