feat: Added ProfilingManager class, used to orchestrate profilers (newrelic#3738)

Author: bizob2828

lib/aggregators/profiling-aggregator.js

@@ -7,6 +7,7 @@
 
 const logger = require('../logger').child({ component: 'pprof_aggregator' })
 const BaseAggregator = require('./base-aggregator')
+const ProfilingManager = require('#agentlib/profiling/index.js')
 
 /**
  * Serves as a means for transmitting pprof data as it is being collected.
@@ -16,7 +17,7 @@ const BaseAggregator = require('./base-aggregator')
  * The `ProfilingAggregator` aggregator overrides the base `start` method.
  * It sets up the interval based on configuration but instead of calling `send`,
  * it calls `collectData` which instructs the Profiler to collect profiling data
- * for every register profiler(cpu, heap at the moment if enabled)
+ * for every registered profiler(cpu, heap at the moment if enabled)
  *
  * @private
  * @class
@@ -27,7 +28,7 @@ class ProfilingAggregator extends BaseAggregator {
     opts.method = opts.method || 'pprof_data'
     super(opts, collector, harvester)
     this.agent = agent
-    this.profiler = opts.profiler
+    this.profilingManager = new ProfilingManager(agent)
     this.pprofData = null
   }
 
@@ -43,22 +44,31 @@ class ProfilingAggregator extends BaseAggregator {
    */
   start() {
     logger.trace(`${this.method} aggregator started.`)
+    this.profilingManager.register()
 
     if (!this.sendTimer) {
       this.sendTimer = setInterval(this.collectData.bind(this), this.periodMs)
       this.sendTimer.unref()
     }
   }
 
+  stop() {
+    super.stop()
+    this.profilingManager.stop()
+  }
+
   /**
    * Called on an interval. Iterates over all registered profilers
    * and collects data for the given time period. Then asynchronously
    * calls send which takes care of sending the data to the collector
    */
   collectData() {
-    for (const profiler of this.profiler.profilers) {
-      this.pprofData = profiler.collect()
-      this.send()
+    const self = this
+    for (const pprofData of this.profilingManager.collect()) {
+      if (pprofData) {
+        self.pprofData = pprofData
+        self.send()
+      }
     }
   }
 

lib/profiling/index.js

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2026 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+const defaultLogger = require('#agentlib/logger.js').child({ component: 'profiling-manager' })
+
+class ProfilingManager {
+  constructor(agent, { logger = defaultLogger } = {}) {
+    this.logger = logger
+    this.config = agent.config
+    this.profilers = []
+  }
+
+  // current no-op until we built out the profilers
+  register() {
+  }
+
+  start() {
+    if (this.profilers.length === 0) {
+      this.logger.warn('No profilers have been included in `config.profiling.include`, not starting any profilers.')
+      return
+    }
+
+    for (const profiler of this.profilers) {
+      this.logger.debug(`Starting ${profiler.name}`)
+      profiler.start()
+    }
+  }
+
+  stop() {
+    if (this.profilers.length === 0) {
+      this.logger.warn('No profilers have been included in `config.profiling.include`, not stopping any profilers.')
+      return
+    }
+
+    for (const profiler of this.profilers) {
+      this.logger.debug(`Stopping ${profiler.name}`)
+      profiler.stop()
+    }
+  }
+
+  collect() {
+    const results = []
+    if (this.profilers.length === 0) {
+      this.logger.warn('No profilers have been included in `config.profiling.include`, not collecting any profiling data.')
+      return results
+    }
+
+    return this.profilers.map((profiler) => {
+      this.logger.debug(`Collecting profiling data for ${profiler.name}`)
+      return profiler.collect()
+    })
+  }
+}
+
+module.exports = ProfilingManager

lib/profiling/profilers/base.js

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2026 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+class BaseProfiler {
+  set name(name) {
+    this._name = name
+  }
+
+  get name() {
+    return this._name
+  }
+
+  start() {
+    throw new Error('start is not implemented')
+  }
+
+  stop() {
+    throw new Error('stop is not implemented')
+  }
+
+  collect() {
+    throw new Error('collect is not implemented')
+  }
+}
+
+module.exports = BaseProfiler

test/unit/aggregators/profiling-aggregator.test.js

@@ -1,5 +1,5 @@
 /*
- * Copyright 2024 New Relic Corporation. All rights reserved.
+ * Copyright 2026 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -13,36 +13,42 @@ const helper = require('#testlib/agent_helper.js')
 const RUN_ID = 1337
 
 test.beforeEach((ctx) => {
+  const sandbox = sinon.createSandbox()
   const agent = helper.loadMockedAgent()
   const cpuProfiler = {
+    name: 'CpuProfiler',
+    stop: sandbox.stub(),
     collect() {
       return 'cpu profile data'
     }
   }
 
   const clock = sinon.useFakeTimers()
   const heapProfiler = {
+    name: 'HeapProfiler',
+    stop: sandbox.stub(),
     collect() {
       return 'heap profile data'
     }
   }
-  const profiler = {
-    profilers: [cpuProfiler, heapProfiler]
-  }
-  sinon.spy(agent.collector, 'send')
-  const profilingAggregator = new ProfilingAggregator({ runId: RUN_ID, periodMs: 100, profiler }, agent)
+  sandbox.spy(agent.collector, 'send')
+  const profilingAggregator = new ProfilingAggregator({ runId: RUN_ID, periodMs: 100 }, agent)
+  const profilingManager = profilingAggregator.profilingManager
+  sandbox.spy(profilingManager, 'register')
+  profilingAggregator.profilingManager.profilers = [cpuProfiler, heapProfiler]
   ctx.nr = {
     agent,
     clock,
     profilingAggregator,
-    profiler
+    profilingManager,
+    sandbox
   }
 })
 
 test.afterEach((ctx) => {
   helper.unloadAgent(ctx.nr.agent)
   ctx.nr.clock.restore()
-  ctx.nr.agent.collector.send.restore()
+  ctx.nr.sandbox.restore()
 })
 
 test('should set the correct default method', (t) => {
@@ -51,15 +57,17 @@ test('should set the correct default method', (t) => {
   assert.equal(method, 'pprof_data')
 })
 
-test('should intialize pprofData and profiler', (t) => {
-  const { profilingAggregator, profiler } = t.nr
-  assert.deepEqual(profilingAggregator.profiler, profiler)
+test('should initialize pprofData and profilingManager', (t) => {
+  const { profilingAggregator, profilingManager } = t.nr
+  assert.deepEqual(profilingAggregator.profilingManager, profilingManager)
   assert.equal(profilingAggregator.pprofData, null)
 })
 
 test('should send 2 messages per interval', (t) => {
-  const { profilingAggregator, clock, agent } = t.nr
+  const { profilingAggregator, profilingManager, clock, agent } = t.nr
+  assert.equal(profilingManager.register.callCount, 0)
   profilingAggregator.start()
+  assert.equal(profilingManager.register.callCount, 1)
   assert.equal(agent.collector.send.callCount, 0)
   clock.tick(100)
   assert.equal(agent.collector.send.callCount, 2)
@@ -70,3 +78,26 @@ test('should send 2 messages per interval', (t) => {
   assert.equal(heapCall[1], 'heap profile data')
   assert.equal(profilingAggregator.pprofData, null)
 })
+
+test('should not send any data if there are no profilers registered', (t) => {
+  const { profilingAggregator, clock, agent } = t.nr
+  profilingAggregator.profilingManager.profilers = []
+  profilingAggregator.start()
+  assert.equal(agent.collector.send.callCount, 0)
+  clock.tick(100)
+  assert.equal(agent.collector.send.callCount, 0)
+})
+
+test('should stop ProfilingManager when aggregator is stopped', (t) => {
+  const { profilingAggregator, profilingManager } = t.nr
+  profilingAggregator.start()
+  assert.ok(profilingAggregator.sendTimer)
+  for (const profiler of profilingManager.profilers) {
+    assert.equal(profiler.stop.callCount, 0)
+  }
+  profilingAggregator.stop()
+  assert.equal(profilingAggregator.sendTimer, null)
+  for (const profiler of profilingManager.profilers) {
+    assert.equal(profiler.stop.callCount, 1)
+  }
+})