feat: Added ability to delay the start of the Profiler and run for n milliseconds before shutting down. (#3758)

Author: bizob2828

lib/aggregators/base-aggregator.js

@@ -160,6 +160,8 @@ class Aggregator extends EventEmitter {
 
     this.defaultPeriod = this.periodMs = opts.periodMs
     this.defaultLimit = this.limit = opts.limit
+    this.delay = opts.delay ?? 0
+    this.duration = opts.duration ?? 0
     this.runId = opts.runId
     this.isAsync = opts.isAsync || false
     // function to pass in to determine if we can start a given aggregator

lib/aggregators/profiling-aggregator.js

@@ -43,8 +43,13 @@ class ProfilingAggregator extends BaseAggregator {
    * and send the gzipped binary encoded data for each profiler
    */
   start() {
-    logger.trace(`${this.method} aggregator started.`)
     this.profilingManager.register()
+    const started = this.profilingManager.start()
+    if (!started) {
+      return
+    }
+
+    logger.trace(`${this.method} aggregator started.`)
 
     if (!this.sendTimer) {
       this.sendTimer = setInterval(this.collectData.bind(this), this.periodMs)

lib/harvester.js

@@ -2,26 +2,41 @@
  * Copyright 2024 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-
 'use strict'
+const defaultLogger = require('./logger').child({ component: 'harvester' })
 
 /**
  * @class
  * @classdesc Used to keep track of all registered aggregators.
  */
 module.exports = class Harvester {
-  constructor() {
+  constructor({ logger = defaultLogger } = {}) {
     this.aggregators = []
+    this.logger = logger
   }
 
   /**
    * Calls start on every registered aggregator that is enabled.
    */
   start() {
     for (const aggregator of this.aggregators) {
-      if (aggregator.enabled) {
+      if (aggregator.enabled && aggregator.delay > 0) {
+        this.logger.debug(`Delay start of ${aggregator.method} by ${aggregator.delay} milliseconds`)
+        const timeout = setTimeout(() => {
+          aggregator.start()
+        }, aggregator.delay)
+        timeout.unref()
+      } else if (aggregator.enabled) {
         aggregator.start()
       }
+
+      if (aggregator.enabled && aggregator.duration > 0) {
+        this.logger.debug(`Running ${aggregator.method} for ${aggregator.duration} milliseconds`)
+        const durationTimeout = setTimeout(() => {
+          aggregator.stop()
+        }, aggregator.delay + aggregator.duration)
+        durationTimeout.unref()
+      }
     }
   }
 

lib/profiling/index.js

@@ -20,13 +20,14 @@ class ProfilingManager {
   start() {
     if (this.profilers.length === 0) {
       this.logger.warn('No profilers have been included in `config.profiling.include`, not starting any profilers.')
-      return
+      return false
     }
 
     for (const profiler of this.profilers) {
       this.logger.debug(`Starting ${profiler.name}`)
       profiler.start()
     }
+    return true
   }
 
   stop() {

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

@@ -11,26 +11,14 @@ const sinon = require('sinon')
 const ProfilingAggregator = require('#agentlib/aggregators/profiling-aggregator.js')
 const helper = require('#testlib/agent_helper.js')
 const RUN_ID = 1337
+const createProfiler = require('../mocks/profiler')
 
 test.beforeEach((ctx) => {
   const sandbox = sinon.createSandbox()
   const agent = helper.loadMockedAgent()
-  const cpuProfiler = {
-    name: 'CpuProfiler',
-    stop: sandbox.stub(),
-    collect() {
-      return 'cpu profile data'
-    }
-  }
-
+  const cpuProfiler = createProfiler({ sandbox, name: 'CpuProfiler', data: 'cpu profile data' })
+  const heapProfiler = createProfiler({ sandbox, name: 'HeapProfiler', data: 'heap profile data' })
   const clock = sinon.useFakeTimers()
-  const heapProfiler = {
-    name: 'HeapProfiler',
-    stop: sandbox.stub(),
-    collect() {
-      return 'heap profile data'
-    }
-  }
   sandbox.spy(agent.collector, 'send')
   const profilingAggregator = new ProfilingAggregator({ runId: RUN_ID, periodMs: 100 }, agent)
   const profilingManager = profilingAggregator.profilingManager

test/unit/harvester.test.js

@@ -18,6 +18,8 @@ class FakeAggregator extends EventEmitter {
     super()
     this.enabled = opts.enabled
     this.method = opts.method
+    this.delay = opts.delay ?? 0
+    this.duration = opts.duration ?? 0
   }
 
   start() {}
@@ -40,19 +42,21 @@ function createAggregator(sandbox, opts) {
 }
 
 test.beforeEach((ctx) => {
-  ctx.nr = {}
-
   const sandbox = sinon.createSandbox()
   const aggregators = [
     createAggregator(sandbox, { enabled: true, method: 'agg1' }),
     createAggregator(sandbox, { enabled: false, method: 'agg2' })
   ]
-  const harvester = new Harvester()
+  const logger = require('./mocks/logger')(sandbox)
+  const harvester = new Harvester({ logger })
   aggregators.forEach((a) => harvester.add(a))
 
-  ctx.nr.sandbox = sandbox
-  ctx.nr.aggregators = aggregators
-  ctx.nr.harvester = harvester
+  ctx.nr = {
+    sandbox,
+    aggregators,
+    harvester,
+    logger
+  }
 })
 
 test.afterEach((ctx) => {
@@ -71,10 +75,11 @@ test('should add aggregator to this.aggregators', (t) => {
 })
 
 test('should start all aggregators that are enabled', (t) => {
-  const { harvester, aggregators } = t.nr
+  const { harvester, aggregators, logger } = t.nr
   harvester.start()
   assert.equal(aggregators[0].start.callCount, 1, 'should start enabled aggregator')
   assert.equal(aggregators[1].start.callCount, 0, 'should not start disabled aggregator')
+  assert.equal(logger.debug.callCount, 0)
 })
 
 test('should stop all aggregators', (t) => {
@@ -103,3 +108,52 @@ test('resolve when all data is sent', async (t) => {
   })
   await promise
 })
+
+test('should delay starting of aggregator when it has a delay property', (t) => {
+  const { sandbox, logger } = t.nr
+  const clock = sandbox.useFakeTimers()
+  const delayAggregator = createAggregator(sandbox, { enabled: true, method: 'test-method', delay: 200 })
+  const harvester = new Harvester({ logger })
+  harvester.add(delayAggregator)
+  harvester.start()
+  assert.equal(logger.debug.callCount, 1)
+  assert.equal(logger.debug.args[0][0], 'Delay start of test-method by 200 milliseconds')
+  const { aggregators } = harvester
+  assert.equal(aggregators[0].start.callCount, 0, 'should not start delayed aggregator yet')
+  clock.tick(201)
+  assert.equal(aggregators[0].start.callCount, 1, 'should start delayed aggregator after delay has elapsed')
+})
+
+test('should stop aggregator dynamically when it has a duration property', (t) => {
+  const { sandbox, logger } = t.nr
+  const clock = sandbox.useFakeTimers()
+  const delayAggregator = createAggregator(sandbox, { enabled: true, method: 'test-method', duration: 200 })
+  const harvester = new Harvester({ logger })
+  harvester.add(delayAggregator)
+  harvester.start()
+  assert.equal(logger.debug.callCount, 1)
+  assert.equal(logger.debug.args[0][0], 'Running test-method for 200 milliseconds')
+  const { aggregators } = harvester
+  assert.equal(aggregators[0].start.callCount, 1, 'should start aggregator')
+  assert.equal(aggregators[0].stop.callCount, 0, 'should not stop aggregator yet')
+  clock.tick(201)
+  assert.equal(aggregators[0].stop.callCount, 1, 'should stop aggregator after duration has elapsed')
+})
+
+test('should delay start and stop aggregator after duration', (t) => {
+  const { sandbox, logger } = t.nr
+  const clock = sandbox.useFakeTimers()
+  const delayAggregator = createAggregator(sandbox, { enabled: true, method: 'test-method', delay: 100, duration: 200 })
+  const harvester = new Harvester({ logger })
+  harvester.add(delayAggregator)
+  harvester.start()
+  assert.equal(logger.debug.callCount, 2)
+  const { aggregators } = harvester
+  assert.equal(aggregators[0].start.callCount, 0, 'should not start delayed aggregator yet')
+  assert.equal(aggregators[0].stop.callCount, 0, 'should not stop aggregator yet')
+  clock.tick(101)
+  assert.equal(aggregators[0].start.callCount, 1, 'should start delayed aggregator after delay has elapsed')
+  assert.equal(aggregators[0].stop.callCount, 0, 'should not stop aggregator yet')
+  clock.tick(200)
+  assert.equal(aggregators[0].stop.callCount, 1, 'should stop aggregator after duration has elapsed')
+})

test/unit/lib/profiling/index.test.js

@@ -9,6 +9,7 @@ const { describe, test } = require('node:test')
 const assert = require('node:assert')
 const sinon = require('sinon')
 const ProfilingManager = require('#agentlib/profiling/index.js')
+const createProfiler = require('../../mocks/profiler')
 
 test.beforeEach((ctx) => {
   const sandbox = sinon.createSandbox()
@@ -21,19 +22,8 @@ test.beforeEach((ctx) => {
       }
     }
   }
-  const cpuProfiler = {
-    name: 'cpu',
-    start: sandbox.stub(),
-    stop: sandbox.stub(),
-    collect: sandbox.stub()
-  }
-
-  const heapProfiler = {
-    name: 'heap',
-    start: sandbox.stub(),
-    stop: sandbox.stub(),
-    collect: sandbox.stub()
-  }
+  const cpuProfiler = createProfiler({ sandbox, name: 'cpu' })
+  const heapProfiler = createProfiler({ sandbox, name: 'heap' })
   ctx.nr = {
     agent,
     cpuProfiler,
@@ -81,7 +71,8 @@ describe('start', () => {
     const { agent, logger } = t.nr
     const profilingManager = new ProfilingManager(agent, { logger })
 
-    profilingManager.start()
+    const started = profilingManager.start()
+    assert.equal(started, false)
 
     assert.equal(logger.warn.callCount, 1)
     assert.ok(
@@ -95,8 +86,8 @@ describe('start', () => {
     const { agent, cpuProfiler, heapProfiler, logger } = t.nr
     const profilingManager = new ProfilingManager(agent, { logger })
     profilingManager.profilers = [cpuProfiler, heapProfiler]
-    profilingManager.start()
-
+    const started = profilingManager.start()
+    assert.equal(started, true)
     assert.equal(cpuProfiler.start.callCount, 1)
     assert.equal(heapProfiler.start.callCount, 1)
     assert.ok(

test/unit/mocks/profiler.js

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2026 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+const sinon = require('sinon')
+const DEFAULT_DATA = Buffer.from('test-data')
+
+function createProfiler({ sandbox = sinon, name = 'TestProfiler', data = DEFAULT_DATA } = {}) {
+  return {
+    name,
+    start: sandbox.stub(),
+    stop: sandbox.stub(),
+    collect: sandbox.stub().returns(data)
+  }
+}
+
+module.exports = createProfiler