dd-trace 5.49.0 → 5.50.0

package/packages/dd-trace/src/debugger/devtools_client/breakpoints.js

@@ -1,7 +1,7 @@
 'use strict'
 
+const lock = require('mutexify/promise')()
 const { getGeneratedPosition } = require('./source-maps')
-const lock = require('./lock')()
 const session = require('./session')
 const { compile: compileCondition, compileSegments, templateRequiresEvaluation } = require('./condition')
 const { MAX_SNAPSHOTS_PER_SECOND_PER_PROBE, MAX_NON_SNAPSHOTS_PER_SECOND_PER_PROBE } = require('./defaults')
@@ -64,14 +64,14 @@ async function addBreakpoint (probe) {
   const release = await lock()
 
   try {
-    log.debug(
-      '[debugger:devtools_client] Adding breakpoint at %s:%d:%d (probe: %s, version: %d)',
-      url, lineNumber, columnNumber, probe.id, probe.version
-    )
-
     const locationKey = generateLocationKey(scriptId, lineNumber, columnNumber)
     const breakpoint = locationToBreakpoint.get(locationKey)
 
+    log.debug(
+      '[debugger:devtools_client] %s breakpoint at %s:%d:%d (probe: %s, version: %d)',
+      breakpoint ? 'Updating' : 'Adding', url, lineNumber, columnNumber, probe.id, probe.version
+    )
+
     if (breakpoint) {
       // A breakpoint already exists at this location, so we need to add the probe to the existing breakpoint
       await updateBreakpoint(breakpoint, probe)
@@ -82,10 +82,15 @@ async function addBreakpoint (probe) {
         lineNumber: lineNumber - 1, // Beware! lineNumber is zero-indexed
         columnNumber
       }
-      const result = await session.post('Debugger.setBreakpoint', {
-        location,
-        condition: probe.condition
-      })
+      let result
+      try {
+        result = await session.post('Debugger.setBreakpoint', {
+          location,
+          condition: probe.condition
+        })
+      } catch (err) {
+        throw new Error(`Error setting breakpoint for probe ${probe.id}`, { cause: err })
+      }
       probeToLocation.set(probe.id, locationKey)
       locationToBreakpoint.set(locationKey, { id: result.breakpointId, location, locationKey })
       breakpointToProbes.set(result.breakpointId, new Map([[probe.id, probe]]))
@@ -120,7 +125,11 @@ async function removeBreakpoint ({ id }) {
       if (breakpointToProbes.size === 0) {
         await stop() // TODO: Will this actually delete the breakpoint?
       } else {
-        await session.post('Debugger.removeBreakpoint', { breakpointId: breakpoint.id })
+        try {
+          await session.post('Debugger.removeBreakpoint', { breakpointId: breakpoint.id })
+        } catch (err) {
+          throw new Error(`Error removing breakpoint for probe ${id}`, { cause: err })
+        }
       }
     } else {
       await updateBreakpoint(breakpoint)
@@ -144,12 +153,21 @@ async function updateBreakpoint (breakpoint, probe) {
   const condition = compileCompoundCondition(Array.from(probesAtLocation.values()))
 
   if (condition || conditionBeforeNewProbe !== condition) {
-    await session.post('Debugger.removeBreakpoint', { breakpointId: breakpoint.id })
+    try {
+      await session.post('Debugger.removeBreakpoint', { breakpointId: breakpoint.id })
+    } catch (err) {
+      throw new Error(`Error removing breakpoint for probe ${probe.id}`, { cause: err })
+    }
     breakpointToProbes.delete(breakpoint.id)
-    const result = await session.post('Debugger.setBreakpoint', {
-      location: breakpoint.location,
-      condition
-    })
+    let result
+    try {
+      result = await session.post('Debugger.setBreakpoint', {
+        location: breakpoint.location,
+        condition
+      })
+    } catch (err) {
+      throw new Error(`Error setting breakpoint for probe ${probe.id}`, { cause: err })
+    }
     breakpoint.id = result.breakpointId
     breakpointToProbes.set(result.breakpointId, probesAtLocation)
   }

package/packages/dd-trace/src/debugger/devtools_client/remote_config.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { workerData: { rcPort } } = require('node:worker_threads')
-const lock = require('./lock')()
+const lock = require('mutexify/promise')()
 const { addBreakpoint, removeBreakpoint } = require('./breakpoints')
 const { ackReceived, ackInstalled, ackError } = require('./status')
 const log = require('../../log')

package/packages/dd-trace/src/debugger/devtools_client/send.js

@@ -26,7 +26,7 @@ const ddtags = [
   ['host_name', hostname],
   [GIT_COMMIT_SHA, config.commitSHA],
   [GIT_REPOSITORY_URL, config.repositoryUrl]
-].map((pair) => pair.join(':')).join(',')
+].filter(([, value]) => value !== undefined).map((pair) => pair.join(':')).join(',')
 
 const path = `/debugger/v1/input?${stringify({ ddtags })}`
 

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

@@ -308,12 +308,16 @@ class MetricsAggregationClient {
     }
 
     for (const [tag, next] of node.nodes) {
-      this._captureNode(next, name, tags.concat(tag), fn)
+      tags.push(tag)
+      this._captureNode(next, name, tags, fn)
+      tags.pop()
     }
   }
 
-  _ensureTree (tree, name, tags, value) {
-    tags = tags ? [].concat(tags) : []
+  _ensureTree (tree, name, tags = [], value) {
+    if (!Array.isArray(tags)) {
+      tags = [tags]
+    }
 
     let node = this._ensureNode(tree, name, value)
 
@@ -331,7 +335,10 @@ class MetricsAggregationClient {
 
     if (!node) {
       node = { nodes: new Map(), touched: false, value }
-      container.set(key, node)
+
+      if (typeof key === 'string') {
+        container.set(key, node)
+      }
     }
 
     return node

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

@@ -4,9 +4,9 @@ const log = require('../log')
 const { PROPAGATED_PARENT_ID_KEY } = require('./constants/tags')
 const { storage } = require('./storage')
 
+const telemetry = require('./telemetry')
 const LLMObsSpanProcessor = require('./span_processor')
 
-const telemetry = require('./telemetry')
 const { channel } = require('dc-polyfill')
 const spanProcessCh = channel('dd-trace:span:process')
 const evalMetricAppendCh = channel('llmobs:eval-metric:append')
@@ -94,12 +94,15 @@ function handleLLMObsParentIdInjection ({ carrier }) {
 }
 
 function handleFlush () {
+  let err = ''
   try {
     spanWriter.flush()
     evalWriter.flush()
   } catch (e) {
+    err = 'writer_flush_error'
     log.warn(`Failed to flush LLMObs spans and evaluation metrics: ${e.message}`)
   }
+  telemetry.recordUserFlush(err)
 }
 
 function handleSpanProcess (data) {

package/packages/dd-trace/src/llmobs/sdk.js

@@ -201,7 +201,7 @@ class LLMObs extends NoopLLMObs {
     return this._tracer.wrap(name, spanOptions, wrapped)
   }
 
-  annotate (span, options) {
+  annotate (span, options, autoinstrumented = false) {
     if (!this.enabled) return
 
     if (!span) {
@@ -213,150 +213,184 @@ class LLMObs extends NoopLLMObs {
       span = this._active()
     }
 
-    if (!span) {
-      throw new Error('No span provided and no active LLMObs-generated span found')
-    }
-    if (!options) {
-      throw new Error('No options provided for annotation.')
-    }
+    let err = ''
 
-    if (!LLMObsTagger.tagMap.has(span)) {
-      throw new Error('Span must be an LLMObs-generated span')
-    }
-    if (span._duration !== undefined) {
-      throw new Error('Cannot annotate a finished span')
-    }
+    try {
+      if (!span) {
+        err = 'invalid_span_no_active_spans'
+        throw new Error('No span provided and no active LLMObs-generated span found')
+      }
+      if (!options) {
+        err = 'invalid_options'
+        throw new Error('No options provided for annotation.')
+      }
 
-    const spanKind = LLMObsTagger.tagMap.get(span)[SPAN_KIND]
-    if (!spanKind) {
-      throw new Error('LLMObs span must have a span kind specified')
-    }
+      if (!LLMObsTagger.tagMap.has(span)) {
+        err = 'invalid_span_type'
+        throw new Error('Span must be an LLMObs-generated span')
+      }
+      if (span._duration !== undefined) {
+        err = 'invalid_finished_span'
+        throw new Error('Cannot annotate a finished span')
+      }
 
-    const { inputData, outputData, metadata, metrics, tags } = options
-
-    if (inputData || outputData) {
-      if (spanKind === 'llm') {
-        this._tagger.tagLLMIO(span, inputData, outputData)
-      } else if (spanKind === 'embedding') {
-        this._tagger.tagEmbeddingIO(span, inputData, outputData)
-      } else if (spanKind === 'retrieval') {
-        this._tagger.tagRetrievalIO(span, inputData, outputData)
-      } else {
-        this._tagger.tagTextIO(span, inputData, outputData)
+      const spanKind = LLMObsTagger.tagMap.get(span)[SPAN_KIND]
+      if (!spanKind) {
+        err = 'invalid_no_span_kind'
+        throw new Error('LLMObs span must have a span kind specified')
       }
-    }
 
-    if (metadata) {
-      this._tagger.tagMetadata(span, metadata)
-    }
+      const { inputData, outputData, metadata, metrics, tags } = options
 
-    if (metrics) {
-      this._tagger.tagMetrics(span, metrics)
-    }
+      if (inputData || outputData) {
+        if (spanKind === 'llm') {
+          this._tagger.tagLLMIO(span, inputData, outputData)
+        } else if (spanKind === 'embedding') {
+          this._tagger.tagEmbeddingIO(span, inputData, outputData)
+        } else if (spanKind === 'retrieval') {
+          this._tagger.tagRetrievalIO(span, inputData, outputData)
+        } else {
+          this._tagger.tagTextIO(span, inputData, outputData)
+        }
+      }
 
-    if (tags) {
-      this._tagger.tagSpanTags(span, tags)
+      if (metadata) {
+        this._tagger.tagMetadata(span, metadata)
+      }
+      if (metrics) {
+        this._tagger.tagMetrics(span, metrics)
+      }
+      if (tags) {
+        this._tagger.tagSpanTags(span, tags)
+      }
+    } catch (e) {
+      if (e.ddErrorTag) {
+        err = e.ddErrorTag
+      }
+      throw e
+    } finally {
+      if (autoinstrumented === false) {
+        telemetry.recordLLMObsAnnotate(span, err)
+      }
     }
   }
 
   exportSpan (span) {
     span = span || this._active()
-
-    if (!span) {
-      throw new Error('No span provided and no active LLMObs-generated span found')
-    }
-
-    if (!(span instanceof Span)) {
-      throw new Error('Span must be a valid Span object.')
-    }
-
-    if (!LLMObsTagger.tagMap.has(span)) {
-      throw new Error('Span must be an LLMObs-generated span')
+    let err = ''
+    try {
+      if (!span) {
+        err = 'no_active_span'
+        throw new Error('No span provided and no active LLMObs-generated span found')
+      }
+      if (!(span instanceof Span)) {
+        err = 'invalid_span'
+        throw new Error('Span must be a valid Span object.')
+      }
+      if (!LLMObsTagger.tagMap.has(span)) {
+        err = 'invalid_span'
+        throw new Error('Span must be an LLMObs-generated span')
+      }
+    } catch (e) {
+      telemetry.recordExportSpan(span, err)
+      throw e
     }
-
     try {
       return {
         traceId: span.context().toTraceId(true),
         spanId: span.context().toSpanId()
       }
     } catch {
-      logger.warn('Faild to export span. Span must be a valid Span object.')
+      err = 'invalid_span'
+      logger.warn('Failed to export span. Span must be a valid Span object.')
+    } finally {
+      telemetry.recordExportSpan(span, err)
     }
   }
 
   submitEvaluation (llmobsSpanContext, options = {}) {
     if (!this.enabled) return
 
+    let err = ''
     const { traceId, spanId } = llmobsSpanContext
-    if (!traceId || !spanId) {
-      throw new Error(
-        'spanId and traceId must both be specified for the given evaluation metric to be submitted.'
-      )
-    }
-
-    const mlApp = options.mlApp || this._config.llmobs.mlApp
-    if (!mlApp) {
-      throw new Error(
-        'ML App name is required for sending evaluation metrics. Evaluation metric data will not be sent.'
-      )
-    }
-
-    const timestampMs = options.timestampMs || Date.now()
-    if (typeof timestampMs !== 'number' || timestampMs < 0) {
-      throw new Error('timestampMs must be a non-negative integer. Evaluation metric data will not be sent')
-    }
+    try {
+      if (!traceId || !spanId) {
+        err = 'invalid_span'
+        throw new Error(
+          'spanId and traceId must both be specified for the given evaluation metric to be submitted.'
+        )
+      }
+      const mlApp = options.mlApp || this._config.llmobs.mlApp
+      if (!mlApp) {
+        err = 'missing_ml_app'
+        throw new Error(
+          'ML App name is required for sending evaluation metrics. Evaluation metric data will not be sent.'
+        )
+      }
 
-    const { label, value, tags } = options
-    const metricType = options.metricType?.toLowerCase()
-    if (!label) {
-      throw new Error('label must be the specified name of the evaluation metric')
-    }
-    if (!metricType || !['categorical', 'score'].includes(metricType)) {
-      throw new Error('metricType must be one of "categorical" or "score"')
-    }
+      const timestampMs = options.timestampMs || Date.now()
+      if (typeof timestampMs !== 'number' || timestampMs < 0) {
+        err = 'invalid_timestamp'
+        throw new Error('timestampMs must be a non-negative integer. Evaluation metric data will not be sent')
+      }
 
-    if (metricType === 'categorical' && typeof value !== 'string') {
-      throw new Error('value must be a string for a categorical metric.')
-    }
-    if (metricType === 'score' && typeof value !== 'number') {
-      throw new Error('value must be a number for a score metric.')
-    }
+      const { label, value, tags } = options
+      const metricType = options.metricType?.toLowerCase()
+      if (!label) {
+        err = 'invalid_metric_label'
+        throw new Error('label must be the specified name of the evaluation metric')
+      }
+      if (!metricType || !['categorical', 'score'].includes(metricType)) {
+        err = 'invalid_metric_type'
+        throw new Error('metricType must be one of "categorical" or "score"')
+      }
+      if (metricType === 'categorical' && typeof value !== 'string') {
+        err = 'invalid_metric_value'
+        throw new Error('value must be a string for a categorical metric.')
+      }
+      if (metricType === 'score' && typeof value !== 'number') {
+        err = 'invalid_metric_value'
+        throw new Error('value must be a number for a score metric.')
+      }
 
-    const evaluationTags = {
-      'ddtrace.version': tracerVersion,
-      ml_app: mlApp
-    }
+      const evaluationTags = {
+        'ddtrace.version': tracerVersion,
+        ml_app: mlApp
+      }
 
-    if (tags) {
-      for (const key in tags) {
-        const tag = tags[key]
-        if (typeof tag === 'string') {
-          evaluationTags[key] = tag
-        } else if (typeof tag.toString === 'function') {
-          evaluationTags[key] = tag.toString()
-        } else if (tag == null) {
-          evaluationTags[key] = Object.prototype.toString.call(tag)
-        } else {
-          // should be a rare case
-          // every object in JS has a toString, otherwise every primitive has its own toString
-          // null and undefined are handled above
-          throw new Error('Failed to parse tags. Tags for evaluation metrics must be strings')
+      if (tags) {
+        for (const key in tags) {
+          const tag = tags[key]
+          if (typeof tag === 'string') {
+            evaluationTags[key] = tag
+          } else if (typeof tag.toString === 'function') {
+            evaluationTags[key] = tag.toString()
+          } else if (tag == null) {
+            evaluationTags[key] = Object.prototype.toString.call(tag)
+          } else {
+            // should be a rare case
+            // every object in JS has a toString, otherwise every primitive has its own toString
+            // null and undefined are handled above
+            err = 'invalid_tags'
+            throw new Error('Failed to parse tags. Tags for evaluation metrics must be strings')
+          }
         }
       }
-    }
 
-    const payload = {
-      span_id: spanId,
-      trace_id: traceId,
-      label,
-      metric_type: metricType,
-      ml_app: mlApp,
-      [`${metricType}_value`]: value,
-      timestamp_ms: timestampMs,
-      tags: Object.entries(evaluationTags).map(([key, value]) => `${key}:${value}`)
+      const payload = {
+        span_id: spanId,
+        trace_id: traceId,
+        label,
+        metric_type: metricType,
+        ml_app: mlApp,
+        [`${metricType}_value`]: value,
+        timestamp_ms: timestampMs,
+        tags: Object.entries(evaluationTags).map(([key, value]) => `${key}:${value}`)
+      }
+      evalMetricAppendCh.publish(payload)
+    } finally {
+      telemetry.recordSubmitEvaluation(options, err)
     }
-
-    evalMetricAppendCh.publish(payload)
   }
 
   flush () {
@@ -375,7 +409,7 @@ class LLMObs extends NoopLLMObs {
       annotations.outputData = output
     }
 
-    this.annotate(span, annotations)
+    this.annotate(span, annotations, true)
   }
 
   _active () {

package/packages/dd-trace/src/llmobs/tagger.js

@@ -135,7 +135,7 @@ class LLMObsTagger {
       if (typeof value === 'number') {
         filterdMetrics[processedKey] = value
       } else {
-        this._handleFailure(`Value for metric '${key}' must be a number, instead got ${value}`)
+        this._handleFailure(`Value for metric '${key}' must be a number, instead got ${value}`, 'invalid_metrics')
       }
     }
 
@@ -169,7 +169,7 @@ class LLMObsTagger {
           this._setTag(span, key, JSON.stringify(data))
         } catch {
           const type = key === INPUT_VALUE ? 'input' : 'output'
-          this._handleFailure(`Failed to parse ${type} value, must be JSON serializable.`)
+          this._handleFailure(`Failed to parse ${type} value, must be JSON serializable.`, 'invalid_io_text')
         }
       }
     }
@@ -187,7 +187,7 @@ class LLMObsTagger {
         }
 
         if (document == null || typeof document !== 'object') {
-          this._handleFailure('Documents must be a string, object, or list of objects.')
+          this._handleFailure('Documents must be a string, object, or list of objects.', 'invalid_embedding_io')
           return undefined
         }
 
@@ -195,7 +195,7 @@ class LLMObsTagger {
         let validDocument = true
 
         if (typeof text !== 'string') {
-          this._handleFailure('Document text must be a string.')
+          this._handleFailure('Document text must be a string.', 'invalid_embedding_io')
           validDocument = false
         }
 
@@ -226,7 +226,7 @@ class LLMObsTagger {
         }
 
         if (message == null || typeof message !== 'object') {
-          this._handleFailure('Messages must be a string, object, or list of objects')
+          this._handleFailure('Messages must be a string, object, or list of objects', 'invalid_io_messages')
           return undefined
         }
 
@@ -237,7 +237,7 @@ class LLMObsTagger {
         const messageObj = { content }
 
         if (typeof content !== 'string') {
-          this._handleFailure('Message content must be a string.')
+          this._handleFailure('Message content must be a string.', 'invalid_io_messages')
           validMessage = false
         }
 
@@ -250,7 +250,7 @@ class LLMObsTagger {
 
           const filteredToolCalls = toolCalls.map(toolCall => {
             if (typeof toolCall !== 'object') {
-              this._handleFailure('Tool call must be an object.')
+              this._handleFailure('Tool call must be an object.', 'invalid_io_messages')
               return undefined
             }
 
@@ -313,11 +313,15 @@ class LLMObsTagger {
 
   // any public-facing LLMObs APIs using this tagger should not soft fail
   // auto-instrumentation should soft fail
-  _handleFailure (msg) {
+  _handleFailure (msg, errorTag) {
     if (this.softFail) {
       log.warn(msg)
     } else {
-      throw new Error(msg)
+      const err = new Error(msg)
+      if (errorTag) {
+        Object.defineProperty(err, 'ddErrorTag', { get () { return errorTag } })
+      }
+      throw err
     }
   }
 

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

@@ -109,11 +109,60 @@ function recordDroppedPayload (numEvents, eventType, error) {
   llmobsMetrics.count(metricName, tags).inc(numEvents)
 }
 
+function recordLLMObsAnnotate (span, err, value = 1) {
+  const mlObsTags = LLMObsTagger.tagMap.get(span) || {}
+  const spanKind = mlObsTags[SPAN_KIND] || 'N/A'
+  const isRootSpan = mlObsTags[PARENT_ID_KEY] === ROOT_PARENT_ID
+
+  const tags = {
+    error: Number(!!err),
+    span_kind: spanKind,
+    is_root_span: Number(isRootSpan)
+  }
+  if (err) tags.error_type = err
+  llmobsMetrics.count('annotations', tags).inc(value)
+}
+
+function recordUserFlush (err, value = 1) {
+  const tags = { error: Number(!!err) }
+  if (err) tags.error_type = err
+  llmobsMetrics.count('user_flush', tags).inc(value)
+}
+
+function recordExportSpan (span, err, value = 1) {
+  const mlObsTags = LLMObsTagger.tagMap.get(span) || {}
+  const spanKind = mlObsTags[SPAN_KIND] || 'N/A'
+  const isRootSpan = mlObsTags[PARENT_ID_KEY] === ROOT_PARENT_ID
+
+  const tags = {
+    error: Number(!!err),
+    span_kind: spanKind,
+    is_root_span: Number(isRootSpan)
+  }
+  if (err) tags.error_type = err
+  llmobsMetrics.count('spans_exported', tags).inc(value)
+}
+
+function recordSubmitEvaluation (options, err, value = 1) {
+  const tags = {
+    error: Number(!!err),
+    custom_joining_key: 0
+  }
+  const metricType = options?.metricType?.toLowerCase()
+  if (metricType !== 'categorical' && metricType !== 'score') tags.metric_type = 'other'
+  if (err) tags.error_type = err
+  llmobsMetrics.count('evals_submitted', tags).inc(value)
+}
+
 module.exports = {
   recordLLMObsEnabled,
   incrementLLMObsSpanStartCount,
   incrementLLMObsSpanFinishedCount,
   recordLLMObsRawSpanSize,
   recordLLMObsSpanSize,
-  recordDroppedPayload
+  recordDroppedPayload,
+  recordLLMObsAnnotate,
+  recordUserFlush,
+  recordExportSpan,
+  recordSubmitEvaluation
 }

package/packages/dd-trace/src/payload-tagging/jsonpath-plus.js

@@ -1694,7 +1694,7 @@ JSONPath.prototype._handleCallback = function (fullRetObj, callback, type) {
  * @param {string} parentPropName
  * @param {JSONPathCallback} callback
  * @param {boolean} hasArrExpr
- * @param {boolean} literalPriority
+ * @param {boolean} [literalPriority]
  * @returns {ReturnObject|ReturnObject[]}
  */
 JSONPath.prototype._trace = function (expr, val, path, parent, parentPropName, callback, hasArrExpr, literalPriority) {

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

@@ -15,7 +15,6 @@ const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('../plugins/util/tags')
 const { tagger } = require('./tagger')
 const { isFalse, isTrue } = require('../util')
 const { getAzureTagsFromMetadata, getAzureAppMetadata } = require('../azure_metadata')
-const satisfies = require('semifies')
 
 class Config {
   constructor (options = {}) {
@@ -23,7 +22,6 @@ class Config {
       DD_AGENT_HOST,
       DD_ENV,
       DD_INTERNAL_PROFILING_TIMELINE_SAMPLING_ENABLED, // used for testing
-      DD_PROFILING_ASYNC_ID_ENABLED,
       DD_PROFILING_CODEHOTSPOTS_ENABLED,
       DD_PROFILING_CPU_ENABLED,
       DD_PROFILING_DEBUG_SOURCE_MAPS,
@@ -181,10 +179,6 @@ class Config {
     this.timelineSamplingEnabled = isTrue(coalesce(options.timelineSamplingEnabled,
       DD_INTERNAL_PROFILING_TIMELINE_SAMPLING_ENABLED, true))
 
-    // Async ID gathering only works reliably on Node >= 22.10.0
-    this.asyncIdEnabled = isTrue(coalesce(options.asyncIdEnabled,
-      DD_PROFILING_ASYNC_ID_ENABLED, this.timelineEnabled && satisfies(process.versions.node, '>=22.10.0')))
-
     this.codeHotspotsEnabled = isTrue(coalesce(options.codeHotspotsEnabled,
       DD_PROFILING_CODEHOTSPOTS_ENABLED,
       DD_PROFILING_EXPERIMENTAL_CODEHOTSPOTS_ENABLED, samplingContextsAvailable))