dd-trace 5.97.0 → 5.98.0

package/packages/dd-trace/src/appsec/blocking.js

@@ -6,9 +6,27 @@ const { updateBlockFailureMetric } = require('./telemetry')
 
 const detectedSpecificEndpoints = {}
 
-let templateHtml = blockedTemplates.html
-let templateJson = blockedTemplates.json
-let templateGraphqlJson = blockedTemplates.graphqlJson
+const templateKeyword = '[security_response_id]'
+
+const templates = {
+  html: {
+    body: null,
+    idIndex: -1,
+    type: 'text/html; charset=utf-8',
+  },
+  json: {
+    body: null,
+    idIndex: -1,
+    type: 'application/json',
+  },
+  graphqlJson: {
+    body: null,
+    idIndex: -1,
+    type: 'application/json',
+  },
+}
+
+setTemplates()
 
 let defaultBlockingActionParameters
 
@@ -17,7 +35,7 @@ const responseBlockedSet = new WeakSet()
 const blockDelegations = new WeakMap()
 
 const specificBlockingTypes = {
-  GRAPHQL: 'graphql',
+  GRAPHQL: 'graphqlJson',
 }
 
 function getSpecificKey (method, url) {
@@ -33,21 +51,14 @@ function getBlockWithRedirectData (actionParameters) {
   if (!statusCode || statusCode < 300 || statusCode >= 400) {
     statusCode = 303
   }
-  const headers = {
-    Location: actionParameters.location,
-  }
 
-  return { headers, statusCode }
-}
+  const headers = { Location: actionParameters.location }
 
-function getSpecificBlockingData (type) {
-  switch (type) {
-    case specificBlockingTypes.GRAPHQL:
-      return {
-        type: 'application/json',
-        body: templateGraphqlJson,
-      }
+  if (headers.Location) {
+    headers.Location = headers.Location.replace(templateKeyword, actionParameters.security_response_id ?? '')
   }
+
+  return { headers, statusCode }
 }
 
 function getBlockWithContentData (req, specificType, actionParameters) {
@@ -56,7 +67,7 @@ function getBlockWithContentData (req, specificType, actionParameters) {
 
   const specificBlockingType = specificType || detectedSpecificEndpoints[getSpecificKey(req.method, req.url)]
   if (specificBlockingType) {
-    const specificBlockingContent = getSpecificBlockingData(specificBlockingType)
+    const specificBlockingContent = getTemplate(specificBlockingType, actionParameters)
     type = specificBlockingContent?.type
     body = specificBlockingContent?.body
   }
@@ -65,23 +76,17 @@ function getBlockWithContentData (req, specificType, actionParameters) {
     // parse the Accept header, ex: Accept: text/html, application/xhtml+xml, application/xml;q=0.9, */*;q=0.8
     const accept = req.headers.accept?.split(',').map((str) => str.split(';', 1)[0].trim())
 
+    let templateName = 'json'
+
     if (!actionParameters || actionParameters.type === 'auto') {
       if (accept?.includes('text/html') && !accept.includes('application/json')) {
-        type = 'text/html; charset=utf-8'
-        body = templateHtml
-      } else {
-        type = 'application/json'
-        body = templateJson
-      }
-    } else {
-      if (actionParameters.type === 'html') {
-        type = 'text/html; charset=utf-8'
-        body = templateHtml
-      } else {
-        type = 'application/json'
-        body = templateJson
+        templateName = 'html'
       }
+    } else if (actionParameters.type === 'html') {
+      templateName = 'html'
     }
+
+    ({ type, body } = getTemplate(templateName, actionParameters))
   }
 
   const statusCode = actionParameters?.status_code || 403
@@ -165,14 +170,37 @@ function getBlockingAction (actions) {
 }
 
 /**
- * @param {import('../config/config-base')} config - Tracer configuration
+ * @param {import('../config/config-base')} [config] - Tracer configuration
  */
 function setTemplates (config) {
-  templateHtml = config.appsec.blockedTemplateHtml || blockedTemplates.html
+  templates.html.body = config?.appsec?.blockedTemplateHtml
+  templates.json.body = config?.appsec?.blockedTemplateJson
+  templates.graphqlJson.body = config?.appsec?.blockedTemplateGraphql
+
+  for (const type of Object.keys(templates)) {
+    const template = templates[type]
+
+    // set default template if not set by config
+    if (!template.body) template.body = blockedTemplates[type]
+
+    template.idIndex = template.body.indexOf(templateKeyword)
+
+    if (template.idIndex !== -1) {
+      template.body = [
+        template.body.slice(0, template.idIndex),
+        template.body.slice(template.idIndex + templateKeyword.length),
+      ]
+    }
+  }
+}
+
+function getTemplate (type, actionParameters) {
+  const template = templates[type]
+  if (template.idIndex === -1) return template
 
-  templateJson = config.appsec.blockedTemplateJson || blockedTemplates.json
+  const body = template.body[0] + (actionParameters?.security_response_id ?? '') + template.body[1]
 
-  templateGraphqlJson = config.appsec.blockedTemplateGraphql || blockedTemplates.graphqlJson
+  return { body, type: template.type }
 }
 
 function isBlocked (res) {

package/packages/dd-trace/src/appsec/sdk/set_user.js

@@ -19,7 +19,7 @@ function setUser (tracer, user) {
     return
   }
 
-  const rootSpan = getRootSpan(tracer)
+  const rootSpan = getRootSpan()
   if (!rootSpan) {
     log.warn('[ASM] Root span not available in setUser')
     return

package/packages/dd-trace/src/appsec/sdk/track_event.js

@@ -21,7 +21,7 @@ function trackUserLoginSuccessEvent (tracer, user, metadata) {
 
   incrementSdkEventMetric('login_success', 'v1')
 
-  const rootSpan = getRootSpan(tracer)
+  const rootSpan = getRootSpan()
   if (!rootSpan) {
     log.warn('[ASM] Root span not available in trackUserLoginSuccessEvent')
     return
@@ -54,7 +54,7 @@ function trackUserLoginFailureEvent (tracer, userId, exists, metadata) {
     ...metadata,
   }
 
-  trackEvent('users.login.failure', fields, 'trackUserLoginFailureEvent', getRootSpan(tracer))
+  trackEvent('users.login.failure', fields, 'trackUserLoginFailureEvent', getRootSpan())
 
   runWaf('users.login.failure', { login: userId })
 
@@ -67,7 +67,7 @@ function trackCustomEvent (tracer, eventName, metadata) {
     return
   }
 
-  trackEvent(eventName, metadata, 'trackCustomEvent', getRootSpan(tracer))
+  trackEvent(eventName, metadata, 'trackCustomEvent', getRootSpan())
 
   incrementSdkEventMetric('custom', 'v1')
 
@@ -84,7 +84,7 @@ function trackUserLoginSuccessV2 (tracer, login, user, metadata) {
 
   incrementSdkEventMetric('login_success', 'v2')
 
-  const rootSpan = getRootSpan(tracer)
+  const rootSpan = getRootSpan()
   if (!rootSpan) {
     log.warn('[ASM] Root span not available in eventTrackingV2.trackUserLoginSuccess')
     return
@@ -122,7 +122,7 @@ function trackUserLoginFailureV2 (tracer, login, exists, metadata) {
 
   incrementSdkEventMetric('login_failure', 'v2')
 
-  const rootSpan = getRootSpan(tracer)
+  const rootSpan = getRootSpan()
   if (!rootSpan) {
     log.warn('[ASM] Root span not available in eventTrackingV2.trackUserLoginFailure')
     return

package/packages/dd-trace/src/appsec/sdk/user_blocking.js

@@ -19,7 +19,7 @@ function checkUserAndSetUser (tracer, user) {
     return false
   }
 
-  const rootSpan = getRootSpan(tracer)
+  const rootSpan = getRootSpan()
   if (rootSpan) {
     if (!rootSpan.context()._tags['usr.id']) {
       setUserTags(user, rootSpan)
@@ -45,7 +45,7 @@ function blockRequest (tracer, req, res) {
     return false
   }
 
-  const rootSpan = getRootSpan(tracer)
+  const rootSpan = getRootSpan()
   if (!rootSpan) {
     log.warn('[ASM] Root span not available in blockRequest')
     return false

package/packages/dd-trace/src/appsec/sdk/utils.js

@@ -1,7 +1,9 @@
 'use strict'
 
-function getRootSpan (tracer) {
-  let span = tracer.scope().active()
+const { storage } = require('../../../../datadog-core')
+
+function getRootSpan () {
+  let span = storage('legacy').getStore()?.span
   if (!span) return
 
   const context = span.context()

package/packages/dd-trace/src/config/defaults.js

@@ -60,7 +60,6 @@ setWarnInvalidValue(warnInvalidValue)
 const defaults = {
   instrumentationSource: 'manual',
   isServiceUserProvided: false,
-  isServiceNameInferred: true,
   plugins: true,
   isCiVisibility: false,
   lookup: dns.lookup,

package/packages/dd-trace/src/config/generated-config-types.d.ts

@@ -504,6 +504,10 @@ export interface GeneratedConfig {
   otelMetricsUrl: string | undefined;
   otelProtocol: string;
   otelTimeout: number;
+  otelTracesHeaders: Record<string, string> | undefined;
+  otelTracesProtocol: string;
+  otelTracesTimeout: number;
+  otelTracesUrl: string | undefined;
   peerServiceMapping: Record<string, string>;
   port: string | number;
   profiling: {
@@ -526,6 +530,7 @@ export interface GeneratedConfig {
     enabled: boolean;
     eventLoop: boolean;
     gc: boolean;
+    native: boolean;
   };
   runtimeMetricsRuntimeId: boolean;
   sampleRate: number | undefined;

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

@@ -29,7 +29,6 @@ const {
   getEnvironmentVariable,
   getEnvironmentVariables,
   getStableConfigSources,
-  getValueFromEnvSources,
 } = require('./helper')
 const {
   defaults,
@@ -229,22 +228,6 @@ class Config extends ConfigBase {
   #applyEnvs (envs, source) {
     for (const [name, value] of Object.entries(envs)) {
       const entry = configurationsTable[name]
-      // TracePropagationStyle is a special case. It is a single option that is used to set both inject and extract.
-      // TODO: Consider what to do with this later
-      if (name === 'DD_TRACE_PROPAGATION_STYLE') {
-        if (
-          getValueFromEnvSources('DD_TRACE_PROPAGATION_STYLE_INJECT') !== undefined ||
-          getValueFromEnvSources('DD_TRACE_PROPAGATION_STYLE_EXTRACT') !== undefined
-        ) {
-          log.warn(
-            // eslint-disable-next-line @stylistic/max-len
-            'Use either DD_TRACE_PROPAGATION_STYLE or separate DD_TRACE_PROPAGATION_STYLE_INJECT and DD_TRACE_PROPAGATION_STYLE_EXTRACT environment variables'
-          )
-          continue
-        }
-        this.#applyEnvs({ DD_TRACE_PROPAGATION_STYLE_INJECT: value, DD_TRACE_PROPAGATION_STYLE_EXTRACT: value }, source)
-        continue
-      }
       const parsed = entry.parser(value, name, source)
       const transformed = parsed !== undefined && entry.transformer ? entry.transformer(parsed, name, source) : parsed
       const rawValue = transformed !== null && typeof transformed === 'object' ? value : parsed
@@ -293,6 +276,7 @@ class Config extends ConfigBase {
         } else {
           if (fullName === 'tracePropagationStyle') {
             // TracePropagationStyle is special. It is a single option that is used to set both inject and extract.
+            // TODO: Consider what to do with this later
             // @ts-expect-error - Difficult to type this correctly.
             this.#applyOptions({ inject: value, extract: value }, source, 'tracePropagationStyle')
           } else {
@@ -374,6 +358,23 @@ class Config extends ConfigBase {
       setAndTrack(this, 'otelMetricsEnabled', false)
     }
 
+    const otelTracesEnabled = trackedConfigOrigins.has('OTEL_TRACES_EXPORTER') &&
+      this.OTEL_TRACES_EXPORTER === 'otlp'
+    if (this.protocolVersion && this.protocolVersion !== '0.4' && otelTracesEnabled) {
+      log.warn('DD_TRACE_AGENT_PROTOCOL_VERSION is set, disabling OTLP traces export')
+      setAndTrack(this, 'otelTracesEnabled', false)
+    } else {
+      setAndTrack(this, 'otelTracesEnabled', otelTracesEnabled)
+    }
+
+    if (this.otelTracesProtocol && this.otelTracesProtocol !== 'http/json') {
+      log.warn(
+        'OTEL_EXPORTER_OTLP_TRACES_PROTOCOL=%s is not yet supported; only http/json is currently implemented',
+        this.otelTracesProtocol
+      )
+      setAndTrack(this, 'otelTracesProtocol', 'http/json')
+    }
+
     if (this.telemetry.heartbeatInterval) {
       setAndTrack(this, 'telemetry.heartbeatInterval', Math.floor(this.telemetry.heartbeatInterval * 1000))
     }
@@ -440,8 +441,16 @@ class Config extends ConfigBase {
       setAndTrack(this, 'runtimeMetrics.enabled', false)
     }
 
-    if (!trackedConfigOrigins.has('sampleRate') && trackedConfigOrigins.has('OTEL_TRACES_SAMPLER')) {
-      setAndTrack(this, 'sampleRate', getFromOtelSamplerMap(this.OTEL_TRACES_SAMPLER, this.OTEL_TRACES_SAMPLER_ARG))
+    if (!trackedConfigOrigins.has('sampleRate')) {
+      const effectiveSampler = (trackedConfigOrigins.has('OTEL_TRACES_EXPORTER') &&
+        this.OTEL_TRACES_EXPORTER === 'otlp' &&
+        !trackedConfigOrigins.has('OTEL_TRACES_SAMPLER'))
+        ? 'parentbased_always_on'
+        : this.OTEL_TRACES_SAMPLER
+      if (effectiveSampler && (trackedConfigOrigins.has('OTEL_TRACES_SAMPLER') ||
+          trackedConfigOrigins.has('OTEL_TRACES_EXPORTER'))) {
+        setAndTrack(this, 'sampleRate', getFromOtelSamplerMap(effectiveSampler, this.OTEL_TRACES_SAMPLER_ARG))
+      }
     }
 
     if (this.DD_SPAN_SAMPLING_RULES_FILE) {
@@ -541,7 +550,10 @@ class Config extends ConfigBase {
         isServiceNameInferred = true
       }
     }
-    setAndTrack(this, 'isServiceNameInferred', isServiceNameInferred)
+
+    // This should not be tracked.
+    // TODO: Consider moving this outside of the config.
+    set(this, 'isServiceNameInferred', isServiceNameInferred)
 
     // Add missing tags, in case they are defined otherwise.
     if (this.service) {
@@ -600,6 +612,13 @@ class Config extends ConfigBase {
     if (!this.otelMetricsUrl) {
       setAndTrack(this, 'otelMetricsUrl', `http://${agentHostname}:${DEFAULT_OTLP_PORT}/v1/metrics`)
     }
+    if (!trackedConfigOrigins.has('otelTracesUrl') && this.OTEL_EXPORTER_OTLP_ENDPOINT) {
+      // Generic OTLP endpoint: per spec, append /v1/traces signal-specific subpath
+      setAndTrack(this, 'otelTracesUrl', this.OTEL_EXPORTER_OTLP_ENDPOINT.replace(/\/$/, '') + '/v1/traces')
+    } else if (!this.otelTracesUrl) {
+      const tracesHostname = agentHostname === '127.0.0.1' ? 'localhost' : agentHostname
+      setAndTrack(this, 'otelTracesUrl', `http://${tracesHostname}:${DEFAULT_OTLP_PORT}/v1/traces`)
+    }
 
     if (process.platform === 'win32') {
       // OOM monitoring does not work properly on Windows, so it will be disabled.
@@ -691,13 +710,25 @@ function increaseCounter (event, ddVar, otelVar) {
 }
 
 function getFromOtelSamplerMap (otelTracesSampler, otelTracesSamplerArg) {
+  const NON_PARENTBASED_TO_PARENTBASED = {
+    always_on: 'parentbased_always_on',
+    always_off: 'parentbased_always_off',
+    traceidratio: 'parentbased_traceidratio',
+  }
   const OTEL_TRACES_SAMPLER_MAPPING = {
-    always_on: 1,
-    always_off: 0,
     parentbased_always_on: 1,
     parentbased_always_off: 0,
   }
 
+  const parentBasedEquivalent = NON_PARENTBASED_TO_PARENTBASED[otelTracesSampler]
+  if (parentBasedEquivalent) {
+    log.info(
+      'OTEL_TRACES_SAMPLER=%s does not respect upstream sampling decisions; using parent-based equivalent %s instead',
+      otelTracesSampler, parentBasedEquivalent
+    )
+    otelTracesSampler = parentBasedEquivalent
+  }
+
   const result = OTEL_TRACES_SAMPLER_MAPPING[otelTracesSampler] ?? otelTracesSamplerArg
   if (result === undefined) {
     increaseCounter('otel.env.invalid', 'DD_TRACE_SAMPLE_RATE', 'OTEL_TRACES_SAMPLER')
@@ -712,7 +743,7 @@ function warnWrongOtelSettings () {
     // eslint-disable-next-line eslint-rules/eslint-env-aliases
     ['OTEL_LOG_LEVEL', 'DD_TRACE_LOG_LEVEL', 'logLevel'],
     // eslint-disable-next-line eslint-rules/eslint-env-aliases
-    ['OTEL_PROPAGATORS', 'DD_TRACE_PROPAGATION_STYLE'],
+    ['OTEL_PROPAGATORS', 'DD_TRACE_PROPAGATION_STYLE', 'DD_TRACE_PROPAGATION_STYLE'],
     // eslint-disable-next-line eslint-rules/eslint-env-aliases
     ['OTEL_SERVICE_NAME', 'DD_SERVICE', 'service'],
     ['OTEL_TRACES_SAMPLER', 'DD_TRACE_SAMPLE_RATE'],
@@ -733,11 +764,7 @@ function warnWrongOtelSettings () {
         increaseCounter('otel.env.hiding', ddEnvVar, otelEnvVar)
       }
 
-      // eslint-disable-next-line eslint-rules/eslint-env-aliases
-      const invalidOtelValue = otelEnvVar === 'OTEL_PROPAGATORS'
-        ? trackedConfigOrigins.get(/** @type {ConfigPath} */ ('tracePropagationStyle.inject')) !== otelSource &&
-          !envs[ddEnvVar]
-        : !otelSource
+      const invalidOtelValue = !otelSource
       if (invalidOtelValue) {
         increaseCounter('otel.env.invalid', ddEnvVar, otelEnvVar)
       }

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

@@ -46,12 +46,12 @@
     ],
     "DD_AI_GUARD_BLOCK": [
       {
-        "implementation": "B",
+        "implementation": "C",
         "type": "boolean",
         "configurationNames": [
           "experimental.aiguard.block"
         ],
-        "default": "false"
+        "default": "true"
       }
     ],
     "DD_AI_GUARD_ENABLED": [
@@ -1573,6 +1573,16 @@
         "default": "10000"
       }
     ],
+    "DD_RUNTIME_METRICS_NATIVE": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "configurationNames": [
+          "runtimeMetrics.native"
+        ],
+        "default": "true"
+      }
+    ],
     "DD_RUNTIME_METRICS_GC_ENABLED": [
       {
         "implementation": "A",
@@ -3442,7 +3452,10 @@
           "tracePropagationStyle.extract"
         ],
         "default": "datadog, tracecontext, baggage",
-        "transform": "toLowerCase"
+        "transform": "toLowerCase",
+        "aliases": [
+          "DD_TRACE_PROPAGATION_STYLE"
+        ]
       }
     ],
     "DD_TRACE_PROPAGATION_STYLE_INJECT": [
@@ -3453,7 +3466,10 @@
           "tracePropagationStyle.inject"
         ],
         "default": "datadog, tracecontext, baggage",
-        "transform": "toLowerCase"
+        "transform": "toLowerCase",
+        "aliases": [
+          "DD_TRACE_PROPAGATION_STYLE"
+        ]
       }
     ],
     "DD_TRACE_PROTOBUFJS_ENABLED": [
@@ -3886,6 +3902,47 @@
         "internalPropertyName": "otelHeaders"
       }
     ],
+    "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT": [
+      {
+        "implementation": "A",
+        "type": "string",
+        "default": null,
+        "internalPropertyName": "otelTracesUrl"
+      }
+    ],
+    "OTEL_EXPORTER_OTLP_TRACES_HEADERS": [
+      {
+        "implementation": "B",
+        "type": "map",
+        "default": null,
+        "internalPropertyName": "otelTracesHeaders",
+        "aliases": [
+          "OTEL_EXPORTER_OTLP_HEADERS"
+        ]
+      }
+    ],
+    "OTEL_EXPORTER_OTLP_TRACES_PROTOCOL": [
+      {
+        "implementation": "B",
+        "type": "string",
+        "default": "http/json",
+        "internalPropertyName": "otelTracesProtocol",
+        "aliases": [
+          "OTEL_EXPORTER_OTLP_PROTOCOL"
+        ]
+      }
+    ],
+    "OTEL_EXPORTER_OTLP_TRACES_TIMEOUT": [
+      {
+        "implementation": "B",
+        "type": "int",
+        "internalPropertyName": "otelTracesTimeout",
+        "default": "10000",
+        "aliases": [
+          "OTEL_EXPORTER_OTLP_TIMEOUT"
+        ]
+      }
+    ],
     "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT": [
       {
         "implementation": "A",

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

@@ -21,6 +21,7 @@ module.exports = {
   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',
+  SVC_SRC_KEY: '_dd.svc_src',
   DATADOG_LAMBDA_EXTENSION_PATH: '/opt/extensions/datadog-agent',
   DATADOG_MINI_AGENT_PATH: '/tmp/datadog/mini_agent_ready',
   DECISION_MAKER_KEY: '_dd.p.dm',

package/packages/dd-trace/src/debugger/devtools_client/snapshot/processor.js

@@ -105,10 +105,13 @@ function getObjectValue (obj, maxLength) {
     // case 'node': // TODO: What does this subtype represent?
     case 'regexp':
       return { type: obj.className, value: obj.description }
-    case 'date':
+    case 'date': {
       // TODO: This looses millisecond resolution, as that's not retained in the `.toString()` representation contained
       // in the `description` field. Unfortunately that's all we get from the Chrome DevTools Protocol.
-      return { type: obj.className, value: `${new Date(obj.description).toISOString().slice(0, -5)}Z` }
+      const date = new Date(obj.description)
+      const value = Number.isNaN(date.getTime()) ? obj.description : `${date.toISOString().slice(0, -5)}Z`
+      return { type: obj.className, value }
+    }
     case 'map':
       return toMap(obj.className, obj.properties, maxLength, timeBudgetReached)
     case 'set':

package/packages/dd-trace/src/encode/0.4.js

@@ -3,7 +3,6 @@
 const { MsgpackChunk, MsgpackEncoder } = require('../msgpack')
 const log = require('../log')
 const { isTrue } = require('../util')
-const { memoize } = require('../log/utils')
 const { getValueFromEnvSources } = require('../config/helper')
 const { truncateSpan, normalizeSpan } = require('./tags-processors')
 
@@ -338,11 +337,13 @@ class AgentEncoder {
   }
 }
 
-const memoizedLogDebug = memoize((key, message) => {
-  log.debug(message)
-  // return something to store in memoize cache
-  return true
-})
+const seenKeys = new Set()
+const memoizedLogDebug = (key, message) => {
+  if (!seenKeys.has(key)) {
+    seenKeys.add(key)
+    log.debug(message)
+  }
+}
 
 function formatSpanEvents (span) {
   for (const spanEvent of span.span_events) {

package/packages/dd-trace/src/encode/span-stats.js

@@ -31,7 +31,7 @@ class SpanStatsEncoder extends AgentEncoder {
   }
 
   _encodeStat (bytes, stat) {
-    this._encodeMapPrefix(bytes, 14)
+    this._encodeMapPrefix(bytes, 15)
 
     this._encodeString(bytes, 'Service')
     const service = stat.Service || DEFAULT_SERVICE_NAME
@@ -76,6 +76,9 @@ class SpanStatsEncoder extends AgentEncoder {
 
     this._encodeString(bytes, 'HTTPEndpoint')
     this._encodeString(bytes, stat.HTTPEndpoint)
+
+    this._encodeString(bytes, 'srv_src')
+    this._encodeString(bytes, stat.srv_src || '')
   }
 
   _encodeBucket (bytes, bucket) {

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

@@ -8,7 +8,6 @@ const { getValueFromEnvSources } = require('../config/helper')
 const { traceChannel, debugChannel, infoChannel, warnChannel, errorChannel } = require('./channels')
 const logWriter = require('./writer')
 const { Log, LogConfig, NoTransmitError } = require('./log')
-const { memoize } = require('./utils')
 
 const config = {
   enabled: defaults.DD_TRACE_DEBUG,
@@ -16,11 +15,6 @@ const config = {
   logLevel: defaults.logLevel,
 }
 
-const deprecate = memoize((code, message) => {
-  publishFormatted(errorChannel, null, message)
-  return true
-})
-
 // In most places where we know we want to mute a log we use log.error() directly
 const NO_TRANSMIT = new LogConfig(false)
 
@@ -82,10 +76,6 @@ const log = {
     return log
   },
 
-  deprecate (code, message) {
-    return deprecate(code, message)
-  },
-
   configure (options) {
     config.logger = options.logger
     config.logLevel = options.logLevel ??

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

@@ -19,9 +19,14 @@ function enable (rc, config, getOpenfeatureProxy) {
 
   // Set product handler for FFE_FLAGS
   rc.setProductHandler('FFE_FLAGS', (action, conf) => {
-    // Feed UFC config directly to OpenFeature provider
     if (action === 'apply' || action === 'modify') {
+      // Feed UFC config directly to OpenFeature provider
       getOpenfeatureProxy()._setConfiguration(conf)
+    } else if (action === 'unapply') {
+      // Clear the configuration so evaluations return PROVIDER_NOT_READY,
+      // consistent with Go and Python which also set config to null on RC deletion.
+      // The evaluator returns PROVIDER_NOT_READY when config is null/undefined.
+      getOpenfeatureProxy()._setConfiguration(null)
     }
   })
 }