dd-trace 5.0.0-pre-e2df7ec → 5.0.0

package/README.md

@@ -218,7 +218,7 @@ esbuild.build({
   outfile: 'out.js',
   plugins: [ddPlugin],
   platform: 'node', // allows built-in modules to be required
-  target: ['node16']
+  target: ['node18']
 }).catch((err) => {
   console.error(err)
   process.exit(1)

package/index.d.ts

@@ -83,8 +83,9 @@ export declare interface Tracer extends opentracing.Tracer {
    * unless there is already an active span or `childOf` option. Note that this
    * option is deprecated and has been removed in version 4.0.
    */
-  trace<T> (name: string, fn: (span?: Span, fn?: (error?: Error) => any) => T): T;
-  trace<T> (name: string, options: TraceOptions & SpanOptions, fn: (span?: Span, done?: (error?: Error) => string) => T): T;
+  trace<T> (name: string, fn: (span: Span) => T): T;
+  trace<T> (name: string, fn: (span: Span, done: (error?: Error) => void) => T): T;
+  trace<T> (name: string, options: TraceOptions & SpanOptions, fn: (span?: Span, done?: (error?: Error) => void) => T): T;
 
   /**
    * Wrap a function to automatically create a span activated on its
@@ -883,7 +884,7 @@ interface Analyzable {
   measured?: boolean | { [key: string]: boolean };
 }
 
-declare namespace plugins {
+export declare namespace plugins {
   /** @hidden */
   interface Integration {
     /**
@@ -1380,7 +1381,8 @@ declare namespace plugins {
    */
   interface ioredis extends Instrumentation {
     /**
-     * List of commands that should be instrumented.
+     * List of commands that should be instrumented. Commands must be in
+     * lowercase for example 'xread'.
      *
      * @default /^.*$/
      */
@@ -1396,7 +1398,8 @@ declare namespace plugins {
 
     /**
      * List of commands that should not be instrumented. Takes precedence over
-     * allowlist if a command matches an entry in both.
+     * allowlist if a command matches an entry in both. Commands must be in
+     * lowercase for example 'xread'.
      *
      * @default []
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.0.0-pre-e2df7ec",
+  "version": "5.0.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -65,27 +65,27 @@
   },
   "homepage": "https://github.com/DataDog/dd-trace-js#readme",
   "engines": {
-    "node": ">=16"
+    "node": ">=18"
   },
   "dependencies": {
     "@datadog/native-appsec": "6.0.0",
     "@datadog/native-iast-rewriter": "2.2.2",
     "@datadog/native-iast-taint-tracking": "1.6.4",
     "@datadog/native-metrics": "^2.0.0",
-    "@datadog/pprof": "4.1.0",
+    "@datadog/pprof": "5.0.0",
     "@datadog/sketches-js": "^2.1.0",
     "@opentelemetry/api": "^1.0.0",
     "@opentelemetry/core": "^1.14.0",
     "crypto-randomuuid": "^1.0.0",
     "dc-polyfill": "^0.1.2",
     "ignore": "^5.2.4",
-    "import-in-the-middle": "^1.4.2",
+    "import-in-the-middle": "^1.7.1",
     "int64-buffer": "^0.1.9",
     "ipaddr.js": "^2.1.0",
     "istanbul-lib-coverage": "3.2.0",
     "jest-docblock": "^29.7.0",
     "koalas": "^1.0.2",
-    "limiter": "^1.1.4",
+    "limiter": "1.1.5",
     "lodash.kebabcase": "^4.1.1",
     "lodash.pick": "^4.4.0",
     "lodash.sortby": "^4.7.0",
@@ -99,12 +99,12 @@
     "path-to-regexp": "^0.1.2",
     "pprof-format": "^2.0.7",
     "protobufjs": "^7.2.5",
-    "tlhunter-sorted-set": "^0.1.0",
     "retry": "^0.13.1",
-    "semver": "^7.5.4"
+    "semver": "^7.5.4",
+    "tlhunter-sorted-set": "^0.1.0"
   },
   "devDependencies": {
-    "@types/node": ">=16",
+    "@types/node": ">=18",
     "autocannon": "^4.5.2",
     "aws-sdk": "^2.1446.0",
     "axios": "^0.21.2",

package/packages/datadog-instrumentations/src/couchbase.js

@@ -252,9 +252,10 @@ addHook({ name: 'couchbase', file: 'lib/cluster.js', versions: ['^3.0.7', '^3.1.
   return Cluster
 })
 
-// semver >=3.2.0
+// semver >=3.2.2
+// NOTE: <3.2.2 segfaults on cluster.close() https://issues.couchbase.com/browse/JSCBC-936
 
-addHook({ name: 'couchbase', file: 'dist/collection.js', versions: ['>=3.2.0'] }, collection => {
+addHook({ name: 'couchbase', file: 'dist/collection.js', versions: ['>=3.2.2'] }, collection => {
   const Collection = collection.Collection
 
   wrapAllNames(['upsert', 'insert', 'replace'], name => {
@@ -264,7 +265,7 @@ addHook({ name: 'couchbase', file: 'dist/collection.js', versions: ['>=3.2.0'] }
   return collection
 })
 
-addHook({ name: 'couchbase', file: 'dist/bucket.js', versions: ['>=3.2.0'] }, bucket => {
+addHook({ name: 'couchbase', file: 'dist/bucket.js', versions: ['>=3.2.2'] }, bucket => {
   const Bucket = bucket.Bucket
   shimmer.wrap(Bucket.prototype, 'collection', getCollection => {
     return function () {
@@ -278,7 +279,7 @@ addHook({ name: 'couchbase', file: 'dist/bucket.js', versions: ['>=3.2.0'] }, bu
   return bucket
 })
 
-addHook({ name: 'couchbase', file: 'dist/cluster.js', versions: ['3.2.0 - 3.2.1', '>=3.2.2'] }, (cluster) => {
+addHook({ name: 'couchbase', file: 'dist/cluster.js', versions: ['>=3.2.2'] }, (cluster) => {
   const Cluster = cluster.Cluster
 
   shimmer.wrap(Cluster.prototype, 'query', wrapV3Query)

package/packages/datadog-instrumentations/src/jest.js

@@ -495,6 +495,8 @@ addHook({
       _ddTestModuleId,
       _ddTestSessionId,
       _ddTestCommand,
+      _ddForcedToRun,
+      _ddUnskippable,
       ...restOfTestEnvironmentOptions
     } = testEnvironmentOptions
 

package/packages/datadog-plugin-google-cloud-pubsub/src/consumer.js

@@ -28,6 +28,8 @@ class GoogleCloudPubsubConsumerPlugin extends ConsumerPlugin {
   finish (message) {
     const span = this.activeSpan
 
+    if (!span) return
+
     if (message.message._handled) {
       span.setTag('pubsub.ack', 1)
     }

package/packages/datadog-plugin-jest/src/index.js

@@ -38,6 +38,20 @@ class JestPlugin extends CiPlugin {
     return 'jest'
   }
 
+  // The lists are the same for every test suite, so we can cache them
+  getUnskippableSuites (unskippableSuitesList) {
+    if (!this.unskippableSuites) {
+      this.unskippableSuites = JSON.parse(unskippableSuitesList)
+    }
+    return this.unskippableSuites
+  }
+  getForcedToRunSuites (forcedToRunSuitesList) {
+    if (!this.forcedToRunSuites) {
+      this.forcedToRunSuites = JSON.parse(forcedToRunSuitesList)
+    }
+    return this.forcedToRunSuites
+  }
+
   constructor (...args) {
     super(...args)
 
@@ -128,11 +142,17 @@ class JestPlugin extends CiPlugin {
       const testSuiteMetadata = getTestSuiteCommonTags(testCommand, frameworkVersion, testSuite, 'jest')
 
       if (_ddUnskippable) {
-        this.telemetry.count(TELEMETRY_ITR_UNSKIPPABLE, { testLevel: 'suite' })
-        testSuiteMetadata[TEST_ITR_UNSKIPPABLE] = 'true'
+        const unskippableSuites = this.getUnskippableSuites(_ddUnskippable)
+        if (unskippableSuites[testSuite]) {
+          this.telemetry.count(TELEMETRY_ITR_UNSKIPPABLE, { testLevel: 'suite' })
+          testSuiteMetadata[TEST_ITR_UNSKIPPABLE] = 'true'
+        }
         if (_ddForcedToRun) {
-          this.telemetry.count(TELEMETRY_ITR_FORCED_TO_RUN, { testLevel: 'suite' })
-          testSuiteMetadata[TEST_ITR_FORCED_RUN] = 'true'
+          const forcedToRunSuites = this.getForcedToRunSuites(_ddForcedToRun)
+          if (forcedToRunSuites[testSuite]) {
+            this.telemetry.count(TELEMETRY_ITR_FORCED_TO_RUN, { testLevel: 'suite' })
+            testSuiteMetadata[TEST_ITR_FORCED_RUN] = 'true'
+          }
         }
       }
 

package/packages/datadog-plugin-jest/src/util.js

@@ -77,30 +77,52 @@ function isMarkedAsUnskippable (test) {
 }
 
 function getJestSuitesToRun (skippableSuites, originalTests, rootDir) {
-  return originalTests.reduce((acc, test) => {
+  const unskippableSuites = {}
+  const forcedToRunSuites = {}
+
+  const skippedSuites = []
+  const suitesToRun = []
+
+  for (const test of originalTests) {
     const relativePath = getTestSuitePath(test.path, rootDir)
     const shouldBeSkipped = skippableSuites.includes(relativePath)
-
     if (isMarkedAsUnskippable(test)) {
-      acc.suitesToRun.push(test)
-      if (test?.context?.config?.testEnvironmentOptions) {
-        test.context.config.testEnvironmentOptions['_ddUnskippable'] = true
-        acc.hasUnskippableSuites = true
-        if (shouldBeSkipped) {
-          test.context.config.testEnvironmentOptions['_ddForcedToRun'] = true
-          acc.hasForcedToRunSuites = true
-        }
+      suitesToRun.push(test)
+      unskippableSuites[relativePath] = true
+      if (shouldBeSkipped) {
+        forcedToRunSuites[relativePath] = true
       }
-      return acc
+      continue
     }
-
     if (shouldBeSkipped) {
-      acc.skippedSuites.push(relativePath)
+      skippedSuites.push(relativePath)
     } else {
-      acc.suitesToRun.push(test)
+      suitesToRun.push(test)
     }
-    return acc
-  }, { skippedSuites: [], suitesToRun: [], hasUnskippableSuites: false, hasForcedToRunSuites: false })
+  }
+
+  const hasUnskippableSuites = Object.keys(unskippableSuites).length > 0
+  const hasForcedToRunSuites = Object.keys(forcedToRunSuites).length > 0
+
+  if (originalTests.length) {
+    // The config object is shared by all tests, so we can just take the first one
+    const [test] = originalTests
+    if (test?.context?.config?.testEnvironmentOptions) {
+      if (hasUnskippableSuites) {
+        test.context.config.testEnvironmentOptions._ddUnskippable = JSON.stringify(unskippableSuites)
+      }
+      if (hasForcedToRunSuites) {
+        test.context.config.testEnvironmentOptions._ddForcedToRun = JSON.stringify(forcedToRunSuites)
+      }
+    }
+  }
+
+  return {
+    skippedSuites,
+    suitesToRun,
+    hasUnskippableSuites,
+    hasForcedToRunSuites
+  }
 }
 
 module.exports = { getFormattedJestTestParameters, getJestTestName, getJestSuitesToRun, isMarkedAsUnskippable }

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

@@ -611,7 +611,7 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
     this.startupLogs = isTrue(DD_TRACE_STARTUP_LOGS)
     // Disabled for CI Visibility's agentless
     this.telemetry = {
-      enabled: DD_TRACE_EXPORTER !== 'datadog' && isTrue(DD_INSTRUMENTATION_TELEMETRY_ENABLED),
+      enabled: isTrue(DD_INSTRUMENTATION_TELEMETRY_ENABLED),
       heartbeatInterval: DD_TELEMETRY_HEARTBEAT_INTERVAL,
       debug: isTrue(DD_TELEMETRY_DEBUG),
       logCollection: isTrue(DD_TELEMETRY_LOG_COLLECTION_ENABLED),

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/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

@@ -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

@@ -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
   }
 }
 

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

@@ -7,7 +7,7 @@ const { HTTP_METHOD, HTTP_ROUTE, RESOURCE_NAME, SPAN_TYPE } = require('../../../
 const { WEB } = require('../../../../../ext/types')
 const runtimeMetrics = require('../../runtime_metrics')
 const telemetryMetrics = require('../../telemetry/metrics')
-const { END_TIMESTAMP_LABEL, getThreadLabels } = require('./shared')
+const { END_TIMESTAMP_LABEL, getNonJSThreadsLabels, getThreadLabels } = require('./shared')
 
 const beforeCh = dc.channel('dd-trace:storage:before')
 const enterCh = dc.channel('dd-trace:storage:enter')
@@ -78,13 +78,15 @@ class NativeWallProfiler {
     this._codeHotspotsEnabled = !!options.codeHotspotsEnabled
     this._endpointCollectionEnabled = !!options.endpointCollectionEnabled
     this._timelineEnabled = !!options.timelineEnabled
+    this._cpuProfilingEnabled = !!options.cpuProfilingEnabled
     // We need to capture span data into the sample context for either code hotspots
     // or endpoint collection.
     this._captureSpanData = this._codeHotspotsEnabled || this._endpointCollectionEnabled
     // We need to run the pprof wall profiler with sample contexts if we're either
     // capturing span data or timeline is enabled (so we need sample timestamps, and for now
-    // timestamps require the sample contexts feature in the pprof wall profiler.)
-    this._withContexts = this._captureSpanData || this._timelineEnabled
+    // timestamps require the sample contexts feature in the pprof wall profiler), or
+    // cpu profiling is enabled.
+    this._withContexts = this._captureSpanData || this._timelineEnabled || this._cpuProfilingEnabled
     this._v8ProfilerBugWorkaroundEnabled = !!options.v8ProfilerBugWorkaroundEnabled
     this._mapper = undefined
     this._pprof = undefined
@@ -131,7 +133,8 @@ class NativeWallProfiler {
       sourceMapper: this._mapper,
       withContexts: this._withContexts,
       lineNumbers: false,
-      workaroundV8Bug: this._v8ProfilerBugWorkaroundEnabled
+      workaroundV8Bug: this._v8ProfilerBugWorkaroundEnabled,
+      collectCpuTime: this._cpuProfilingEnabled
     })
 
     if (this._withContexts) {
@@ -220,22 +223,42 @@ class NativeWallProfiler {
 
   _stop (restart) {
     if (!this._started) return
+
     if (this._captureSpanData) {
       // update last sample context if needed
       this._enter()
       this._lastSampleCount = 0
     }
     const profile = this._pprof.time.stop(restart, this._generateLabels)
+
     if (restart) {
       const v8BugDetected = this._pprof.time.v8ProfilerStuckEventLoopDetected()
       if (v8BugDetected !== 0) {
         this._reportV8bug(v8BugDetected === 1)
       }
+    } else {
+      if (this._captureSpanData) {
+        beforeCh.unsubscribe(this._enter)
+        enterCh.unsubscribe(this._enter)
+        spanFinishCh.unsubscribe(this._spanFinished)
+        this._profilerState = undefined
+        this._lastSpan = undefined
+        this._lastStartedSpans = undefined
+        this._lastWebTags = undefined
+      }
+      this._started = false
     }
+
     return profile
   }
 
-  _generateLabels (context) {
+  _generateLabels ({ node, context }) {
+    // check for special node that represents CPU time all non-JS threads.
+    // In that case only return a special thread name label since we cannot associate any timestamp/span/endpoint to it.
+    if (node.name === this._pprof.time.constants.NON_JS_THREADS_FUNCTION_NAME) {
+      return getNonJSThreadsLabels()
+    }
+
     if (context == null) {
       // generateLabels is also called for samples without context.
       // In that case just return thread labels.
@@ -267,8 +290,8 @@ class NativeWallProfiler {
     return labels
   }
 
-  profile () {
-    return this._stop(true)
+  profile (restart) {
+    return this._stop(restart)
   }
 
   encode (profile) {
@@ -276,21 +299,11 @@ class NativeWallProfiler {
   }
 
   stop () {
-    if (!this._started) return
-
-    const profile = this._stop(false)
-    if (this._captureSpanData) {
-      beforeCh.unsubscribe(this._enter)
-      enterCh.unsubscribe(this._enter)
-      spanFinishCh.unsubscribe(this._spanFinished)
-      this._profilerState = undefined
-      this._lastSpan = undefined
-      this._lastStartedSpans = undefined
-      this._lastWebTags = undefined
-    }
+    this._stop(false)
+  }
 
-    this._started = false
-    return profile
+  isStarted () {
+    return this._started
   }
 }
 

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

@@ -0,0 +1,130 @@
+'use strict'
+
+const { globMatch } = require('../src/util')
+const RateLimiter = require('./rate_limiter')
+const Sampler = require('./sampler')
+
+class AlwaysMatcher {
+  match () {
+    return true
+  }
+}
+
+class GlobMatcher {
+  constructor (pattern, locator) {
+    this.pattern = pattern
+    this.locator = locator
+  }
+
+  match (span) {
+    const subject = this.locator(span)
+    if (!subject) return false
+    return globMatch(this.pattern, subject)
+  }
+}
+
+class RegExpMatcher {
+  constructor (pattern, locator) {
+    this.pattern = pattern
+    this.locator = locator
+  }
+
+  match (span) {
+    const subject = this.locator(span)
+    if (!subject) return false
+    return this.pattern.test(subject)
+  }
+}
+
+function matcher (pattern, locator) {
+  if (pattern instanceof RegExp) {
+    return new RegExpMatcher(pattern, locator)
+  }
+
+  if (typeof pattern === 'string' && pattern !== '*') {
+    return new GlobMatcher(pattern, locator)
+  }
+
+  return new AlwaysMatcher()
+}
+
+function makeTagLocator (tag) {
+  return (span) => span.context()._tags[tag]
+}
+
+function nameLocator (span) {
+  return span.context()._name
+}
+
+function serviceLocator (span) {
+  const { _tags: tags } = span.context()
+  return tags.service ||
+    tags['service.name'] ||
+    span.tracer()._service
+}
+
+class SamplingRule {
+  constructor ({ name, service, resource, tags, sampleRate = 1.0, maxPerSecond } = {}) {
+    this.matchers = []
+
+    if (name) {
+      this.matchers.push(matcher(name, nameLocator))
+    }
+    if (service) {
+      this.matchers.push(matcher(service, serviceLocator))
+    }
+    if (resource) {
+      this.matchers.push(matcher(resource, makeTagLocator('resource.name')))
+    }
+    for (const [key, value] of Object.entries(tags || {})) {
+      this.matchers.push(matcher(value, makeTagLocator(key)))
+    }
+
+    this._sampler = new Sampler(sampleRate)
+    this._limiter = undefined
+
+    if (Number.isFinite(maxPerSecond)) {
+      this._limiter = new RateLimiter(maxPerSecond)
+    }
+  }
+
+  static from (config) {
+    return new SamplingRule(config)
+  }
+
+  get sampleRate () {
+    return this._sampler.rate()
+  }
+
+  get effectiveRate () {
+    return this._limiter && this._limiter.effectiveRate()
+  }
+
+  get maxPerSecond () {
+    return this._limiter && this._limiter._rateLimit
+  }
+
+  match (span) {
+    for (const matcher of this.matchers) {
+      if (!matcher.match(span)) {
+        return false
+      }
+    }
+
+    return true
+  }
+
+  sample () {
+    if (!this._sampler.isSampled()) {
+      return false
+    }
+
+    if (this._limiter) {
+      return this._limiter.isAllowed()
+    }
+
+    return true
+  }
+}
+
+module.exports = SamplingRule

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

@@ -1,67 +1,16 @@
 'use strict'
-const { globMatch } = require('../src/util')
-const { USER_KEEP, AUTO_KEEP } = require('../../../ext').priority
-const RateLimiter = require('./rate_limiter')
-const Sampler = require('./sampler')
-
-class SpanSamplingRule {
-  constructor ({ service, name, sampleRate = 1.0, maxPerSecond } = {}) {
-    this.service = service
-    this.name = name
-
-    this._sampler = new Sampler(sampleRate)
-    this._limiter = undefined
-
-    if (Number.isFinite(maxPerSecond)) {
-      this._limiter = new RateLimiter(maxPerSecond)
-    }
-  }
-
-  get sampleRate () {
-    return this._sampler.rate()
-  }
-
-  get maxPerSecond () {
-    return this._limiter && this._limiter._rateLimit
-  }
-
-  static from (config) {
-    return new SpanSamplingRule(config)
-  }
-
-  match (service, name) {
-    if (this.service && !globMatch(this.service, service)) {
-      return false
-    }
-
-    if (this.name && !globMatch(this.name, name)) {
-      return false
-    }
-
-    return true
-  }
-
-  sample () {
-    if (!this._sampler.isSampled()) {
-      return false
-    }
 
-    if (this._limiter) {
-      return this._limiter.isAllowed()
-    }
-
-    return true
-  }
-}
+const { USER_KEEP, AUTO_KEEP } = require('../../../ext').priority
+const SamplingRule = require('./sampling_rule')
 
 class SpanSampler {
   constructor ({ spanSamplingRules = [] } = {}) {
-    this._rules = spanSamplingRules.map(SpanSamplingRule.from)
+    this._rules = spanSamplingRules.map(SamplingRule.from)
   }
 
-  findRule (service, name) {
+  findRule (context) {
     for (const rule of this._rules) {
-      if (rule.match(service, name)) {
+      if (rule.match(context)) {
         return rule
       }
     }
@@ -73,14 +22,7 @@ class SpanSampler {
 
     const { started } = spanContext._trace
     for (const span of started) {
-      const context = span.context()
-      const tags = context._tags || {}
-      const name = context._name
-      const service = tags.service ||
-        tags['service.name'] ||
-        span.tracer()._service
-
-      const rule = this.findRule(service, name)
+      const rule = this.findRule(span)
       if (rule && rule.sample()) {
         span.context()._spanSampling = {
           sampleRate: rule.sampleRate,

package/packages/dd-trace/src/telemetry/send-data.js

@@ -1,6 +1,7 @@
 
 const request = require('../exporters/common/request')
 const log = require('../log')
+
 let agentTelemetry = true
 
 function getHeaders (config, application, reqType) {
@@ -15,9 +16,22 @@ function getHeaders (config, application, reqType) {
   if (debug) {
     headers['dd-telemetry-debug-enabled'] = 'true'
   }
+  if (config.apiKey) {
+    headers['dd-api-key'] = config.apiKey
+  }
   return headers
 }
 
+function getAgentlessTelemetryEndpoint (site) {
+  if (site === 'datad0g.com') { // staging
+    return 'https://all-http-intake.logs.datad0g.com'
+  }
+  if (site === 'datadoghq.eu') {
+    return 'https://instrumentation-telemetry-intake.eu1.datadoghq.com'
+  }
+  return `https://instrumentation-telemetry-intake.${site}`
+}
+
 let seqId = 0
 
 function getPayload (payload) {
@@ -35,17 +49,33 @@ function sendData (config, application, host, reqType, payload = {}, cb = () =>
   const {
     hostname,
     port,
-    url
+    experimental,
+    isCiVisibility
   } = config
 
+  let url = config.url
+
+  const isCiVisibilityAgentlessMode = isCiVisibility && experimental?.exporter === 'datadog'
+
+  if (isCiVisibilityAgentlessMode) {
+    try {
+      url = url || new URL(getAgentlessTelemetryEndpoint(config.site))
+    } catch (err) {
+      log.error(err)
+      // No point to do the request if the URL is invalid
+      return cb(err, { payload, reqType })
+    }
+  }
+
   const options = {
     url,
     hostname,
     port,
     method: 'POST',
-    path: '/telemetry/proxy/api/v2/apmtelemetry',
+    path: isCiVisibilityAgentlessMode ? '/api/v2/apmtelemetry' : '/telemetry/proxy/api/v2/apmtelemetry',
     headers: getHeaders(config, application, reqType)
   }
+
   const data = JSON.stringify({
     api_version: 'v2',
     naming_schema_version: config.spanAttributeSchema ? config.spanAttributeSchema : '',
@@ -65,24 +95,13 @@ function sendData (config, application, host, reqType, payload = {}, cb = () =>
         agentTelemetry = false
       }
       // figure out which data center to send to
-      let backendUrl
-      const dataCenters = [
-        'datadoghq.com',
-        'us3.datadoghq.com',
-        'us5.datadoghq.com',
-        'ap1.datadoghq.com',
-        'eu1.datadoghq.com'
-      ]
-      if (config.site === 'datad0g.com') { // staging
-        backendUrl = 'https://all-http-intake.logs.datad0g.com/api/v2/apmtelemetry'
-      } else if (dataCenters.includes(config.site)) {
-        backendUrl = 'https://instrumentation-telemetry-intake.' + config.site + '/api/v2/apmtelemetry'
-      }
+      const backendUrl = getAgentlessTelemetryEndpoint(config.site)
       const backendHeader = { ...options.headers, 'DD-API-KEY': process.env.DD_API_KEY }
       const backendOptions = {
         ...options,
         url: backendUrl,
-        headers: backendHeader
+        headers: backendHeader,
+        path: '/api/v2/apmtelemetry'
       }
       if (backendUrl) {
         request(data, backendOptions, (error) => { log.error(error) })