dd-trace 4.22.0 → 4.24.0

package/packages/dd-trace/src/plugins/util/git.js

@@ -1,10 +1,9 @@
-const { execFileSync } = require('child_process')
+const cp = require('child_process')
 const os = require('os')
 const path = require('path')
 const fs = require('fs')
 
 const log = require('../../log')
-const { sanitizedExec } = require('./exec')
 const {
   GIT_COMMIT_SHA,
   GIT_BRANCH,
@@ -19,10 +18,46 @@ const {
   GIT_COMMIT_AUTHOR_NAME,
   CI_WORKSPACE_PATH
 } = require('./tags')
+const {
+  incrementCountMetric,
+  distributionMetric,
+  TELEMETRY_GIT_COMMAND,
+  TELEMETRY_GIT_COMMAND_MS,
+  TELEMETRY_GIT_COMMAND_ERRORS
+} = require('../../ci-visibility/telemetry')
 const { filterSensitiveInfoFromRepository } = require('./url')
 
 const GIT_REV_LIST_MAX_BUFFER = 8 * 1024 * 1024 // 8MB
 
+function sanitizedExec (
+  cmd,
+  flags,
+  operationMetric,
+  durationMetric,
+  errorMetric
+) {
+  let startTime
+  if (operationMetric) {
+    incrementCountMetric(operationMetric.name, operationMetric.tags)
+  }
+  if (durationMetric) {
+    startTime = Date.now()
+  }
+  try {
+    const result = cp.execFileSync(cmd, flags, { stdio: 'pipe' }).toString().replace(/(\r\n|\n|\r)/gm, '')
+    if (durationMetric) {
+      distributionMetric(durationMetric.name, durationMetric.tags, Date.now() - startTime)
+    }
+    return result
+  } catch (e) {
+    if (errorMetric) {
+      incrementCountMetric(errorMetric.name, { ...errorMetric.tags, exitCode: e.status })
+    }
+    log.error(e)
+    return ''
+  }
+}
+
 function isDirectory (path) {
   try {
     const stats = fs.statSync(path)
@@ -33,7 +68,13 @@ function isDirectory (path) {
 }
 
 function isShallowRepository () {
-  return sanitizedExec('git', ['rev-parse', '--is-shallow-repository']) === 'true'
+  return sanitizedExec(
+    'git',
+    ['rev-parse', '--is-shallow-repository'],
+    { name: TELEMETRY_GIT_COMMAND, tags: { command: 'check_shallow' } },
+    { name: TELEMETRY_GIT_COMMAND_MS, tags: { command: 'check_shallow' } },
+    { name: TELEMETRY_GIT_COMMAND_ERRORS, tags: { command: 'check_shallow' } }
+  ) === 'true'
 }
 
 function getGitVersion () {
@@ -72,50 +113,76 @@ function unshallowRepository () {
     defaultRemoteName
   ]
 
+  incrementCountMetric(TELEMETRY_GIT_COMMAND, { command: 'unshallow' })
+  const start = Date.now()
   try {
-    execFileSync('git', [
+    cp.execFileSync('git', [
       ...baseGitOptions,
       revParseHead
     ], { stdio: 'pipe' })
-  } catch (e) {
+  } catch (err) {
     // If the local HEAD is a commit that has not been pushed to the remote, the above command will fail.
-    log.error(e)
+    log.error(err)
+    incrementCountMetric(TELEMETRY_GIT_COMMAND_ERRORS, { command: 'unshallow', exitCode: err.status })
     const upstreamRemote = sanitizedExec('git', ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}'])
     try {
-      execFileSync('git', [
+      cp.execFileSync('git', [
         ...baseGitOptions,
         upstreamRemote
       ], { stdio: 'pipe' })
-    } catch (e) {
+    } catch (err) {
       // If the CI is working on a detached HEAD or branch tracking hasn’t been set up, the above command will fail.
-      log.error(e)
+      log.error(err)
+      incrementCountMetric(TELEMETRY_GIT_COMMAND_ERRORS, { command: 'unshallow', exitCode: err.status })
       // We use sanitizedExec here because if this last option fails, we'll give up.
-      sanitizedExec('git', baseGitOptions)
+      sanitizedExec(
+        'git',
+        baseGitOptions,
+        null,
+        null,
+        { name: TELEMETRY_GIT_COMMAND_ERRORS, tags: { command: 'unshallow' } } // we log the error in sanitizedExec
+      )
     }
   }
+  distributionMetric(TELEMETRY_GIT_COMMAND_MS, { command: 'unshallow' }, Date.now() - start)
 }
 
 function getRepositoryUrl () {
-  return sanitizedExec('git', ['config', '--get', 'remote.origin.url'])
+  return sanitizedExec(
+    'git',
+    ['config', '--get', 'remote.origin.url'],
+    { name: TELEMETRY_GIT_COMMAND, tags: { command: 'get_repository' } },
+    { name: TELEMETRY_GIT_COMMAND_MS, tags: { command: 'get_repository' } },
+    { name: TELEMETRY_GIT_COMMAND_ERRORS, tags: { command: 'get_repository' } }
+  )
 }
 
 function getLatestCommits () {
+  incrementCountMetric(TELEMETRY_GIT_COMMAND, { command: 'get_local_commits' })
+  const startTime = Date.now()
   try {
-    return execFileSync('git', ['log', '--format=%H', '-n 1000', '--since="1 month ago"'], { stdio: 'pipe' })
+    const result = cp.execFileSync('git', ['log', '--format=%H', '-n 1000', '--since="1 month ago"'], { stdio: 'pipe' })
       .toString()
       .split('\n')
       .filter(commit => commit)
+    distributionMetric(TELEMETRY_GIT_COMMAND_MS, { command: 'get_local_commits' }, Date.now() - startTime)
+    return result
   } catch (err) {
     log.error(`Get latest commits failed: ${err.message}`)
+    incrementCountMetric(TELEMETRY_GIT_COMMAND_ERRORS, { command: 'get_local_commits', errorType: err.status })
     return []
   }
 }
 
 function getCommitsRevList (commitsToExclude, commitsToInclude) {
+  let result = []
+
   const commitsToExcludeString = commitsToExclude.map(commit => `^${commit}`)
 
+  incrementCountMetric(TELEMETRY_GIT_COMMAND, { command: 'get_objects' })
+  const startTime = Date.now()
   try {
-    return execFileSync(
+    result = cp.execFileSync(
       'git',
       [
         'rev-list',
@@ -132,11 +199,14 @@ function getCommitsRevList (commitsToExclude, commitsToInclude) {
       .filter(commit => commit)
   } catch (err) {
     log.error(`Get commits to upload failed: ${err.message}`)
-    return []
+    incrementCountMetric(TELEMETRY_GIT_COMMAND_ERRORS, { command: 'get_objects', errorType: err.status })
   }
+  distributionMetric(TELEMETRY_GIT_COMMAND_MS, { command: 'get_objects' }, Date.now() - startTime)
+  return result
 }
 
 function generatePackFilesForCommits (commitsToUpload) {
+  let result = []
   const tmpFolder = os.tmpdir()
 
   if (!isDirectory(tmpFolder)) {
@@ -148,10 +218,12 @@ function generatePackFilesForCommits (commitsToUpload) {
   const temporaryPath = path.join(tmpFolder, randomPrefix)
   const cwdPath = path.join(process.cwd(), randomPrefix)
 
+  incrementCountMetric(TELEMETRY_GIT_COMMAND, { command: 'pack_objects' })
+  const startTime = Date.now()
   // Generates pack files to upload and
   // returns the ordered list of packfiles' paths
   function execGitPackObjects (targetPath) {
-    return execFileSync(
+    return cp.execFileSync(
       'git',
       [
         'pack-objects',
@@ -164,9 +236,10 @@ function generatePackFilesForCommits (commitsToUpload) {
   }
 
   try {
-    return execGitPackObjects(temporaryPath)
+    result = execGitPackObjects(temporaryPath)
   } catch (err) {
     log.error(err)
+    incrementCountMetric(TELEMETRY_GIT_COMMAND_ERRORS, { command: 'pack_objects', errorType: err.status })
     /**
      * The generation of pack files in the temporary folder (from `os.tmpdir()`)
      * sometimes fails in certain CI setups with the error message
@@ -180,13 +253,15 @@ function generatePackFilesForCommits (commitsToUpload) {
      * TODO: fix issue and remove workaround.
      */
     try {
-      return execGitPackObjects(cwdPath)
+      result = execGitPackObjects(cwdPath)
     } catch (err) {
       log.error(err)
+      incrementCountMetric(TELEMETRY_GIT_COMMAND_ERRORS, { command: 'pack_objects', errorType: err.status })
     }
-
-    return []
   }
+  distributionMetric(TELEMETRY_GIT_COMMAND_MS, { command: 'pack_objects' }, Date.now() - startTime)
+
+  return result
 }
 
 // If there is ciMetadata, it takes precedence.

package/packages/dd-trace/src/priority_sampler.js

@@ -1,9 +1,8 @@
 'use strict'
 
-const RateLimiter = require('./rate_limiter')
 const Sampler = require('./sampler')
-const ext = require('../../../ext')
 const { setSamplingRules } = require('./startup-log')
+const SamplingRule = require('./sampling_rule')
 
 const {
   SAMPLING_MECHANISM_DEFAULT,
@@ -16,14 +15,21 @@ const {
   DECISION_MAKER_KEY
 } = require('./constants')
 
-const SERVICE_NAME = ext.tags.SERVICE_NAME
-const SAMPLING_PRIORITY = ext.tags.SAMPLING_PRIORITY
-const MANUAL_KEEP = ext.tags.MANUAL_KEEP
-const MANUAL_DROP = ext.tags.MANUAL_DROP
-const USER_REJECT = ext.priority.USER_REJECT
-const AUTO_REJECT = ext.priority.AUTO_REJECT
-const AUTO_KEEP = ext.priority.AUTO_KEEP
-const USER_KEEP = ext.priority.USER_KEEP
+const {
+  tags: {
+    MANUAL_KEEP,
+    MANUAL_DROP,
+    SAMPLING_PRIORITY,
+    SERVICE_NAME
+  },
+  priority: {
+    AUTO_REJECT,
+    AUTO_KEEP,
+    USER_REJECT,
+    USER_KEEP
+  }
+} = require('../../../ext')
+
 const DEFAULT_KEY = 'service:,env:'
 
 const defaultSampler = new Sampler(AUTO_KEEP)
@@ -36,8 +42,7 @@ class PrioritySampler {
 
   configure (env, { sampleRate, rateLimit = 100, rules = [] } = {}) {
     this._env = env
-    this._rules = this._normalizeRules(rules, sampleRate)
-    this._limiter = new RateLimiter(rateLimit)
+    this._rules = this._normalizeRules(rules, sampleRate, rateLimit)
 
     setSamplingRules(this._rules)
   }
@@ -104,7 +109,7 @@ class PrioritySampler {
 
   _getPriorityFromAuto (span) {
     const context = this._getContext(span)
-    const rule = this._findRule(context)
+    const rule = this._findRule(span)
 
     return rule
       ? this._getPriorityByRule(context, rule)
@@ -131,15 +136,14 @@ class PrioritySampler {
     context._trace[SAMPLING_RULE_DECISION] = rule.sampleRate
     context._sampling.mechanism = SAMPLING_MECHANISM_RULE
 
-    return rule.sampler.isSampled(context) && this._isSampledByRateLimit(context) ? USER_KEEP : USER_REJECT
-  }
+    const sampled = rule.sample()
+    const priority = sampled ? USER_KEEP : USER_REJECT
 
-  _isSampledByRateLimit (context) {
-    const allowed = this._limiter.isAllowed()
-
-    context._trace[SAMPLING_LIMIT_DECISION] = this._limiter.effectiveRate()
+    if (sampled) {
+      context._trace[SAMPLING_LIMIT_DECISION] = rule.effectiveRate
+    }
 
-    return allowed
+    return priority
   }
 
   _getPriorityByAgent (context) {
@@ -172,33 +176,21 @@ class PrioritySampler {
     }
   }
 
-  _normalizeRules (rules, sampleRate) {
+  _normalizeRules (rules, sampleRate, rateLimit) {
     rules = [].concat(rules || [])
 
     return rules
-      .concat({ sampleRate })
+      .concat({ sampleRate, maxPerSecond: rateLimit })
       .map(rule => ({ ...rule, sampleRate: parseFloat(rule.sampleRate) }))
       .filter(rule => !isNaN(rule.sampleRate))
-      .map(rule => ({ ...rule, sampler: new Sampler(rule.sampleRate) }))
+      .map(SamplingRule.from)
   }
 
-  _findRule (context) {
-    for (let i = 0, l = this._rules.length; i < l; i++) {
-      if (this._matchRule(context, this._rules[i])) return this._rules[i]
+  _findRule (span) {
+    for (const rule of this._rules) {
+      if (rule.match(span)) return rule
     }
   }
-
-  _matchRule (context, rule) {
-    const name = context._name
-    const service = context._tags['service.name']
-
-    if (rule.name instanceof RegExp && !rule.name.test(name)) return false
-    if (typeof rule.name === 'string' && rule.name !== name) return false
-    if (rule.service instanceof RegExp && !rule.service.test(service)) return false
-    if (typeof rule.service === 'string' && rule.service !== service) return false
-
-    return true
-  }
 }
 
 function hasOwn (object, prop) {

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

@@ -35,6 +35,7 @@ class Config {
       DD_PROFILING_HEAP_ENABLED,
       DD_PROFILING_V8_PROFILER_BUG_WORKAROUND,
       DD_PROFILING_WALLTIME_ENABLED,
+      DD_PROFILING_EXPERIMENTAL_CPU_ENABLED,
       DD_PROFILING_EXPERIMENTAL_OOM_MONITORING_ENABLED,
       DD_PROFILING_EXPERIMENTAL_OOM_HEAP_LIMIT_EXTENSION_SIZE,
       DD_PROFILING_EXPERIMENTAL_OOM_MAX_HEAP_EXTENSION_COUNT,
@@ -91,14 +92,24 @@ class Config {
         logger.warn(`${deprecatedEnvVarName} is deprecated. Use DD_PROFILING_${shortVarName} instead.`)
       }
     }
+    // Profiler sampling contexts are not available on Windows, so features
+    // depending on those (code hotspots and endpoint collection) need to default
+    // to false on Windows.
+    const samplingContextsAvailable = process.platform !== 'win32'
+    function checkOptionAllowed (option, description) {
+      if (option && !samplingContextsAvailable) {
+        throw new Error(`${description} not supported on ${process.platform}.`)
+      }
+    }
     this.flushInterval = flushInterval
     this.uploadTimeout = uploadTimeout
     this.sourceMap = sourceMap
     this.debugSourceMaps = isTrue(coalesce(options.debugSourceMaps, DD_PROFILING_DEBUG_SOURCE_MAPS, false))
     this.endpointCollectionEnabled = isTrue(coalesce(options.endpointCollection,
       DD_PROFILING_ENDPOINT_COLLECTION_ENABLED,
-      DD_PROFILING_EXPERIMENTAL_ENDPOINT_COLLECTION_ENABLED, false))
+      DD_PROFILING_EXPERIMENTAL_ENDPOINT_COLLECTION_ENABLED, samplingContextsAvailable))
     logExperimentalVarDeprecation('ENDPOINT_COLLECTION_ENABLED')
+    checkOptionAllowed(this.endpointCollectionEnabled, 'Endpoint collection')
 
     this.pprofPrefix = pprofPrefix
     this.v8ProfilerBugWorkaroundEnabled = isTrue(coalesce(options.v8ProfilerBugWorkaround,
@@ -147,8 +158,12 @@ class Config {
 
     this.codeHotspotsEnabled = isTrue(coalesce(options.codeHotspotsEnabled,
       DD_PROFILING_CODEHOTSPOTS_ENABLED,
-      DD_PROFILING_EXPERIMENTAL_CODEHOTSPOTS_ENABLED, false))
+      DD_PROFILING_EXPERIMENTAL_CODEHOTSPOTS_ENABLED, samplingContextsAvailable))
     logExperimentalVarDeprecation('CODEHOTSPOTS_ENABLED')
+    checkOptionAllowed(this.codeHotspotsEnabled, 'Code hotspots')
+
+    this.cpuProfilingEnabled = isTrue(coalesce(options.cpuProfilingEnabled,
+      DD_PROFILING_EXPERIMENTAL_CPU_ENABLED, false))
 
     this.profilers = ensureProfilers(profilers, this)
   }

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

@@ -75,6 +75,7 @@ class AgentExporter {
       ['tags[]', 'language:javascript'],
       ['tags[]', 'runtime:nodejs'],
       ['tags[]', `runtime_version:${process.version}`],
+      ['tags[]', `process_id:${process.pid}`],
       ['tags[]', `profiler_version:${version}`],
       ['tags[]', 'format:pprof'],
       ...Object.entries(tags).map(([key, value]) => ['tags[]', `${key}:${value}`])

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

@@ -2,6 +2,7 @@
 
 const fs = require('fs')
 const { promisify } = require('util')
+const { threadId } = require('worker_threads')
 const writeFile = promisify(fs.writeFile)
 
 function formatDateTime (t) {
@@ -19,7 +20,7 @@ class FileExporter {
     const types = Object.keys(profiles)
     const dateStr = formatDateTime(end)
     const tasks = types.map(type => {
-      return writeFile(`${this._pprofPrefix}${type}_${dateStr}.pprof`, profiles[type])
+      return writeFile(`${this._pprofPrefix}${type}_worker_${threadId}_${dateStr}.pprof`, profiles[type])
     })
 
     return Promise.all(tasks)

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

@@ -3,6 +3,7 @@
 const { EventEmitter } = require('events')
 const { Config } = require('./config')
 const { snapshotKinds } = require('./constants')
+const { threadNamePrefix } = require('./profilers/shared')
 
 function maybeSourceMap (sourceMap, SourceMapper, debug) {
   if (!sourceMap) return
@@ -68,7 +69,7 @@ class Profiler extends EventEmitter {
           mapper,
           nearOOMCallback: this._nearOOMExport.bind(this)
         })
-        this._logger.debug(`Started ${profiler.type} profiler`)
+        this._logger.debug(`Started ${profiler.type} profiler in ${threadNamePrefix} thread`)
       }
 
       this._capture(this._timeoutInterval, start)
@@ -97,7 +98,7 @@ class Profiler extends EventEmitter {
 
     // collect and export current profiles
     // once collect returns, profilers can be safely stopped
-    this._collect(snapshotKinds.ON_SHUTDOWN)
+    this._collect(snapshotKinds.ON_SHUTDOWN, false)
     this._stop()
   }
 
@@ -108,13 +109,11 @@ class Profiler extends EventEmitter {
 
     for (const profiler of this._config.profilers) {
       profiler.stop()
-      this._logger.debug(`Stopped ${profiler.type} profiler`)
+      this._logger.debug(`Stopped ${profiler.type} profiler in ${threadNamePrefix} thread`)
     }
 
     clearTimeout(this._timer)
     this._timer = undefined
-
-    return this
   }
 
   _capture (timeout, start) {
@@ -128,18 +127,21 @@ class Profiler extends EventEmitter {
     }
   }
 
-  async _collect (snapshotKind) {
+  async _collect (snapshotKind, restart = true) {
     if (!this._enabled) return
 
-    const start = this._lastStart
-    const end = new Date()
+    const startDate = this._lastStart
+    const endDate = new Date()
     const profiles = []
     const encodedProfiles = {}
 
     try {
       // collect profiles synchronously so that profilers can be safely stopped asynchronously
       for (const profiler of this._config.profilers) {
-        const profile = profiler.profile(start, end)
+        const profile = profiler.profile(restart, startDate, endDate)
+        if (!restart) {
+          this._logger.debug(`Stopped ${profiler.type} profiler in ${threadNamePrefix} thread`)
+        }
         if (!profile) continue
         profiles.push({ profiler, profile })
       }
@@ -155,8 +157,10 @@ class Profiler extends EventEmitter {
         })
       }
 
-      this._capture(this._timeoutInterval, end)
-      await this._submit(encodedProfiles, start, end, snapshotKind)
+      if (restart) {
+        this._capture(this._timeoutInterval, endDate)
+      }
+      await this._submit(encodedProfiles, startDate, endDate, snapshotKind)
       this._logger.debug('Submitted profiles')
     } catch (err) {
       this._logger.error(err)
@@ -196,10 +200,10 @@ class ServerlessProfiler extends Profiler {
     this._flushAfterIntervals = this._config.flushInterval / 1000
   }
 
-  async _collect (snapshotKind) {
-    if (this._profiledIntervals >= this._flushAfterIntervals) {
+  async _collect (snapshotKind, restart = true) {
+    if (this._profiledIntervals >= this._flushAfterIntervals || !restart) {
       this._profiledIntervals = 0
-      await super._collect(snapshotKind)
+      await super._collect(snapshotKind, restart)
     } else {
       this._profiledIntervals += 1
       this._capture(this._timeoutInterval, new Date())

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

@@ -1,4 +1,4 @@
-const { performance, constants, PerformanceObserver } = require('node:perf_hooks')
+const { performance, constants, PerformanceObserver } = require('perf_hooks')
 const { END_TIMESTAMP_LABEL } = require('./shared')
 const semver = require('semver')
 const { Function, Label, Line, Location, Profile, Sample, StringTable, ValueType } = require('pprof-format')
@@ -159,22 +159,24 @@ class EventsProfiler {
   }
 
   start () {
+    // if already started, do nothing
+    if (this._observer) return
+
     function add (items) {
       this.entries.push(...items.getEntries())
     }
-    if (!this._observer) {
-      this._observer = new PerformanceObserver(add.bind(this))
-    }
+    this._observer = new PerformanceObserver(add.bind(this))
     this._observer.observe({ entryTypes: Object.keys(decoratorTypes) })
   }
 
   stop () {
     if (this._observer) {
       this._observer.disconnect()
+      this._observer = undefined
     }
   }
 
-  profile (startDate, endDate) {
+  profile (restart, startDate, endDate) {
     if (this.entries.length === 0) {
       // No events in the period; don't produce a profile
       return null
@@ -243,6 +245,10 @@ class EventsProfiler {
       unit: stringTable.dedup(pprofValueUnit)
     })
 
+    if (!restart) {
+      this.stop()
+    }
+
     return new Profile({
       sampleType: [timeValueType],
       timeNanos: endDate.getTime() * MS_TO_NS,

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const { isMainThread, threadId } = require('node:worker_threads')
+const { isMainThread, threadId } = require('worker_threads')
 
 const END_TIMESTAMP_LABEL = 'end_timestamp_ns'
 const THREAD_NAME_LABEL = 'thread name'
@@ -29,11 +29,17 @@ function cacheThreadLabels () {
   }
 }
 
+function getNonJSThreadsLabels () {
+  return { [THREAD_NAME_LABEL]: 'Non-JS threads', [THREAD_ID_LABEL]: 'NA', [OS_THREAD_ID_LABEL]: 'NA' }
+}
+
 module.exports = {
   END_TIMESTAMP_LABEL,
   THREAD_NAME_LABEL,
   THREAD_ID_LABEL,
+  OS_THREAD_ID_LABEL,
   threadNamePrefix,
   eventLoopThreadName,
+  getNonJSThreadsLabels,
   getThreadLabels: cacheThreadLabels()
 }

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

@@ -14,9 +14,12 @@ class NativeSpaceProfiler {
     this._stackDepth = options.stackDepth || 64
     this._pprof = undefined
     this._oomMonitoring = options.oomMonitoring || {}
+    this._started = false
   }
 
   start ({ mapper, nearOOMCallback } = {}) {
+    if (this._started) return
+
     this._mapper = mapper
     this._pprof = require('@datadog/pprof')
     this._pprof.heap.start(this._samplingInterval, this._stackDepth)
@@ -31,10 +34,16 @@ class NativeSpaceProfiler {
         strategiesToCallbackMode(strategies, this._pprof.heap.CallbackMode)
       )
     }
+
+    this._started = true
   }
 
-  profile () {
-    return this._pprof.heap.profile(undefined, this._mapper, getThreadLabels)
+  profile (restart) {
+    const profile = this._pprof.heap.profile(undefined, this._mapper, getThreadLabels)
+    if (!restart) {
+      this.stop()
+    }
+    return profile
   }
 
   encode (profile) {
@@ -42,7 +51,13 @@ class NativeSpaceProfiler {
   }
 
   stop () {
+    if (!this._started) return
     this._pprof.heap.stop()
+    this._started = false
+  }
+
+  isStarted () {
+    return this._started
   }
 }