dd-trace 4.18.0 → 5.6.0

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

@@ -48,10 +48,17 @@ const TEST_MODULE_ID = 'test_module_id'
 const TEST_SUITE_ID = 'test_suite_id'
 const TEST_TOOLCHAIN = 'test.toolchain'
 const TEST_SKIPPED_BY_ITR = 'test.skipped_by_itr'
+// Browser used in browser test. Namespaced by test.configuration because it affects the fingerprint
+const TEST_CONFIGURATION_BROWSER_NAME = 'test.configuration.browser_name'
+// Early flake detection
+const TEST_IS_NEW = 'test.is_new'
+const TEST_EARLY_FLAKE_IS_RETRY = 'test.early_flake.is_retry'
+const TEST_EARLY_FLAKE_IS_ENABLED = 'test.early_flake.is_enabled'
 
 const CI_APP_ORIGIN = 'ciapp-test'
 
 const JEST_TEST_RUNNER = 'test.jest.test_runner'
+const JEST_DISPLAY_NAME = 'test.jest.display_name'
 
 const TEST_ITR_TESTS_SKIPPED = '_dd.ci.itr.tests_skipped'
 const TEST_ITR_SKIPPING_ENABLED = 'test.itr.tests_skipping.enabled'
@@ -60,6 +67,7 @@ const TEST_ITR_SKIPPING_COUNT = 'test.itr.tests_skipping.count'
 const TEST_CODE_COVERAGE_ENABLED = 'test.code_coverage.enabled'
 const TEST_ITR_UNSKIPPABLE = 'test.itr.unskippable'
 const TEST_ITR_FORCED_RUN = 'test.itr.forced_run'
+const ITR_CORRELATION_ID = 'itr_correlation_id'
 
 const TEST_CODE_COVERAGE_LINES_PCT = 'test.code_coverage.lines_pct'
 
@@ -67,11 +75,16 @@ const TEST_CODE_COVERAGE_LINES_PCT = 'test.code_coverage.lines_pct'
 const JEST_WORKER_TRACE_PAYLOAD_CODE = 60
 const JEST_WORKER_COVERAGE_PAYLOAD_CODE = 61
 
+// Early flake detection util strings
+const EFD_STRING = "Retried by Datadog's Early Flake Detection"
+const EFD_TEST_NAME_REGEX = new RegExp(EFD_STRING + ' \\(#\\d+\\): ', 'g')
+
 module.exports = {
   TEST_CODE_OWNERS,
   TEST_FRAMEWORK,
   TEST_FRAMEWORK_VERSION,
   JEST_TEST_RUNNER,
+  JEST_DISPLAY_NAME,
   TEST_TYPE,
   TEST_NAME,
   TEST_SUITE,
@@ -86,6 +99,10 @@ module.exports = {
   JEST_WORKER_COVERAGE_PAYLOAD_CODE,
   TEST_SOURCE_START,
   TEST_SKIPPED_BY_ITR,
+  TEST_CONFIGURATION_BROWSER_NAME,
+  TEST_IS_NEW,
+  TEST_EARLY_FLAKE_IS_RETRY,
+  TEST_EARLY_FLAKE_IS_ENABLED,
   getTestEnvironmentMetadata,
   getTestParametersString,
   finishAllTraceSpans,
@@ -111,6 +128,7 @@ module.exports = {
   TEST_CODE_COVERAGE_LINES_PCT,
   TEST_ITR_UNSKIPPABLE,
   TEST_ITR_FORCED_RUN,
+  ITR_CORRELATION_ID,
   addIntelligentTestRunnerSpanTags,
   getCoveredFilenamesFromCoverage,
   resetCoverage,
@@ -119,7 +137,11 @@ module.exports = {
   getTestLineStart,
   getCallSites,
   removeInvalidMetadata,
-  parseAnnotations
+  parseAnnotations,
+  EFD_STRING,
+  EFD_TEST_NAME_REGEX,
+  removeEfdStringFromTestName,
+  addEfdStringToTestName
 }
 
 // Returns pkg manager and its version, separated by '-', e.g. npm-8.15.0 or yarn-1.22.19
@@ -251,7 +273,6 @@ function getTestCommonTags (name, suite, version, testFramework) {
     [SAMPLING_PRIORITY]: AUTO_KEEP,
     [TEST_NAME]: name,
     [TEST_SUITE]: suite,
-    [TEST_SOURCE_FILE]: suite,
     [RESOURCE_NAME]: `${suite}.${name}`,
     [TEST_FRAMEWORK_VERSION]: version,
     [LIBRARY_VERSION]: ddTraceVersion
@@ -279,16 +300,36 @@ const POSSIBLE_CODEOWNERS_LOCATIONS = [
   '.gitlab/CODEOWNERS'
 ]
 
-function getCodeOwnersFileEntries (rootDir = process.cwd()) {
-  let codeOwnersContent
-
-  POSSIBLE_CODEOWNERS_LOCATIONS.forEach(location => {
+function readCodeOwners (rootDir) {
+  for (const location of POSSIBLE_CODEOWNERS_LOCATIONS) {
     try {
-      codeOwnersContent = fs.readFileSync(`${rootDir}/${location}`).toString()
+      return fs.readFileSync(path.join(rootDir, location)).toString()
     } catch (e) {
       // retry with next path
     }
-  })
+  }
+  return ''
+}
+
+function getCodeOwnersFileEntries (rootDir) {
+  let codeOwnersContent
+  let usedRootDir = rootDir
+  let isTriedCwd = false
+
+  const processCwd = process.cwd()
+
+  if (!usedRootDir || usedRootDir === processCwd) {
+    usedRootDir = processCwd
+    isTriedCwd = true
+  }
+
+  codeOwnersContent = readCodeOwners(usedRootDir)
+
+  // If we haven't found CODEOWNERS in the provided root dir, we try with process.cwd()
+  if (!codeOwnersContent && !isTriedCwd) {
+    codeOwnersContent = readCodeOwners(processCwd)
+  }
+
   if (!codeOwnersContent) {
     return null
   }
@@ -397,8 +438,9 @@ function addIntelligentTestRunnerSpanTags (
     testModuleSpan.setTag(TEST_ITR_FORCED_RUN, 'true')
   }
 
-  // If suites have been skipped we don't want to report the total coverage, as it will be wrong
-  if (testCodeCoverageLinesTotal !== undefined && !isSuitesSkipped) {
+  // This will not be reported unless the user has manually added code coverage.
+  // This is always the case for Mocha and Cucumber, but not for Jest.
+  if (testCodeCoverageLinesTotal !== undefined) {
     testSessionSpan.setTag(TEST_CODE_COVERAGE_LINES_PCT, testCodeCoverageLinesTotal)
     testModuleSpan.setTag(TEST_CODE_COVERAGE_LINES_PCT, testCodeCoverageLinesTotal)
   }
@@ -520,3 +562,11 @@ function parseAnnotations (annotations) {
     return tags
   }, {})
 }
+
+function addEfdStringToTestName (testName, numAttempt) {
+  return `${EFD_STRING} (#${numAttempt}): ${testName}`
+}
+
+function removeEfdStringFromTestName (testName) {
+  return testName.replace(EFD_TEST_NAME_REGEX, '')
+}

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

@@ -0,0 +1,26 @@
+const { URL } = require('url')
+
+function filterSensitiveInfoFromRepository (repositoryUrl) {
+  if (!repositoryUrl) {
+    return ''
+  }
+  if (repositoryUrl.startsWith('git@')) {
+    return repositoryUrl
+  }
+
+  // Remove the username from ssh URLs
+  if (repositoryUrl.startsWith('ssh://')) {
+    const sshRegex = /^(ssh:\/\/)[^@/]*@/
+    return repositoryUrl.replace(sshRegex, '$1')
+  }
+
+  try {
+    const { protocol, host, pathname } = new URL(repositoryUrl)
+
+    return `${protocol}//${host}${pathname === '/' ? '' : pathname}`
+  } catch (e) {
+    return ''
+  }
+}
+
+module.exports = { filterSensitiveInfoFromRepository }

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

@@ -13,7 +13,7 @@ const {
 } = require('./tags')
 
 const { normalizeRef } = require('./ci')
-const { URL } = require('url')
+const { filterSensitiveInfoFromRepository } = require('./url')
 
 function removeEmptyValues (tags) {
   return Object.keys(tags).reduce((filteredTags, tag) => {
@@ -27,23 +27,11 @@ function removeEmptyValues (tags) {
   }, {})
 }
 
-function filterSensitiveInfoFromRepository (repositoryUrl) {
-  try {
-    if (repositoryUrl.startsWith('git@')) {
-      return repositoryUrl
-    }
-    const { protocol, hostname, pathname } = new URL(repositoryUrl)
-
-    return `${protocol}//${hostname}${pathname}`
-  } catch (e) {
-    return repositoryUrl
-  }
-}
-
-// The regex is extracted from
+// The regex is inspired by
 // https://github.com/jonschlinkert/is-git-url/blob/396965ffabf2f46656c8af4c47bef1d69f09292e/index.js#L9C15-L9C87
+// The `.git` suffix is optional in this version
 function validateGitRepositoryUrl (repoUrl) {
-  return /(?:git|ssh|https?|git@[-\w.]+):(\/\/)?(.*?)(\.git)(\/?|#[-\d\w._]+?)$/.test(repoUrl)
+  return /(?:git|ssh|https?|git@[-\w.]+):(\/\/)?(.*?)(\/?|#[-\d\w._]+?)$/.test(repoUrl)
 }
 
 function validateGitCommitSha (gitCommitSha) {

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const uniq = require('lodash.uniq')
+const uniq = require('../../../../datadog-core/src/utils/src/uniq')
 const analyticsSampler = require('../../analytics_sampler')
 const FORMAT_HTTP_HEADERS = 'http_headers'
 const log = require('../../log')

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/profiler.js

@@ -8,7 +8,7 @@ process.once('beforeExit', () => { profiler.stop() })
 
 module.exports = {
   start: config => {
-    const { service, version, env, url, hostname, port, tags } = config
+    const { service, version, env, url, hostname, port, tags, repositoryUrl, commitSHA } = config
     const { enabled, sourceMap, exporters } = config.profiling
     const logger = {
       debug: (message) => log.debug(message),
@@ -17,7 +17,7 @@ module.exports = {
       error: (message) => log.error(message)
     }
 
-    profiler.start({
+    return profiler.start({
       enabled,
       service,
       version,
@@ -28,7 +28,9 @@ module.exports = {
       url,
       hostname,
       port,
-      tags
+      tags,
+      repositoryUrl,
+      commitSHA
     })
   },
 

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

@@ -9,38 +9,43 @@ const { FileExporter } = require('./exporters/file')
 const { ConsoleLogger } = require('./loggers/console')
 const WallProfiler = require('./profilers/wall')
 const SpaceProfiler = require('./profilers/space')
+const EventsProfiler = require('./profilers/events')
 const { oomExportStrategies, snapshotKinds } = require('./constants')
+const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('../plugins/util/tags')
 const { tagger } = require('./tagger')
 const { isFalse, isTrue } = require('../util')
 
 class Config {
   constructor (options = {}) {
     const {
-      DD_PROFILING_ENABLED,
-      DD_PROFILING_PROFILERS,
-      DD_ENV,
-      DD_TAGS,
-      DD_SERVICE,
-      DD_VERSION,
-      DD_TRACE_AGENT_URL,
       DD_AGENT_HOST,
-      DD_TRACE_AGENT_PORT,
+      DD_ENV,
+      DD_PROFILING_CODEHOTSPOTS_ENABLED,
       DD_PROFILING_DEBUG_SOURCE_MAPS,
-      DD_PROFILING_UPLOAD_TIMEOUT,
+      DD_PROFILING_ENABLED,
+      DD_PROFILING_ENDPOINT_COLLECTION_ENABLED,
+      DD_PROFILING_EXPERIMENTAL_CODEHOTSPOTS_ENABLED,
+      DD_PROFILING_EXPERIMENTAL_CPU_ENABLED,
+      DD_PROFILING_EXPERIMENTAL_ENDPOINT_COLLECTION_ENABLED,
+      DD_PROFILING_EXPERIMENTAL_OOM_EXPORT_STRATEGIES,
+      DD_PROFILING_EXPERIMENTAL_OOM_HEAP_LIMIT_EXTENSION_SIZE,
+      DD_PROFILING_EXPERIMENTAL_OOM_MAX_HEAP_EXTENSION_COUNT,
+      DD_PROFILING_EXPERIMENTAL_OOM_MONITORING_ENABLED,
+      DD_PROFILING_EXPERIMENTAL_TIMELINE_ENABLED,
+      DD_PROFILING_HEAP_ENABLED,
+      DD_PROFILING_PPROF_PREFIX,
+      DD_PROFILING_PROFILERS,
       DD_PROFILING_SOURCE_MAP,
+      DD_PROFILING_TIMELINE_ENABLED,
       DD_PROFILING_UPLOAD_PERIOD,
-      DD_PROFILING_PPROF_PREFIX,
-      DD_PROFILING_HEAP_ENABLED,
+      DD_PROFILING_UPLOAD_TIMEOUT,
       DD_PROFILING_V8_PROFILER_BUG_WORKAROUND,
       DD_PROFILING_WALLTIME_ENABLED,
-      DD_PROFILING_EXPERIMENTAL_OOM_MONITORING_ENABLED,
-      DD_PROFILING_EXPERIMENTAL_OOM_HEAP_LIMIT_EXTENSION_SIZE,
-      DD_PROFILING_EXPERIMENTAL_OOM_MAX_HEAP_EXTENSION_COUNT,
-      DD_PROFILING_EXPERIMENTAL_OOM_EXPORT_STRATEGIES,
-      DD_PROFILING_CODEHOTSPOTS_ENABLED,
-      DD_PROFILING_ENDPOINT_COLLECTION_ENABLED,
-      DD_PROFILING_EXPERIMENTAL_CODEHOTSPOTS_ENABLED,
-      DD_PROFILING_EXPERIMENTAL_ENDPOINT_COLLECTION_ENABLED
+      DD_SERVICE,
+      DD_TAGS,
+      DD_TRACE_AGENT_PORT,
+      DD_TRACE_AGENT_URL,
+      DD_VERSION
     } = process.env
 
     const enabled = isTrue(coalesce(options.enabled, DD_PROFILING_ENABLED, true))
@@ -70,6 +75,13 @@ class Config {
       tagger.parse(options.tags),
       tagger.parse({ env, host, service, version, functionname })
     )
+
+    // Add source code integration tags if available
+    if (options.repositoryUrl && options.commitSHA) {
+      this.tags[GIT_REPOSITORY_URL] = options.repositoryUrl
+      this.tags[GIT_COMMIT_SHA] = options.commitSHA
+    }
+
     this.logger = ensureLogger(options.logger)
     const logger = this.logger
     function logExperimentalVarDeprecation (shortVarName) {
@@ -81,14 +93,28 @@ 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, condition) {
+      if (option && !condition) {
+        throw new Error(`${description} not supported on ${process.platform}.`)
+      }
+    }
+    function checkOptionWithSamplingContextAllowed (option, description) {
+      checkOptionAllowed(option, description, samplingContextsAvailable)
+    }
+
     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')
+    checkOptionWithSamplingContextAllowed(this.endpointCollectionEnabled, 'Endpoint collection')
 
     this.pprofPrefix = pprofPrefix
     this.v8ProfilerBugWorkaroundEnabled = isTrue(coalesce(options.v8ProfilerBugWorkaround,
@@ -105,8 +131,13 @@ class Config {
       new AgentExporter(this)
     ], this)
 
+    // OOM monitoring does not work well on Windows, so it is disabled by default.
+    const oomMonitoringSupported = process.platform !== 'win32'
+
     const oomMonitoringEnabled = isTrue(coalesce(options.oomMonitoring,
-      DD_PROFILING_EXPERIMENTAL_OOM_MONITORING_ENABLED, true))
+      DD_PROFILING_EXPERIMENTAL_OOM_MONITORING_ENABLED, oomMonitoringSupported))
+    checkOptionAllowed(oomMonitoringEnabled, 'OOM monitoring', oomMonitoringSupported)
+
     const heapLimitExtensionSize = coalesce(options.oomHeapLimitExtensionSize,
       Number(DD_PROFILING_EXPERIMENTAL_OOM_HEAP_LIMIT_EXTENSION_SIZE), 0)
     const maxHeapExtensionCount = coalesce(options.oomMaxHeapExtensionCount,
@@ -126,12 +157,27 @@ class Config {
 
     const profilers = options.profilers
       ? options.profilers
-      : getProfilers({ DD_PROFILING_HEAP_ENABLED, DD_PROFILING_WALLTIME_ENABLED, DD_PROFILING_PROFILERS })
+      : getProfilers({
+        DD_PROFILING_HEAP_ENABLED,
+        DD_PROFILING_WALLTIME_ENABLED,
+        DD_PROFILING_PROFILERS
+      })
+
+    this.timelineEnabled = isTrue(coalesce(options.timelineEnabled,
+      DD_PROFILING_TIMELINE_ENABLED,
+      DD_PROFILING_EXPERIMENTAL_TIMELINE_ENABLED, false))
+    logExperimentalVarDeprecation('TIMELINE_ENABLED')
+    checkOptionWithSamplingContextAllowed(this.timelineEnabled, 'Timeline view')
 
     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')
+    checkOptionWithSamplingContextAllowed(this.codeHotspotsEnabled, 'Code hotspots')
+
+    this.cpuProfilingEnabled = isTrue(coalesce(options.cpuProfilingEnabled,
+      DD_PROFILING_EXPERIMENTAL_CPU_ENABLED, false))
+    checkOptionWithSamplingContextAllowed(this.cpuProfilingEnabled, 'CPU profiling')
 
     this.profilers = ensureProfilers(profilers, this)
   }
@@ -139,7 +185,9 @@ class Config {
 
 module.exports = { Config }
 
-function getProfilers ({ DD_PROFILING_HEAP_ENABLED, DD_PROFILING_WALLTIME_ENABLED, DD_PROFILING_PROFILERS }) {
+function getProfilers ({
+  DD_PROFILING_HEAP_ENABLED, DD_PROFILING_WALLTIME_ENABLED, DD_PROFILING_PROFILERS
+}) {
   // First consider "legacy" DD_PROFILING_PROFILERS env variable, defaulting to wall + space
   // Use a Set to avoid duplicates
   const profilers = new Set(coalesce(DD_PROFILING_PROFILERS, 'wall,space').split(','))
@@ -240,6 +288,11 @@ function ensureProfilers (profilers, options) {
     }
   }
 
+  // Events profiler is a profiler for timeline events
+  if (options.timelineEnabled) {
+    profilers.push(new EventsProfiler(options))
+  }
+
   // Filter out any invalid profilers
   return profilers.filter(v => v)
 }