Testing

Author: szegedi

integration-tests/profiler/eventlimits.js

@@ -0,0 +1,21 @@
+'use strict'
+
+const performance = require('perf_hooks').performance
+
+const EVENT_COUNT = parseInt(process.argv[2])
+require('dd-trace').init().profilerStarted().then(() => {
+  const EventSource = require('dd-trace/packages/dd-trace/src/profiling/profilers/events.js')
+  const template = {
+    entryType: 'dns',
+    duration: 10,
+    name: 'lookup',
+    _ddSpanId: '1234567890abcdef',
+    _ddRootSpanId: 'abcdef1234567890',
+    detail: {
+      hostname: 'example.com'
+    }
+  }
+  for (let i = 0; i < EVENT_COUNT; i++) {
+    EventSource.emitTestEvent({ startTime: performance.now(), ...template })
+  }
+})

integration-tests/profiler/profiler.spec.js

@@ -454,6 +454,33 @@ describe('profiler', () => {
       assert.equal(endpoints.size, 3, encoded)
     })
 
+    it('number of events is limited', async () => {
+      const threads = 1
+      const uploadPeriodSec = 10
+      const samplingPeriodMs = 1000 / 99
+      // Recreates getMaxSamples from packages/dd-trace/src/profiling/profilers/events.js
+      const maxEvents = Math.floor((threads + 2) * uploadPeriodSec * 1000 / samplingPeriodMs)
+
+      // Test will try to force maxEvents + 10 events, we'll assert that only maxEvents are captured.
+      const proc = fork(path.join(cwd, 'profiler/eventlimits.js'), [String(maxEvents + 10)], {
+        cwd,
+        env: {
+          DD_PROFILING_EXPORTERS: 'file',
+          DD_PROFILING_ENABLED: 1,
+          DD_INTERNAL_PROFILING_TIMELINE_SAMPLING_ENABLED: 0, // capture all events
+          DD_TRACE_AGENT_PORT: agent.port,
+          TESTING_PROFILING_EVENTS: 'true', // enable test event source
+          DD_PROFILING_UPLOAD_PERIOD: String(uploadPeriodSec),
+          UV_THREADPOOL_SIZE: String(threads)
+        }
+      })
+
+      await processExitPromise(proc, TIMEOUT)
+
+      const { profile, encoded } = await getLatestProfile(cwd, /^events_.+\.pprof$/)
+      assert.equal(profile.sample.length, maxEvents, encoded)
+    })
+
     it('fs timeline events work', async () => {
       const fsEvents = await gatherFilesystemTimelineEvents(cwd, 'profiler/fstest.js', agent.port)
       assert.equal(fsEvents.length, 6)

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

@@ -4,6 +4,12 @@ const { performance, constants, PerformanceObserver } = require('perf_hooks')
 const { END_TIMESTAMP_LABEL, SPAN_ID_LABEL, LOCAL_ROOT_SPAN_ID_LABEL, encodeProfileAsync } = require('./shared')
 const { Function, Label, Line, Location, Profile, Sample, StringTable, ValueType } = require('pprof-format')
 const { availableParallelism, effectiveLibuvThreadCount } = require('../libuv-size')
+const { getEnvironmentVariables } = require('../../config-helper')
+const dc = require('dc-polyfill')
+
+const testEventChannel = ['true', '1'].includes(getEnvironmentVariables('TESTING_PROFILING_EVENTS'))
+  ? dc.channel('dd-trace:profiling:events-test')
+  : undefined
 
 // perf_hooks uses millis, with fractional part representing nanos. We emit nanos into the pprof file.
 const MS_TO_NS = 1_000_000
@@ -363,6 +369,27 @@ class DatadogInstrumentationEventSource {
   }
 }
 
+class TestEventSource {
+  constructor (eventHandler) {
+    this.eventHandler = eventHandler
+    this.started = false
+  }
+
+  start () {
+    if (!this.started) {
+      testEventChannel.subscribe(this.eventHandler)
+      this.started = true
+    }
+  }
+
+  stop () {
+    if (this.started) {
+      testEventChannel.unsubscribe(this.eventHandler)
+      this.started = false
+    }
+  }
+}
+
 class CompositeEventSource {
   constructor (sources) {
     this.sources = sources
@@ -430,15 +457,21 @@ class EventsProfiler {
       }
     }
 
-    this.eventSource = options.codeHotspotsEnabled
+    const eventSources = options.codeHotspotsEnabled
       // Use Datadog instrumentation to collect events with span IDs. Still use
       // Node API for GC events.
-      ? new CompositeEventSource([
-        new DatadogInstrumentationEventSource(eventHandler, eventFilter),
-        new NodeApiEventSource(filteringEventHandler, ['gc'])
-      ])
+      ? [
+          new DatadogInstrumentationEventSource(eventHandler, eventFilter),
+          new NodeApiEventSource(filteringEventHandler, ['gc']),
+        ]
       // Use Node API instrumentation to collect events without span IDs
-      : new NodeApiEventSource(filteringEventHandler)
+      : [
+          new NodeApiEventSource(filteringEventHandler)
+        ]
+    if (testEventChannel !== undefined) {
+      eventSources.push(new TestEventSource(filteringEventHandler))
+    }
+    this.eventSource = new CompositeEventSource(eventSources)
   }
 
   start () {
@@ -461,6 +494,12 @@ class EventsProfiler {
   encode (profile) {
     return encodeProfileAsync(profile())
   }
+
+  static emitTestEvent (event) {
+    if (testEventChannel !== undefined) {
+      testEventChannel.publish(event)
+    }
+  }
 }
 
 module.exports = EventsProfiler