feat(profiling): add allocations profiling support (#8764)

Author: IlyasShabi

integration-tests/profiler/allocation-profiler.spec.js

@@ -0,0 +1,144 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const childProcess = require('node:child_process')
+const { fork } = childProcess
+const path = require('node:path')
+
+const satisfies = require('semifies')
+
+const { Profile } = require('../../vendor/dist/pprof-format')
+const {
+  FakeAgent,
+  sandboxCwd,
+  stopProc,
+  useSandbox,
+} = require('../helpers')
+const { processExitPromise } = require('./helpers')
+
+const TIMEOUT = 30000
+const isAtLeast26 = satisfies(process.versions.node, '>=26.0.0')
+
+function getString (strings, value) {
+  const index = typeof value?.toNumber === 'function' ? value.toNumber() : Number(value)
+  return strings[index]
+}
+
+function getSampleTypeNames (profile) {
+  const strings = profile.stringTable.strings
+  return profile.sampleType.map(sampleType => getString(strings, sampleType.type))
+}
+
+function findFile (files, originalname) {
+  const file = files.find(file => file.originalname === originalname)
+  assert.ok(file, `Expected ${originalname} attachment`)
+  return file
+}
+
+function expectProfileUpload (agent) {
+  let upload
+
+  const messagePromise = agent.assertMessageReceived(({ files }) => {
+    assert.ok(files, 'Expected profiling upload')
+
+    upload = {
+      event: JSON.parse(findFile(files, 'event.json').buffer.toString()),
+      spaceProfile: Profile.decode(findFile(files, 'space.pprof').buffer),
+    }
+  }, TIMEOUT)
+
+  return messagePromise.then(() => upload)
+}
+
+describe('allocation profiler', () => {
+  let agent
+  let cwd
+  let proc
+  let profilerTestFile
+
+  useSandbox()
+
+  before(() => {
+    cwd = sandboxCwd()
+    profilerTestFile = path.join(cwd, 'profiler/allocation.js')
+  })
+
+  beforeEach(async () => {
+    agent = await new FakeAgent().start()
+  })
+
+  afterEach(async () => {
+    await stopProc(proc)
+    await agent.stop()
+  })
+
+  it('sends heap profiles with the expected sample types on Node.js 26+', async function () {
+    if (!isAtLeast26) {
+      this.skip()
+      return
+    }
+
+    const cases = [
+      {
+        allocationProfilingEnabled: false,
+        sampleTypes: ['objects', 'space'],
+      },
+      {
+        allocationProfilingEnabled: true,
+        sampleTypes: ['inuse_objects', 'alloc_objects', 'inuse_space', 'alloc_space'],
+      },
+    ]
+
+    for (const { allocationProfilingEnabled, sampleTypes } of cases) {
+      proc = fork(profilerTestFile, {
+        cwd,
+        env: {
+          DD_TRACE_AGENT_PORT: agent.port,
+          DD_PROFILING_ALLOCATION_ENABLED: allocationProfilingEnabled ? '1' : '0',
+          DD_PROFILING_DEBUG_UPLOAD_COMPRESSION: 'off',
+          DD_PROFILING_EXPORTERS: 'agent',
+          DD_PROFILING_PROFILERS: 'space',
+          DD_PROFILING_SOURCE_MAP: '0',
+          DD_PROFILING_UPLOAD_PERIOD: '1',
+          TEST_DURATION_MS: '5000',
+        },
+      })
+
+      const [
+        { event, spaceProfile },
+      ] = await Promise.all([
+        expectProfileUpload(agent),
+        processExitPromise(proc, TIMEOUT),
+      ])
+
+      assert.deepStrictEqual(event.attachments, ['space.pprof'])
+      assert.strictEqual(event.info.profiler.settings.allocationProfilingEnabled, allocationProfilingEnabled)
+      assert.deepStrictEqual(getSampleTypeNames(spaceProfile), sampleTypes)
+
+      await stopProc(proc)
+      proc = undefined
+    }
+  })
+
+  it('does not crash when allocation profiling is requested on unsupported Node.js versions', async function () {
+    if (isAtLeast26) {
+      this.skip()
+      return
+    }
+
+    proc = fork(profilerTestFile, {
+      cwd,
+      env: {
+        DD_PROFILING_ALLOCATION_ENABLED: '1',
+        DD_PROFILING_DEBUG_UPLOAD_COMPRESSION: 'off',
+        DD_PROFILING_EXPORTERS: 'file',
+        DD_PROFILING_PROFILERS: 'space',
+        DD_PROFILING_SOURCE_MAP: '0',
+        DD_PROFILING_UPLOAD_PERIOD: '1',
+        TEST_DURATION_MS: '5000',
+      },
+    })
+
+    await processExitPromise(proc, TIMEOUT)
+  })
+})

integration-tests/profiler/allocation.js

@@ -0,0 +1,35 @@
+'use strict'
+
+require('dd-trace').init({ profiling: true })
+
+const durationMs = Number.parseInt(process.env.TEST_DURATION_MS ?? '5000')
+
+function runAllocations (ms) {
+  return new Promise(resolve => {
+    const allocations = []
+    const end = Date.now() + ms
+
+    function work () {
+      if (Date.now() >= end) {
+        resolve()
+        return
+      }
+
+      for (let i = 0; i < 1000; i++) {
+        allocations.push({ index: i, values: [i, i + 1, i + 2] })
+      }
+
+      if (allocations.length > 10000) {
+        allocations.splice(0, 5000)
+      }
+
+      setImmediate(work)
+    }
+
+    work()
+  })
+}
+
+runAllocations(durationMs).catch(err => {
+  process.exitCode = 1
+})

integration-tests/profiler/helpers.js

@@ -0,0 +1,27 @@
+'use strict'
+
+function processExitPromise (proc, timeout, expectBadExit = false) {
+  return new Promise((resolve, reject) => {
+    const timeoutObj = setTimeout(() => {
+      reject(new Error('Process timed out'))
+    }, timeout)
+
+    function checkExitCode (code) {
+      clearTimeout(timeoutObj)
+
+      if ((code !== 0) !== expectBadExit) {
+        reject(new Error(`Process exited with unexpected status code ${code}.`))
+      } else {
+        resolve()
+      }
+    }
+
+    proc
+      .on('error', reject)
+      .on('exit', checkExitCode)
+  })
+}
+
+module.exports = {
+  processExitPromise,
+}

integration-tests/profiler/profiler.spec.js

@@ -19,6 +19,7 @@ const {
   assertObjectContains,
   stopProc,
 } = require('../helpers')
+const { processExitPromise } = require('./helpers')
 
 const DEFAULT_PROFILE_TYPES = ['wall', 'space']
 if (process.platform !== 'win32') {
@@ -77,28 +78,6 @@ function expectProfileMessagePromise (agent, timeout,
   }, timeout, 1, true)
 }
 
-function processExitPromise (proc, timeout, expectBadExit = false) {
-  return new Promise((resolve, reject) => {
-    const timeoutObj = setTimeout(() => {
-      reject(new Error('Process timed out'))
-    }, timeout)
-
-    function checkExitCode (code) {
-      clearTimeout(timeoutObj)
-
-      if ((code !== 0) !== expectBadExit) {
-        reject(new Error(`Process exited with unexpected status code ${code}.`))
-      } else {
-        resolve()
-      }
-    }
-
-    proc
-      .on('error', reject)
-      .on('exit', checkExitCode)
-  })
-}
-
 async function getLatestProfile (cwd, pattern) {
   const pprofCompressed = await readLatestFile(cwd, pattern)
   const pprofUncompressed = zlib[isAtLeast24 ? 'zstdDecompressSync' : 'gunzipSync'](pprofCompressed)

package.json

@@ -169,7 +169,7 @@
     "@datadog/native-iast-taint-tracking": "4.2.0",
     "@datadog/native-metrics": "3.1.2",
     "@datadog/openfeature-node-server": "2.0.0",
-    "@datadog/pprof": "5.14.4",
+    "@datadog/pprof": "5.15.0",
     "@datadog/wasm-js-rewriter": "5.0.1",
     "@opentelemetry/api": ">=1.0.0 <1.10.0",
     "@opentelemetry/api-logs": "<1.0.0",

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

@@ -130,6 +130,7 @@ export interface GeneratedConfig {
   DD_MINI_AGENT_PATH: string | undefined;
   DD_PIPELINE_EXECUTION_ID: string | undefined;
   DD_PLAYWRIGHT_WORKER: string | undefined;
+  DD_PROFILING_ALLOCATION_ENABLED: boolean;
   DD_PROFILING_ASYNC_CONTEXT_FRAME_ENABLED: boolean;
   DD_PROFILING_CODEHOTSPOTS_ENABLED: boolean;
   DD_PROFILING_CPU_ENABLED: boolean;

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

@@ -1308,6 +1308,13 @@
         "default": null
       }
     ],
+    "DD_PROFILING_ALLOCATION_ENABLED": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "default": "false"
+      }
+    ],
     "DD_PROFILING_ASYNC_CONTEXT_FRAME_ENABLED": [
       {
         "implementation": "A",

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

@@ -86,6 +86,7 @@ class Config {
 
     this.timelineEnabled = options.DD_PROFILING_TIMELINE_ENABLED
     this.timelineSamplingEnabled = options.DD_INTERNAL_PROFILING_TIMELINE_SAMPLING_ENABLED
+    this.allocationProfilingEnabled = options.DD_PROFILING_ALLOCATION_ENABLED
     this.codeHotspotsEnabled = options.DD_PROFILING_CODEHOTSPOTS_ENABLED
     this.cpuProfilingEnabled = options.DD_PROFILING_CPU_ENABLED
     this.heapSamplingInterval = options.DD_PROFILING_HEAP_SAMPLING_INTERVAL
@@ -139,6 +140,7 @@ class Config {
 
   get systemInfoReport () {
     const report = {
+      allocationProfilingEnabled: this.allocationProfilingEnabled,
       asyncContextFrameEnabled: this.asyncContextFrameEnabled,
       codeHotspotsEnabled: this.codeHotspotsEnabled,
       cpuProfilingEnabled: this.cpuProfilingEnabled,

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

@@ -13,12 +13,14 @@ class NativeSpaceProfiler {
   #mapper
   #oomMonitoring
   #pprof
+  #allocationProfilingEnabled = false
   #samplingInterval = 512 * 1024
   #started = false
 
   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 || {}
   }
 
@@ -31,7 +33,7 @@ class NativeSpaceProfiler {
 
     this.#mapper = mapper
     this.#pprof = require('@datadog/pprof')
-    this.#pprof.heap.start(this.#samplingInterval, STACK_DEPTH)
+    this.#pprof.heap.start(this.#samplingInterval, STACK_DEPTH, this.#allocationProfilingEnabled)
     if (this.#oomMonitoring.enabled) {
       const strategies = this.#oomMonitoring.exportStrategies
       this.#pprof.heap.monitorOutOfMemory(

packages/dd-trace/test/config/index.spec.js

@@ -1016,6 +1016,7 @@ describe('Config', () => {
       { name: 'plugins', value: true, origin: 'default' },
       { name: 'DD_TRACE_AGENT_PORT', value: 8126, origin: 'default' },
       { name: 'DD_PROFILING_ENABLED', value: 'false', origin: 'default' },
+      { name: 'DD_PROFILING_ALLOCATION_ENABLED', value: false, origin: 'default' },
       { name: 'DD_PROFILING_EXPORTERS', value: 'agent', origin: 'default' },
       { name: 'DD_PROFILING_SOURCE_MAP', value: true, origin: 'default' },
       { name: 'DD_TRACE_AGENT_PROTOCOL_VERSION', value: '0.4', origin: 'default' },