dd-trace 5.109.0 → 5.110.0

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

@@ -8,16 +8,47 @@ const version = require('../../../../../package.json').version
 const { availableParallelism, libuvThreadPoolSize } = require('../libuv-size')
 const processTags = require('../../process-tags')
 
+/** @typedef {import('../../config/config-base')} TracerConfig */
+
+/**
+ * Maps the canonical profiling.enabled value to the activation reported in the
+ * profile event.
+ *
+ * @param {string} [enabled] - config.profiling.enabled ('true' | 'false' | 'auto')
+ * @returns {string}
+ */
+function getActivation (enabled) {
+  if (enabled === 'auto') return 'auto'
+  if (enabled === 'true') return 'manual'
+  return 'unknown'
+}
+
 class EventSerializer {
-  constructor ({ env, host, service, version, libraryInjected, activation } = {}) {
-    this._env = env
-    this._host = host
-    this._service = service
-    this._appVersion = version
-    this._libraryInjected = libraryInjected
-    this._activation = activation || 'unknown'
+  #activation
+  #appVersion
+  #env
+  #host
+  #libraryInjected
+  #service
+
+  /** @param {TracerConfig} config */
+  constructor (config) {
+    this.#env = config.env
+    this.#host = config.reportHostname ? os.hostname() : undefined
+    this.#service = config.service
+    this.#appVersion = config.version
+    this.#libraryInjected = !!config.DD_INJECTION_ENABLED
+    this.#activation = getActivation(config.profiling?.enabled)
   }
 
+  /**
+   * Returns the destination URL for the near-OOM export subprocess, or nothing when this exporter
+   * does not support OOM export. Overridden by {@link AgentExporter} and {@link FileExporter}.
+   *
+   * @returns {URL | undefined}
+   */
+  getExportUrl () {}
+
   typeToFile (type) {
     return `${type}.pprof`
   }
@@ -43,21 +74,21 @@ class EventSerializer {
       endpoint_counts: endpointCounts,
       info: {
         application: {
-          env: this._env,
-          service: this._service,
+          env: this.#env,
+          service: this.#service,
           start_time: new Date(perf.nodeTiming.nodeStart + perf.timeOrigin).toISOString(),
-          version: this._appVersion,
+          version: this.#appVersion,
         },
         platform: {
-          hostname: this._host,
+          hostname: this.#host,
           kernel_name: os.type(),
           kernel_release: os.release(),
           kernel_version: os.version(),
         },
         profiler: {
-          activation: this._activation,
+          activation: this.#activation,
           ssi: {
-            mechanism: this._libraryInjected ? 'injected_agent' : 'none',
+            mechanism: this.#libraryInjected ? 'injected_agent' : 'none',
           },
           version,
           ...infos,
@@ -92,4 +123,4 @@ class EventSerializer {
   }
 }
 
-module.exports = { EventSerializer }
+module.exports = { EventSerializer, getActivation }

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

@@ -2,6 +2,7 @@
 
 const fs = require('fs')
 const { promisify } = require('util')
+const { pathToFileURL } = require('url')
 const { threadId } = require('worker_threads')
 const writeFile = promisify(fs.writeFile)
 const { EventSerializer } = require('./event_serializer')
@@ -10,14 +11,24 @@ const pad = (n) => String(n).padStart(2, '0')
 
 function formatDateTime (t) {
   return `${t.getUTCFullYear()}${pad(t.getUTCMonth() + 1)}${pad(t.getUTCDate())}` +
-         `T${pad(t.getUTCHours())}${pad(t.getUTCMinutes())}${pad(t.getUTCSeconds())}Z`
+    `T${pad(t.getUTCHours())}${pad(t.getUTCMinutes())}${pad(t.getUTCSeconds())}Z`
 }
 
 class FileExporter extends EventSerializer {
-  constructor (config = {}) {
+  #pprofPrefix
+
+  /**
+   * @param {import('./event_serializer').TracerConfig} config
+   * @param {string} [pprofPrefix] - File path prefix. Defaults to the config value, but the OOM
+   *   export subprocess passes a path derived from a `file:` URL, which is not a config value.
+   */
+  constructor (config, pprofPrefix = config.DD_PROFILING_PPROF_PREFIX) {
     super(config)
-    const { pprofPrefix } = config
-    this._pprofPrefix = pprofPrefix || ''
+    this.#pprofPrefix = pprofPrefix
+  }
+
+  getExportUrl () {
+    return pathToFileURL(this.#pprofPrefix)
   }
 
   export (exportSpec) {
@@ -25,7 +36,7 @@ class FileExporter extends EventSerializer {
     const types = Object.keys(profiles)
     const dateStr = formatDateTime(end)
     const tasks = types.map(type => {
-      return writeFile(`${this._pprofPrefix}${type}_worker_${threadId}_${dateStr}.pprof`, profiles[type])
+      return writeFile(`${this.#pprofPrefix}${type}_worker_${threadId}_${dateStr}.pprof`, profiles[type])
     })
     tasks.push(writeFile(`event_worker_${threadId}_${dateStr}.json`, this.getEventJSON(exportSpec)))
     return Promise.all(tasks)

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

@@ -0,0 +1,71 @@
+'use strict'
+
+const path = require('path')
+
+const log = require('../log')
+const { snapshotKinds } = require('./constants')
+
+const oomExportStrategies = Object.freeze({
+  PROCESS: 'process',
+  ASYNC_CALLBACK: 'async',
+  LOGS: 'logs',
+})
+
+/** @param {string} name */
+function getExportStrategy (name) {
+  const strategy = Object.values(oomExportStrategies).find(value => value === name)
+  if (strategy === undefined) {
+    log.error('Unknown oom export strategy "%s"', name)
+  }
+  return strategy
+}
+
+/**
+ * Validates the configured strategies, dropping any the tracer does not recognize (each logged once).
+ *
+ * @param {string[]} strategies
+ * @returns {string[]}
+ */
+function ensureOOMExportStrategies (strategies) {
+  const valid = new Set()
+  for (const strategy of strategies) {
+    const resolved = getExportStrategy(strategy)
+    if (resolved !== undefined) {
+      valid.add(resolved)
+    }
+  }
+  return [...valid]
+}
+
+/**
+ * @param {string[]} strategies
+ * @param {{ Async: number }} callbackMode
+ */
+function strategiesToCallbackMode (strategies, callbackMode) {
+  return strategies.includes(oomExportStrategies.ASYNC_CALLBACK) ? callbackMode.Async : 0
+}
+
+/**
+ * Builds the argv the near-OOM export subprocess ({@link ./exporter_cli.js}) is spawned with. Each
+ * exporter reports its own destination URL, so the command stays agnostic of the exporter types.
+ *
+ * @param {Array<{ getExportUrl(): URL | undefined }>} exporters
+ * @param {Record<string, string>} tags
+ * @returns {string[]}
+ */
+function buildExportCommand (exporters, tags) {
+  const tagString = [...Object.entries(tags),
+    ['snapshot', snapshotKinds.ON_OUT_OF_MEMORY]].map(([key, value]) => `${key}:${value}`).join(',')
+  const urls = []
+  for (const exporter of exporters) {
+    const url = exporter.getExportUrl()
+    if (url !== undefined) {
+      urls.push(url.toString())
+    }
+  }
+  return [process.execPath,
+    path.join(__dirname, 'exporter_cli.js'),
+    urls.join(','), tagString, 'space']
+}
+
+module.exports = { oomExportStrategies, ensureOOMExportStrategies, strategiesToCallbackMode, buildExportCommand }

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

@@ -4,7 +4,7 @@ const { EventEmitter } = require('events')
 const dc = require('dc-polyfill')
 const crashtracker = require('../crashtracking')
 const log = require('../log')
-const { Config } = require('./config')
+const { buildProfilingRuntime } = require('./config')
 const { snapshotKinds } = require('./constants')
 const { threadNamePrefix } = require('./profilers/shared')
 const { isWebServerSpan, endpointNameFromTags, getStartedSpans } = require('./webspan-utils')
@@ -54,14 +54,19 @@ class Profiler extends EventEmitter {
   #compressionFn
   #compressionFnInitialized = false
   #compressionOptions
-  #config
   #customLabelKeys = new Set()
   #enabled = false
   #endpointCounts = new Map()
+  #exporters
+  #flushInterval
   #lastStart
   #profileSeq = 0
+  #profilers
   #spanFinishListener
+  #systemInfoReport
+  #tags
   #timer
+  #uploadCompression
 
   constructor () {
     super()
@@ -71,7 +76,7 @@ class Profiler extends EventEmitter {
   get serverless () { return false }
 
   get flushInterval () {
-    return this.#config?.flushInterval
+    return this.#flushInterval
   }
 
   get enabled () {
@@ -90,8 +95,8 @@ class Profiler extends EventEmitter {
     for (const key of keys) {
       this.#customLabelKeys.add(key)
     }
-    if (this.#config) {
-      for (const profiler of this.#config.profilers) {
+    if (this.#profilers) {
+      for (const profiler of this.#profilers) {
         profiler.setCustomLabelKeys?.(this.#customLabelKeys)
       }
     }
@@ -106,10 +111,10 @@ class Profiler extends EventEmitter {
    * @template T
    */
   runWithLabels (labels, fn) {
-    if (!this.#enabled || !this.#config) {
+    if (!this.#enabled || !this.#profilers) {
       return fn()
     }
-    for (const profiler of this.#config.profilers) {
+    for (const profiler of this.#profilers) {
       if (profiler.runWithLabels) {
         return profiler.runWithLabels(labels, fn)
       }
@@ -123,7 +128,7 @@ class Profiler extends EventEmitter {
       try {
         const { promisify } = require('util')
         const zlib = require('zlib')
-        const { method, level: clevel } = this.#config.uploadCompression
+        const { method, level: clevel } = this.#uploadCompression
         switch (method) {
           case 'gzip':
             this.#compressionFn = promisify(zlib.gzip)
@@ -161,13 +166,20 @@ class Profiler extends EventEmitter {
   }
 
   /**
-   * @param {import('../config/config-base')} options - Tracer configuration
+   * @param {import('../config/config-base')} config - Tracer configuration
    */
-  start (options) {
+  start (config) {
     if (this.enabled) return true
     this.#enabled = true
 
-    const config = this.#config = new Config(options)
+    const { tags, exporters, flushInterval, profilers, uploadCompression, systemInfoReport } =
+      buildProfilingRuntime(config)
+    this.#tags = tags
+    this.#exporters = exporters
+    this.#flushInterval = flushInterval
+    this.#profilers = profilers
+    this.#uploadCompression = uploadCompression
+    this.#systemInfoReport = systemInfoReport
 
     this._setInterval()
     // Log errors if the source map finder fails, but don't prevent the rest
@@ -176,11 +188,11 @@ class Profiler extends EventEmitter {
     const { setLogger, SourceMapper } = require('@datadog/pprof')
     setLogger(pprofLogger)
 
-    if (config.sourceMap) {
-      mapper = new SourceMapper(config.debugSourceMaps)
+    if (config.DD_PROFILING_SOURCE_MAP) {
+      mapper = new SourceMapper(config.DD_PROFILING_DEBUG_SOURCE_MAPS)
       mapper.loadDirectory(process.cwd())
         .then(() => {
-          if (config.debugSourceMaps) {
+          if (config.DD_PROFILING_DEBUG_SOURCE_MAPS) {
             const count = mapper.infoMap.size
             // eslint-disable-next-line eslint-rules/eslint-log-printf-style
             log.debug(() => {
@@ -198,7 +210,7 @@ class Profiler extends EventEmitter {
     try {
       const start = new Date()
       const nearOOMCallback = this.#nearOOMExport.bind(this)
-      for (const profiler of config.profilers) {
+      for (const profiler of profilers) {
         // TODO: move this out of Profiler when restoring sourcemap support
         profiler.start({
           mapper,
@@ -207,7 +219,7 @@ class Profiler extends EventEmitter {
         log.debug('Started %s profiler in %s thread', profiler.type, threadNamePrefix)
       }
 
-      if (config.endpointCollectionEnabled) {
+      if (config.DD_PROFILING_ENDPOINT_COLLECTION_ENABLED) {
         this.#spanFinishListener = this.#onSpanFinish.bind(this)
         spanFinishedChannel.subscribe(this.#spanFinishListener)
       }
@@ -233,7 +245,7 @@ class Profiler extends EventEmitter {
   }
 
   _setInterval () {
-    this._timeoutInterval = this.#config.flushInterval
+    this._timeoutInterval = this.#flushInterval
   }
 
   stop () {
@@ -255,7 +267,7 @@ class Profiler extends EventEmitter {
       this.#spanFinishListener = undefined
     }
 
-    for (const profiler of this.#config.profilers) {
+    for (const profiler of this.#profilers) {
       profiler.stop()
       log.debug('Stopped %s profiler in %s thread', profiler.type, threadNamePrefix)
     }
@@ -298,7 +310,7 @@ class Profiler extends EventEmitter {
   #createInitialInfos () {
     return {
       serverless: this.serverless,
-      settings: this.#config.systemInfoReport,
+      settings: this.#systemInfoReport,
       hasMissingSourceMaps: false,
     }
   }
@@ -307,7 +319,7 @@ class Profiler extends EventEmitter {
     if (!this.enabled) return
 
     try {
-      if (this.#config.profilers.length === 0) {
+      if (this.#profilers.length === 0) {
         throw new Error('No profile types configured.')
       }
 
@@ -317,7 +329,7 @@ class Profiler extends EventEmitter {
 
       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.#profilers) {
           const info = profiler.getInfo()
           const profile = profiler.profile(restart, startDate, endDate)
           if (!restart) {
@@ -377,7 +389,7 @@ class Profiler extends EventEmitter {
   }
 
   #submit (profiles, infos, start, end, snapshotKind) {
-    const { tags } = this.#config
+    const tags = this.#tags
 
     // Flatten endpoint counts
     const endpointCounts = {}
@@ -392,7 +404,7 @@ class Profiler extends EventEmitter {
       ? [...this.#customLabelKeys]
       : undefined
     const exportSpec = { profiles, infos, start, end, tags, endpointCounts, customAttributes }
-    const tasks = this.#config.exporters.map(exporter =>
+    const tasks = this.#exporters.map(exporter =>
       exporter.export(exportSpec).catch(error => {
         log.warn(error)
       })

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

@@ -12,6 +12,7 @@ const {
   ValueType,
 } = require('../../../../../vendor/dist/pprof-format')
 const { availableParallelism, effectiveLibuvThreadCount } = require('../libuv-size')
+const { SAMPLING_INTERVAL } = require('../constants')
 const { END_TIMESTAMP_LABEL, SPAN_ID_LABEL, LOCAL_ROOT_SPAN_ID_LABEL, encodeProfileAsync } = require('./shared')
 const PoissonProcessSamplingFilter = require('./poisson')
 // perf_hooks uses millis, with fractional part representing nanos. We emit nanos into the pprof file.
@@ -19,6 +20,8 @@ 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
 
+/** @typedef {import('../../config/config-base')} TracerConfig */
+
 // 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".
 const pprofValueType = 'timeline'
@@ -50,8 +53,8 @@ function labelFromStrStr (stringTable, keyStr, valStr) {
   return labelFromStr(stringTable, stringTable.dedup(keyStr), valStr)
 }
 
-function getMaxSamples (options) {
-  const maxCpuSamples = options.flushInterval / options.samplingInterval
+function getMaxSamples (flushInterval, samplingInterval) {
+  const maxCpuSamples = flushInterval / samplingInterval
 
   // 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.
@@ -439,14 +442,18 @@ class EventsProfiler {
 
   get type () { return 'events' }
 
-  constructor (options) {
-    this.#maxSamples = getMaxSamples(options)
-    this.#timelineSamplingEnabled = !!options.timelineSamplingEnabled
+  /**
+   * @param {TracerConfig} config
+   * @param {{ flushInterval: number }} runtime
+   */
+  constructor (config, { flushInterval }) {
+    this.#maxSamples = getMaxSamples(flushInterval, SAMPLING_INTERVAL)
+    this.#timelineSamplingEnabled = config.DD_INTERNAL_PROFILING_TIMELINE_SAMPLING_ENABLED
     this.#eventSerializer = new EventSerializer(this.#maxSamples)
 
     const eventHandler = event => this.#eventSerializer.addEvent(event)
     const eventFilter = this.#timelineSamplingEnabled
-      ? createPoissonProcessSamplingFilter(options.samplingInterval)
+      ? createPoissonProcessSamplingFilter(SAMPLING_INTERVAL)
       : () => true
     const filteringEventHandler = event => {
       if (eventFilter(event)) {
@@ -454,7 +461,7 @@ class EventsProfiler {
       }
     }
 
-    this.#eventSources = options.codeHotspotsEnabled
+    this.#eventSources = config.DD_PROFILING_CODEHOTSPOTS_ENABLED
       // Use Datadog instrumentation to collect events with span IDs. Still use
       // Node API for GC events.
       ? [

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

@@ -1,27 +1,35 @@
 'use strict'
 
-const { oomExportStrategies } = require('../constants')
+const { oomExportStrategies, ensureOOMExportStrategies, strategiesToCallbackMode, buildExportCommand } =
+  require('../oom')
 const { encodeProfileAsync, getThreadLabels } = require('./shared')
 
-function strategiesToCallbackMode (strategies, callbackMode) {
-  return strategies.includes(oomExportStrategies.ASYNC_CALLBACK) ? callbackMode.Async : 0
-}
+/** @typedef {import('../../config/config-base')} TracerConfig */
+/**
+ * @typedef {import('../exporters/agent').AgentExporter
+ *   | import('../exporters/file').FileExporter} ProfilingExporter
+ */
 
 const STACK_DEPTH = 64
 
 class NativeSpaceProfiler {
+  #config
+  #exporters
   #mapper
-  #oomMonitoring
   #pprof
-  #allocationProfilingEnabled = false
-  #samplingInterval = 512 * 1024
+  #samplingInterval
   #started = false
+  #tags
 
-  constructor (options = {}) {
-    // TODO: Remove default value. It is only used in testing.
-    this.#samplingInterval = options.heapSamplingInterval || 512 * 1024
-    this.#allocationProfilingEnabled = options.allocationProfilingEnabled
-    this.#oomMonitoring = options.oomMonitoring || {}
+  /**
+   * @param {TracerConfig} config
+   * @param {{ tags: Record<string, string>, exporters: ProfilingExporter[] }} runtime
+   */
+  constructor (config, { tags, exporters }) {
+    this.#config = config
+    this.#tags = tags
+    this.#exporters = exporters
+    this.#samplingInterval = config.DD_PROFILING_HEAP_SAMPLING_INTERVAL
   }
 
   get type () {
@@ -31,16 +39,17 @@ class NativeSpaceProfiler {
   start ({ mapper, nearOOMCallback } = {}) {
     if (this.#started) return
 
+    const config = this.#config
     this.#mapper = mapper
     this.#pprof = require('@datadog/pprof')
-    this.#pprof.heap.start(this.#samplingInterval, STACK_DEPTH, this.#allocationProfilingEnabled)
-    if (this.#oomMonitoring.enabled) {
-      const strategies = this.#oomMonitoring.exportStrategies
+    this.#pprof.heap.start(this.#samplingInterval, STACK_DEPTH, config.DD_PROFILING_ALLOCATION_ENABLED)
+    if (config.DD_PROFILING_EXPERIMENTAL_OOM_MONITORING_ENABLED) {
+      const strategies = ensureOOMExportStrategies(config.DD_PROFILING_EXPERIMENTAL_OOM_EXPORT_STRATEGIES)
       this.#pprof.heap.monitorOutOfMemory(
-        this.#oomMonitoring.heapLimitExtensionSize,
-        this.#oomMonitoring.maxHeapExtensionCount,
+        config.DD_PROFILING_EXPERIMENTAL_OOM_HEAP_LIMIT_EXTENSION_SIZE,
+        config.DD_PROFILING_EXPERIMENTAL_OOM_MAX_HEAP_EXTENSION_COUNT,
         strategies.includes(oomExportStrategies.LOGS),
-        strategies.includes(oomExportStrategies.PROCESS) ? this.#oomMonitoring.exportCommand : [],
+        strategies.includes(oomExportStrategies.PROCESS) ? buildExportCommand(this.#exporters, this.#tags) : [],
         (profile) => nearOOMCallback(this.type, this.#pprof.encodeSync(profile), this.getInfo()),
         strategiesToCallbackMode(strategies, this.#pprof.heap.CallbackMode)
       )

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

@@ -7,6 +7,7 @@ const log = require('../../log')
 const runtimeMetrics = require('../../runtime_metrics')
 const telemetryMetrics = require('../../telemetry/metrics')
 const { isWebServerSpan, endpointNameFromTags, getStartedSpans } = require('../webspan-utils')
+const { SAMPLING_INTERVAL } = require('../constants')
 
 const {
   END_TIMESTAMP_LABEL,
@@ -18,6 +19,8 @@ const {
 } = require('./shared')
 const TRACE_ENDPOINT_LABEL = 'trace endpoint'
 
+/** @typedef {import('../../config/config-base')} TracerConfig */
+
 let beforeCh
 const enterCh = dc.channel('dd-trace:storage:enter')
 const spanFinishCh = dc.channel('dd-trace:span:finish')
@@ -108,13 +111,17 @@ class NativeWallProfiler {
   #asyncContextFrameEnabled = false
   #captureSpanData = false
   #codeHotspotsEnabled = false
+  #contextCountGaugeUpdater
   #cpuProfilingEnabled = false
+  #currentContext
   #customLabelsActive = false
   #customLabelKeys
   #endpointCollectionEnabled = false
   #flushIntervalMillis = 0
+  #lastSampleCount = 0
   #mapper
   #pprof
+  #profilerState
   #samplingIntervalMicros = 0
   #started = false
   #telemetryHeartbeatIntervalMillis = 0
@@ -130,17 +137,20 @@ class NativeWallProfiler {
 
   get type () { return 'wall' }
 
-  constructor (options = {}) {
-    this.#asyncContextFrameEnabled = !!options.asyncContextFrameEnabled
-    this.#codeHotspotsEnabled = !!options.codeHotspotsEnabled
-    this.#cpuProfilingEnabled = !!options.cpuProfilingEnabled
-    this.#endpointCollectionEnabled = !!options.endpointCollectionEnabled
-    this.#flushIntervalMillis = options.flushInterval || 60 * 1e3 // 60 seconds
-    // TODO: Remove default value. It is only used in testing.
-    this.#samplingIntervalMicros = (options.samplingInterval || 1e3 / 99) * 1000
-    this.#telemetryHeartbeatIntervalMillis = options.heartbeatInterval || 60 * 1e3 // 60 seconds
-    this.#timelineEnabled = !!options.timelineEnabled
-    this.#v8ProfilerBugWorkaroundEnabled = !!options.v8ProfilerBugWorkaroundEnabled
+  /**
+   * @param {TracerConfig} config
+   * @param {{ asyncContextFrameEnabled: boolean, flushInterval: number }} runtime
+   */
+  constructor (config, { asyncContextFrameEnabled, flushInterval }) {
+    this.#asyncContextFrameEnabled = asyncContextFrameEnabled
+    this.#codeHotspotsEnabled = config.DD_PROFILING_CODEHOTSPOTS_ENABLED
+    this.#cpuProfilingEnabled = config.DD_PROFILING_CPU_ENABLED
+    this.#endpointCollectionEnabled = config.DD_PROFILING_ENDPOINT_COLLECTION_ENABLED
+    this.#flushIntervalMillis = flushInterval
+    this.#samplingIntervalMicros = SAMPLING_INTERVAL * 1000
+    this.#telemetryHeartbeatIntervalMillis = config.telemetry.heartbeatInterval
+    this.#timelineEnabled = config.DD_PROFILING_TIMELINE_ENABLED
+    this.#v8ProfilerBugWorkaroundEnabled = config.DD_PROFILING_V8_PROFILER_BUG_WORKAROUND
 
     // We need to capture span data into the sample context for either code hotspots
     // or endpoint collection.
@@ -192,8 +202,8 @@ class NativeWallProfiler {
       }
 
       if (this.#captureSpanData) {
-        this._profilerState = this.#pprof.time.getState()
-        this._lastSampleCount = 0
+        this.#profilerState = this.#pprof.time.getState()
+        this.#lastSampleCount = 0
 
         ensureChannelsActivated(this.#asyncContextFrameEnabled)
 
@@ -217,12 +227,12 @@ class NativeWallProfiler {
     const asyncContextsLiveGauge = profilerTelemetryMetrics.gauge('wall.async_contexts_live')
     const asyncContextsUsedGauge = profilerTelemetryMetrics.gauge('wall.async_contexts_used')
 
-    this._contextCountGaugeUpdater = setInterval(() => {
+    this.#contextCountGaugeUpdater = setInterval(() => {
       const { totalAsyncContextCount, usedAsyncContextCount } = this.#pprof.time.getMetrics()
       asyncContextsLiveGauge.mark(totalAsyncContextCount)
       asyncContextsUsedGauge.mark(usedAsyncContextCount)
     }, this.#telemetryHeartbeatIntervalMillis)
-    this._contextCountGaugeUpdater.unref?.()
+    this.#contextCountGaugeUpdater.unref?.()
   }
 
   #enter () {
@@ -271,16 +281,16 @@ class NativeWallProfiler {
         this.#pprof.time.setContext(sampleContext)
       }
     } else {
-      const sampleCount = this._profilerState[kSampleCount]
-      if (sampleCount !== this._lastSampleCount) {
-        this._lastSampleCount = sampleCount
-        const context = this._currentContext.ref
+      const sampleCount = this.#profilerState[kSampleCount]
+      if (sampleCount !== this.#lastSampleCount) {
+        this.#lastSampleCount = sampleCount
+        const context = this.#currentContext.ref
         this.#setNewContext()
 
         updateContext(context)
       }
 
-      this._currentContext.ref = sampleContext
+      this.#currentContext.ref = sampleContext
     }
   }
 
@@ -322,10 +332,10 @@ class NativeWallProfiler {
   }
 
   #setNewContext () {
-    this._currentContext = {
+    this.#currentContext = {
       ref: {},
     }
-    this.#pprof.time.setContext(this._currentContext)
+    this.#pprof.time.setContext(this.#currentContext)
   }
 
   #spanFinished (span) {
@@ -360,7 +370,7 @@ class NativeWallProfiler {
     if (this.#captureSpanData && !this.#asyncContextFrameEnabled) {
       // update last sample context if needed
       this.#enter()
-      this._lastSampleCount = 0
+      this.#lastSampleCount = 0
     }
 
     // Mark thread labels and trace endpoint label as good deduplication candidates
@@ -382,7 +392,7 @@ class NativeWallProfiler {
         this.#reportV8bug(v8BugDetected === 1)
       }
     } else {
-      clearInterval(this._contextCountGaugeUpdater)
+      clearInterval(this.#contextCountGaugeUpdater)
       if (this.#captureSpanData) {
         if (!this.#asyncContextFrameEnabled) {
           beforeCh.unsubscribe(this.#boundEnter)
@@ -392,7 +402,7 @@ class NativeWallProfiler {
         if (this.#endpointCollectionEnabled) {
           tagsUpdateCh.unsubscribe(this.#boundSpanTagsUpdated)
         }
-        this._profilerState = undefined
+        this.#profilerState = undefined
       }
       this.#started = false
     }