dd-trace 5.0.0-pre-0a30f33 → 5.0.0-pre-244a0ea

package/README.md

@@ -2,8 +2,6 @@
 
 [![npm v4](https://img.shields.io/npm/v/dd-trace/latest?color=blue&label=dd-trace%40v4&logo=npm)](https://www.npmjs.com/package/dd-trace)
 [![npm v3](https://img.shields.io/npm/v/dd-trace/latest-node14?color=blue&label=dd-trace%40v3&logo=npm)](https://www.npmjs.com/package/dd-trace/v/latest-node12)
-[![npm v2](https://img.shields.io/npm/v/dd-trace/latest-node12?color=blue&label=dd-trace%40v2&logo=npm)](https://www.npmjs.com/package/dd-trace/v/latest-node12)
-[![npm dev](https://img.shields.io/npm/v/dd-trace/dev?color=orange&label=dd-trace%40dev&logo=npm)](https://www.npmjs.com/package/dd-trace/v/dev)
 [![codecov](https://codecov.io/gh/DataDog/dd-trace-js/branch/master/graph/badge.svg)](https://codecov.io/gh/DataDog/dd-trace-js)
 
 <img align="right" src="https://user-images.githubusercontent.com/551402/208212084-1d0c07e2-4135-4c61-b2da-8f2fddbc66ed.png" alt="Bits the dog  JavaScript" width="200px"/>
@@ -28,12 +26,12 @@ Most of the documentation for `dd-trace` is available on these webpages:
 | Release Line                                             | Latest Version                                                                                         | Node.js  | Status          |Initial Release | End of Life |
 | :---:                                                    | :---:                                                                                                  | :---:    | :---:           | :---:          | :---:       |
 | [`v1`](https://github.com/DataDog/dd-trace-js/tree/v1.x) | ![npm v1](https://img.shields.io/npm/v/dd-trace/legacy-v1?color=white&label=%20&style=flat-square)     | `>= v12` | **End of Life** | 2021-07-13     | 2022-02-25  |
-| [`v2`](https://github.com/DataDog/dd-trace-js/tree/v2.x) | ![npm v2](https://img.shields.io/npm/v/dd-trace/latest-node12?color=white&label=%20&style=flat-square) | `>= v12` | **Maintenance** | 2022-01-28     | 2023-08-15  |
+| [`v2`](https://github.com/DataDog/dd-trace-js/tree/v2.x) | ![npm v2](https://img.shields.io/npm/v/dd-trace/latest-node12?color=white&label=%20&style=flat-square) | `>= v12` | **End of Life** | 2022-01-28     | 2023-08-15  |
 | [`v3`](https://github.com/DataDog/dd-trace-js/tree/v3.x) | ![npm v3](https://img.shields.io/npm/v/dd-trace/latest-node14?color=white&label=%20&style=flat-square) | `>= v14` | **Maintenance** | 2022-08-15     | 2024-05-15  |
 | [`v4`](https://github.com/DataDog/dd-trace-js/tree/v4.x) | ![npm v4](https://img.shields.io/npm/v/dd-trace/latest?color=white&label=%20&style=flat-square)        | `>= v16` | **Current**     | 2023-05-12     | Unknown     |
 
-We currently maintain three release lines, namely `v2`, `v3` and `v4`.
-Features and bug fixes that are merged are released to the `v4` line and, if appropriate, also the `v2` and `v3` line.
+We currently maintain two release lines, namely `v3` and `v4`.
+Features and bug fixes that are merged are released to the `v4` line and, if appropriate, also the `v3` line.
 
 For any new projects it is recommended to use the `v4` release line:
 
@@ -42,15 +40,12 @@ $ npm install dd-trace
 $ yarn add dd-trace
 ```
 
-However, existing projects that already use the `v2` or `v3` release lines, or projects that need to support EOL versions of Node.js, may continue to use these release lines.
+However, existing projects that already use the `v3` release line, or projects that need to support EOL versions of Node.js, may continue to use these release lines.
 This is done by specifying the version when installing the package.
-Note that we also publish to npm using a `latest-node12` and `latest-node14` tag that can also be used for install:
 
 ```sh
 $ npm install dd-trace@3
 $ yarn add dd-trace@3
-$ npm install dd-trace@latest-node14
-$ yarn add dd-trace@latest-node14
 ```
 
 Any backwards-breaking functionality that is introduced into the library will result in an increase of the major version of the library and therefore a new release line.

package/index.d.ts

@@ -121,6 +121,8 @@ export declare interface Tracer extends opentracing.Tracer {
   appsec: Appsec;
 
   TracerProvider: opentelemetry.TracerProvider;
+
+  dogstatsd: DogStatsD;
 }
 
 export declare interface TraceOptions extends Analyzable {
@@ -642,6 +644,47 @@ export declare interface User {
   [key: string]: string | undefined
 }
 
+export declare interface DogStatsD {
+  /**
+   * Increments a metric by the specified value, optionally specifying tags.
+   * @param {string} stat The dot-separated metric name.
+   * @param {number} value The amount to increment the stat by.
+   * @param {[tag:string]:string|number} tags Tags to pass along, such as `[ 'foo:bar' ]`. Values are combined with config.tags.
+   */
+  increment(stat: string, value?: number, tags?: { [tag: string]: string|number }): void
+
+  /**
+   * Decrements a metric by the specified value, optionally specifying tags.
+   * @param {string} stat The dot-separated metric name.
+   * @param {number} value The amount to decrement the stat by.
+   * @param {[tag:string]:string|number} tags Tags to pass along, such as `[ 'foo:bar' ]`. Values are combined with config.tags.
+   */
+  decrement(stat: string, value?: number, tags?: { [tag: string]: string|number }): void
+
+  /**
+   * Sets a distribution value, optionally specifying tags.
+   * @param {string} stat The dot-separated metric name.
+   * @param {number} value The amount to increment the stat by.
+   * @param {[tag:string]:string|number} tags Tags to pass along, such as `[ 'foo:bar' ]`. Values are combined with config.tags.
+   */
+  distribution(stat: string, value?: number, tags?: { [tag: string]: string|number }): void
+
+  /**
+   * Sets a gauge value, optionally specifying tags.
+   * @param {string} stat The dot-separated metric name.
+   * @param {number} value The amount to increment the stat by.
+   * @param {[tag:string]:string|number} tags Tags to pass along, such as `[ 'foo:bar' ]`. Values are combined with config.tags.
+   */
+  gauge(stat: string, value?: number, tags?: { [tag: string]: string|number }): void
+
+  /**
+   * Forces any unsent metrics to be sent
+   *
+   * @beta This method is experimental and could be removed in future versions.
+   */
+  flush(): void
+}
+
 export declare interface Appsec {
   /**
    * Links a successful login event to the current trace. Will link the passed user to the current trace with Appsec.setUser() internally.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.0.0-pre-0a30f33",
+  "version": "5.0.0-pre-244a0ea",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -71,7 +71,7 @@
     "@datadog/native-iast-rewriter": "2.0.1",
     "@datadog/native-iast-taint-tracking": "1.5.0",
     "@datadog/native-metrics": "^2.0.0",
-    "@datadog/pprof": "3.1.0",
+    "@datadog/pprof": "3.2.0",
     "@datadog/sketches-js": "^2.1.0",
     "@opentelemetry/api": "^1.0.0",
     "@opentelemetry/core": "^1.14.0",

package/packages/datadog-esbuild/index.js

@@ -53,10 +53,25 @@ module.exports.setup = function (build) {
   const externalModules = new Set(build.initialOptions.external || [])
   build.onResolve({ filter: /.*/ }, args => {
     if (externalModules.has(args.path)) {
+      // Internal Node.js packages will still be instrumented via require()
       if (DEBUG) console.log(`EXTERNAL: ${args.path}`)
       return
     }
 
+    // TODO: Should this also check for namespace === 'file'?
+    if (args.path.startsWith('.') && !args.importer.includes('node_modules/')) {
+      // This is local application code, not an instrumented package
+      if (DEBUG) console.log(`LOCAL: ${args.path}`)
+      return
+    }
+
+    // TODO: Should this also check for namespace === 'file'?
+    if (args.path.startsWith('@') && !args.importer.includes('node_modules/')) {
+      // This is the Next.js convention for loading local files
+      if (DEBUG) console.log(`@LOCAL: ${args.path}`)
+      return
+    }
+
     let fullPathToModule
     try {
       fullPathToModule = dotFriendlyResolve(args.path, args.resolveDir)
@@ -65,12 +80,11 @@ module.exports.setup = function (build) {
       return
     }
     const extracted = extractPackageAndModulePath(fullPathToModule)
-    const packageName = args.path
 
     const internal = builtins.has(args.path)
 
     if (args.namespace === 'file' && (
-      modulesOfInterest.has(packageName) || modulesOfInterest.has(`${extracted.pkg}/${extracted.path}`))
+      modulesOfInterest.has(args.path) || modulesOfInterest.has(`${extracted.pkg}/${extracted.path}`))
     ) {
       // The file namespace is used when requiring files from disk in userland
 
@@ -90,7 +104,7 @@ module.exports.setup = function (build) {
 
       const packageJson = require(pathToPackageJson)
 
-      if (DEBUG) console.log(`RESOLVE: ${packageName}@${packageJson.version}`)
+      if (DEBUG) console.log(`RESOLVE: ${args.path}@${packageJson.version}`)
 
       // https://esbuild.github.io/plugins/#on-resolve-arguments
       return {
@@ -101,17 +115,17 @@ module.exports.setup = function (build) {
           pkg: extracted.pkg,
           path: extracted.path,
           full: fullPathToModule,
-          raw: packageName,
+          raw: args.path,
           internal
         }
       }
     } else if (args.namespace === NAMESPACE) {
       // The datadog namespace is used when requiring files that are injected during the onLoad stage
 
-      if (builtins.has(packageName)) return
+      if (builtins.has(args.path)) return
 
       return {
-        path: require.resolve(packageName, { paths: [ args.resolveDir ] }),
+        path: require.resolve(args.path, { paths: [ args.resolveDir ] }),
         namespace: 'file'
       }
     }

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

@@ -105,7 +105,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         await super.handleTestEvent(event, state)
       }
 
-      const setNameToParams = (name, params) => { this.nameToParams[name] = params }
+      const setNameToParams = (name, params) => { this.nameToParams[name] = [...params] }
 
       if (event.name === 'setup') {
         if (this.global.test) {

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

@@ -12,6 +12,7 @@ const errorChannel = channel('apm:next:request:error')
 const pageLoadChannel = channel('apm:next:page:load')
 
 const requests = new WeakSet()
+const requestToNextjsPagePath = new WeakMap()
 
 function wrapHandleRequest (handleRequest) {
   return function (req, res, pathname, query) {
@@ -132,6 +133,57 @@ function instrument (req, res, handler) {
   })
 }
 
+function wrapSetupServerWorker (setupServerWorker) {
+  return function (requestHandler) {
+    arguments[0] = shimmer.wrap(requestHandler, wrapRequestHandler(requestHandler))
+    return setupServerWorker.apply(this, arguments)
+  }
+}
+
+function wrapInitialize (initialize) {
+  return async function () {
+    const result = await initialize.apply(this, arguments)
+    if (Array.isArray(result)) {
+      const requestHandler = result[0]
+      result[0] = shimmer.wrap(requestHandler, wrapRequestHandler(requestHandler))
+    }
+    return result
+  }
+}
+
+function wrapRequestHandler (requestHandler) {
+  return function (req, res) {
+    return instrument(req, res, async () => {
+      const result = await requestHandler.apply(this, arguments) // apply here first to get page path association
+
+      const page = requestToNextjsPagePath.get(req)
+      if (page && pageLoadChannel.hasSubscribers) pageLoadChannel.publish({ page })
+
+      return result
+    })
+  }
+}
+
+// these two functions make sure we get path groups for routes in standalone,
+// as it doesn't route through `next-server`/`base-server`
+function wrapGetResolveRoutes (getResolveRoutes) {
+  return function () {
+    const result = getResolveRoutes.apply(this, arguments)
+    return shimmer.wrap(result, wrapResolveRoutes(result))
+  }
+}
+
+function wrapResolveRoutes (resolveRoutes) {
+  return async function (req) {
+    const result = await resolveRoutes.apply(this, arguments)
+    if (result && result.matchedOutput) {
+      const path = result.matchedOutput.itemPath
+      requestToNextjsPagePath.set(req, path)
+    }
+    return result
+  }
+}
+
 function finish (ctx, result, err) {
   if (err) {
     ctx.error = err
@@ -147,11 +199,27 @@ function finish (ctx, result, err) {
   return result
 }
 
+addHook({
+  name: 'next',
+  versions: ['>=13.4.13'],
+  file: 'dist/server/lib/router-utils/resolve-routes.js'
+}, resolveRoutesModule => shimmer.wrap(resolveRoutesModule, 'getResolveRoutes', wrapGetResolveRoutes))
+
+addHook({
+  name: 'next',
+  versions: ['13.4.13'],
+  file: 'dist/server/lib/setup-server-worker.js'
+}, setupServerWorker => shimmer.wrap(setupServerWorker, 'initializeServerWorker', wrapSetupServerWorker))
+
+addHook({
+  name: 'next',
+  versions: ['>=13.4.15'],
+  file: 'dist/server/lib/router-server.js'
+}, routerServer => shimmer.wrap(routerServer, 'initialize', wrapInitialize))
+
 addHook({ name: 'next', versions: ['>=13.2'], file: 'dist/server/next-server.js' }, nextServer => {
   const Server = nextServer.default
 
-  shimmer.wrap(Server.prototype, 'handleRequest', wrapHandleRequest)
-  shimmer.wrap(Server.prototype, 'handleApiRequest', wrapHandleApiRequestWithMatch)
   shimmer.wrap(Server.prototype, 'renderToResponse', wrapRenderToResponse)
   shimmer.wrap(Server.prototype, 'renderErrorToResponse', wrapRenderErrorToResponse)
   shimmer.wrap(Server.prototype, 'findPageComponents', wrapFindPageComponents)
@@ -159,6 +227,22 @@ addHook({ name: 'next', versions: ['>=13.2'], file: 'dist/server/next-server.js'
   return nextServer
 })
 
+// these functions wrapped in all versions above 13.2 except:
+// 13.4.13 due to tests failing when these functions are wrapped
+// 13.4.14 due to it not being in the NPM registry/officially released
+addHook({
+  name: 'next',
+  versions: ['>=13.2 <13.4.13', '>=13.4.15'],
+  file: 'dist/server/next-server.js'
+}, nextServer => {
+  const Server = nextServer.default
+
+  shimmer.wrap(Server.prototype, 'handleRequest', wrapHandleRequest)
+  shimmer.wrap(Server.prototype, 'handleApiRequest', wrapHandleApiRequestWithMatch)
+
+  return nextServer
+})
+
 addHook({ name: 'next', versions: ['>=11.1 <13.2'], file: 'dist/server/next-server.js' }, nextServer => {
   const Server = nextServer.default
 

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

@@ -10,7 +10,7 @@ const startCh = channel('apm:openai:request:start')
 const finishCh = channel('apm:openai:request:finish')
 const errorCh = channel('apm:openai:request:error')
 
-addHook({ name: 'openai', file: 'dist/api.js', versions: ['>=3.0.0'] }, exports => {
+addHook({ name: 'openai', file: 'dist/api.js', versions: ['>=3.0.0 <4'] }, exports => {
   const methodNames = Object.getOwnPropertyNames(exports.OpenAIApi.prototype)
   methodNames.shift() // remove leading 'constructor' method
 

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

@@ -56,9 +56,9 @@ function getVariablesFilter (config) {
 
 function getHooks (config) {
   const noop = () => { }
-  const execute = (config.hooks && config.hooks.execute) || noop
-  const parse = (config.hooks && config.hooks.parse) || noop
-  const validate = (config.hooks && config.hooks.validate) || noop
+  const execute = config.hooks?.execute || noop
+  const parse = config.hooks?.parse || noop
+  const validate = config.hooks?.validate || noop
 
   return { execute, parse, validate }
 }

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

@@ -4,6 +4,7 @@ const ServerPlugin = require('../../dd-trace/src/plugins/server')
 const { storage } = require('../../datadog-core')
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 const { COMPONENT } = require('../../dd-trace/src/constants')
+const web = require('../../dd-trace/src/plugins/util/web')
 
 class NextPlugin extends ServerPlugin {
   static get id () {
@@ -49,6 +50,7 @@ class NextPlugin extends ServerPlugin {
 
     const span = store.span
     const error = span.context()._tags['error']
+    const page = span.context()._tags['next.page']
 
     if (!this.config.validateStatus(res.statusCode) && !error) {
       span.setTag('error', true)
@@ -58,6 +60,8 @@ class NextPlugin extends ServerPlugin {
       'http.status_code': res.statusCode
     })
 
+    if (page) web.setRoute(req, page)
+
     this.config.hooks.request(span, req, res)
 
     span.finish()

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

@@ -35,14 +35,14 @@ class DogStatsDClient {
     this._udp6 = this._socket('udp6')
   }
 
-  gauge (stat, value, tags) {
-    this._add(stat, value, TYPE_GAUGE, tags)
-  }
-
   increment (stat, value, tags) {
     this._add(stat, value, TYPE_COUNTER, tags)
   }
 
+  gauge (stat, value, tags) {
+    this._add(stat, value, TYPE_GAUGE, tags)
+  }
+
   distribution (stat, value, tags) {
     this._add(stat, value, TYPE_DISTRIBUTION, tags)
   }
@@ -153,7 +153,67 @@ class NoopDogStatsDClient {
   flush () { }
 }
 
+// This is a simplified user-facing proxy to the underlying DogStatsDClient instance
+class CustomMetrics {
+  constructor (options) {
+    this.dogstatsd = new DogStatsDClient(options)
+  }
+
+  increment (stat, value = 1, tags) {
+    return this.dogstatsd.increment(
+      stat,
+      value,
+      CustomMetrics.tagTranslator(tags)
+    )
+  }
+
+  decrement (stat, value = 1, tags) {
+    return this.dogstatsd.increment(
+      stat,
+      value * -1,
+      CustomMetrics.tagTranslator(tags)
+    )
+  }
+
+  gauge (stat, value, tags) {
+    return this.dogstatsd.gauge(
+      stat,
+      value,
+      CustomMetrics.tagTranslator(tags)
+    )
+  }
+
+  distribution (stat, value, tags) {
+    return this.dogstatsd.distribution(
+      stat,
+      value,
+      CustomMetrics.tagTranslator(tags)
+    )
+  }
+
+  flush () {
+    return this.dogstatsd.flush()
+  }
+
+  /**
+   * Exposing { tagName: 'tagValue' } to the end user
+   * These are translated into [ 'tagName:tagValue' ] for internal use
+   */
+  static tagTranslator (objTags) {
+    const arrTags = []
+
+    if (!objTags) return arrTags
+
+    for (const [key, value] of Object.entries(objTags)) {
+      arrTags.push(`${key}:${value}`)
+    }
+
+    return arrTags
+  }
+}
+
 module.exports = {
   DogStatsDClient,
-  NoopDogStatsDClient
+  NoopDogStatsDClient,
+  CustomMetrics
 }

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

@@ -2,7 +2,7 @@
 
 const request = require('../common/request')
 const { startupLog } = require('../../startup-log')
-const metrics = require('../../metrics')
+const runtimeMetrics = require('../../runtime_metrics')
 const log = require('../../log')
 const tracerVersion = require('../../../../../package.json').version
 const BaseWriter = require('../common/writer')
@@ -22,19 +22,19 @@ class Writer extends BaseWriter {
   }
 
   _sendPayload (data, count, done) {
-    metrics.increment(`${METRIC_PREFIX}.requests`, true)
+    runtimeMetrics.increment(`${METRIC_PREFIX}.requests`, true)
 
     const { _headers, _lookup, _protocolVersion, _url } = this
     makeRequest(_protocolVersion, data, count, _url, _headers, _lookup, true, (err, res, status) => {
       if (status) {
-        metrics.increment(`${METRIC_PREFIX}.responses`, true)
-        metrics.increment(`${METRIC_PREFIX}.responses.by.status`, `status:${status}`, true)
+        runtimeMetrics.increment(`${METRIC_PREFIX}.responses`, true)
+        runtimeMetrics.increment(`${METRIC_PREFIX}.responses.by.status`, `status:${status}`, true)
       } else if (err) {
-        metrics.increment(`${METRIC_PREFIX}.errors`, true)
-        metrics.increment(`${METRIC_PREFIX}.errors.by.name`, `name:${err.name}`, true)
+        runtimeMetrics.increment(`${METRIC_PREFIX}.errors`, true)
+        runtimeMetrics.increment(`${METRIC_PREFIX}.errors.by.name`, `name:${err.name}`, true)
 
         if (err.code) {
-          metrics.increment(`${METRIC_PREFIX}.errors.by.code`, `code:${err.code}`, true)
+          runtimeMetrics.increment(`${METRIC_PREFIX}.errors.by.code`, `code:${err.code}`, true)
         }
       }
 
@@ -53,8 +53,8 @@ class Writer extends BaseWriter {
       } catch (e) {
         log.error(e)
 
-        metrics.increment(`${METRIC_PREFIX}.errors`, true)
-        metrics.increment(`${METRIC_PREFIX}.errors.by.name`, `name:${e.name}`, true)
+        runtimeMetrics.increment(`${METRIC_PREFIX}.errors`, true)
+        runtimeMetrics.increment(`${METRIC_PREFIX}.errors.by.name`, `name:${e.name}`, true)
       }
       done()
     })

package/packages/dd-trace/src/exporters/common/request.js

@@ -42,10 +42,19 @@ function urlToOptions (url) {
   return options
 }
 
-function fromUrlString (url) {
-  return typeof urlToHttpOptions === 'function'
-    ? urlToOptions(new URL(url))
-    : urlParse(url)
+function fromUrlString (urlString) {
+  const url = typeof urlToHttpOptions === 'function'
+    ? urlToOptions(new URL(urlString))
+    : urlParse(urlString)
+
+  // Add the 'hostname' back if we're using named pipes
+  if (url.protocol === 'unix:' && url.host === '.') {
+    const udsPath = urlString.replace(/^unix:/, '')
+    url.path = udsPath
+    url.pathname = udsPath
+  }
+
+  return url
 }
 
 function request (data, options, callback) {

package/packages/dd-trace/src/opentracing/span.js

@@ -8,7 +8,7 @@ const semver = require('semver')
 const SpanContext = require('./span_context')
 const id = require('../id')
 const tagger = require('../tagger')
-const metrics = require('../metrics')
+const runtimeMetrics = require('../runtime_metrics')
 const log = require('../log')
 const { storage } = require('../../../datadog-core')
 const telemetryMetrics = require('../telemetry/metrics')
@@ -79,11 +79,11 @@ class DatadogSpan {
     this._startTime = fields.startTime || this._getTime()
 
     if (DD_TRACE_EXPERIMENTAL_SPAN_COUNTS && finishedRegistry) {
-      metrics.increment('runtime.node.spans.unfinished')
-      metrics.increment('runtime.node.spans.unfinished.by.name', `span_name:${operationName}`)
+      runtimeMetrics.increment('runtime.node.spans.unfinished')
+      runtimeMetrics.increment('runtime.node.spans.unfinished.by.name', `span_name:${operationName}`)
 
-      metrics.increment('runtime.node.spans.open') // unfinished for real
-      metrics.increment('runtime.node.spans.open.by.name', `span_name:${operationName}`)
+      runtimeMetrics.increment('runtime.node.spans.open') // unfinished for real
+      runtimeMetrics.increment('runtime.node.spans.open.by.name', `span_name:${operationName}`)
 
       unfinishedRegistry.register(this, operationName, this)
     }
@@ -159,13 +159,13 @@ class DatadogSpan {
     getIntegrationCounter('span_finished', this._integrationName).inc()
 
     if (DD_TRACE_EXPERIMENTAL_SPAN_COUNTS && finishedRegistry) {
-      metrics.decrement('runtime.node.spans.unfinished')
-      metrics.decrement('runtime.node.spans.unfinished.by.name', `span_name:${this._name}`)
-      metrics.increment('runtime.node.spans.finished')
-      metrics.increment('runtime.node.spans.finished.by.name', `span_name:${this._name}`)
+      runtimeMetrics.decrement('runtime.node.spans.unfinished')
+      runtimeMetrics.decrement('runtime.node.spans.unfinished.by.name', `span_name:${this._name}`)
+      runtimeMetrics.increment('runtime.node.spans.finished')
+      runtimeMetrics.increment('runtime.node.spans.finished.by.name', `span_name:${this._name}`)
 
-      metrics.decrement('runtime.node.spans.open') // unfinished for real
-      metrics.decrement('runtime.node.spans.open.by.name', `span_name:${this._name}`)
+      runtimeMetrics.decrement('runtime.node.spans.open') // unfinished for real
+      runtimeMetrics.decrement('runtime.node.spans.open.by.name', `span_name:${this._name}`)
 
       unfinishedRegistry.unregister(this)
       finishedRegistry.register(this, this._name)
@@ -243,8 +243,8 @@ function createRegistry (type) {
   if (!semver.satisfies(process.version, '>=14.6')) return
 
   return new global.FinalizationRegistry(name => {
-    metrics.decrement(`runtime.node.spans.${type}`)
-    metrics.decrement(`runtime.node.spans.${type}.by.name`, [`span_name:${name}`])
+    runtimeMetrics.decrement(`runtime.node.spans.${type}`)
+    runtimeMetrics.decrement(`runtime.node.spans.${type}.by.name`, [`span_name:${name}`])
   })
 }
 

package/packages/dd-trace/src/opentracing/tracer.js

@@ -11,7 +11,7 @@ const LogPropagator = require('./propagation/log')
 const formats = require('../../../../ext/formats')
 
 const log = require('../log')
-const metrics = require('../metrics')
+const runtimeMetrics = require('../runtime_metrics')
 const getExporter = require('../exporter')
 const SpanContext = require('./span_context')
 
@@ -82,7 +82,7 @@ class DatadogTracer {
       this._propagators[format].inject(spanContext, carrier)
     } catch (e) {
       log.error(e)
-      metrics.increment('datadog.tracer.node.inject.errors', true)
+      runtimeMetrics.increment('datadog.tracer.node.inject.errors', true)
     }
   }
 
@@ -91,7 +91,7 @@ class DatadogTracer {
       return this._propagators[format].extract(carrier)
     } catch (e) {
       log.error(e)
-      metrics.increment('datadog.tracer.node.extract.errors', true)
+      runtimeMetrics.increment('datadog.tracer.node.extract.errors', true)
       return null
     }
   }

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

@@ -31,6 +31,7 @@ class Config {
       DD_PROFILING_UPLOAD_PERIOD,
       DD_PROFILING_PPROF_PREFIX,
       DD_PROFILING_HEAP_ENABLED,
+      DD_PROFILING_V8_PROFILER_BUG_WORKAROUND,
       DD_PROFILING_WALLTIME_ENABLED,
       DD_PROFILING_EXPERIMENTAL_OOM_MONITORING_ENABLED,
       DD_PROFILING_EXPERIMENTAL_OOM_HEAP_LIMIT_EXTENSION_SIZE,
@@ -76,7 +77,8 @@ class Config {
     this.debugSourceMaps = isTrue(coalesce(options.debugSourceMaps, DD_PROFILING_DEBUG_SOURCE_MAPS, false))
     this.endpointCollectionEnabled = endpointCollectionEnabled
     this.pprofPrefix = pprofPrefix
-
+    this.v8ProfilerBugWorkaroundEnabled = isTrue(coalesce(options.v8ProfilerBugWorkaround,
+      DD_PROFILING_V8_PROFILER_BUG_WORKAROUND, true))
     const hostname = coalesce(options.hostname, DD_AGENT_HOST) || 'localhost'
     const port = coalesce(options.port, DD_TRACE_AGENT_PORT) || 8126
     this.url = new URL(coalesce(options.url, DD_TRACE_AGENT_URL, format({

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

@@ -3,6 +3,9 @@
 const { storage } = require('../../../../datadog-core')
 
 const dc = require('../../../../diagnostics_channel')
+const { HTTP_METHOD, HTTP_ROUTE, RESOURCE_NAME, SPAN_TYPE } = require('../../../../../ext/tags')
+const { WEB } = require('../../../../../ext/types')
+const runtimeMetrics = require('../../runtime_metrics')
 
 const beforeCh = dc.channel('dd-trace:storage:before')
 const enterCh = dc.channel('dd-trace:storage:enter')
@@ -41,13 +44,13 @@ function getSpanContextTags (span) {
 }
 
 function isWebServerSpan (tags) {
-  return tags['span.type'] === 'web'
+  return tags[SPAN_TYPE] === WEB
 }
 
 function endpointNameFromTags (tags) {
-  return tags['resource.name'] || [
-    tags['http.method'],
-    tags['http.route']
+  return tags[RESOURCE_NAME] || [
+    tags[HTTP_METHOD],
+    tags[HTTP_ROUTE]
   ].filter(v => v).join(' ')
 }
 
@@ -81,6 +84,7 @@ class NativeWallProfiler {
     this._flushIntervalMillis = options.flushInterval || 60 * 1e3 // 60 seconds
     this._codeHotspotsEnabled = !!options.codeHotspotsEnabled
     this._endpointCollectionEnabled = !!options.endpointCollectionEnabled
+    this._v8ProfilerBugWorkaroundEnabled = !!options.v8ProfilerBugWorkaroundEnabled
     this._mapper = undefined
     this._pprof = undefined
 
@@ -99,7 +103,7 @@ class NativeWallProfiler {
 
     if (this._codeHotspotsEnabled && !this._emittedFFMessage && this._logger) {
       this._logger.debug(
-        `Wall profiler: Enable config_trace_show_breakdown_profiling_for_node feature flag to see code hotspots.`)
+        `Wall profiler: Enable trace_show_breakdown_profiling_for_node feature flag to see code hotspots.`)
       this._emittedFFMessage = true
     }
 
@@ -120,7 +124,8 @@ class NativeWallProfiler {
       durationMillis: this._flushIntervalMillis,
       sourceMapper: this._mapper,
       withContexts: this._codeHotspotsEnabled,
-      lineNumbers: false
+      lineNumbers: false,
+      workaroundV8Bug: this._v8ProfilerBugWorkaroundEnabled
     })
 
     if (this._codeHotspotsEnabled) {
@@ -170,7 +175,18 @@ class NativeWallProfiler {
       this._enter()
       this._lastSampleCount = 0
     }
-    return this._pprof.time.stop(restart, this._codeHotspotsEnabled ? generateLabels : undefined)
+    const profile = this._pprof.time.stop(restart, this._codeHotspotsEnabled ? generateLabels : undefined)
+    if (restart) {
+      const v8BugDetected = this._pprof.time.v8ProfilerStuckEventLoopDetected()
+      if (v8BugDetected === 1) {
+        this._logger?.warn('Wall profiler: possible v8 profiler stuck event loop detected.')
+        runtimeMetrics.increment('runtime.node.profiler.v8_cpu_profiler_maybe_stuck_event_loop', undefined, true)
+      } else if (v8BugDetected === 2) {
+        this._logger?.warn('Wall profiler: v8 profiler stuck event loop detected.')
+        runtimeMetrics.increment('runtime.node.profiler.v8_cpu_profiler_stuck_event_loop', undefined, true)
+      }
+    }
+    return profile
   }
 
   profile () {

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

@@ -2,13 +2,14 @@
 const NoopProxy = require('./noop/proxy')
 const DatadogTracer = require('./tracer')
 const Config = require('./config')
-const metrics = require('./metrics')
+const runtimeMetrics = require('./runtime_metrics')
 const log = require('./log')
 const { setStartupLogPluginManager } = require('./startup-log')
 const telemetry = require('./telemetry')
 const PluginManager = require('./plugin_manager')
 const remoteConfig = require('./appsec/remote_config')
 const AppsecSdk = require('./appsec/sdk')
+const dogstatsd = require('./dogstatsd')
 
 class Tracer extends NoopProxy {
   constructor () {
@@ -16,6 +17,7 @@ class Tracer extends NoopProxy {
 
     this._initialized = false
     this._pluginManager = new PluginManager(this)
+    this.dogstatsd = new dogstatsd.NoopDogStatsDClient()
   }
 
   init (options) {
@@ -26,6 +28,25 @@ class Tracer extends NoopProxy {
     try {
       const config = new Config(options) // TODO: support dynamic code config
 
+      if (config.dogstatsd) {
+        // Custom Metrics
+        this.dogstatsd = new dogstatsd.CustomMetrics({
+          host: config.dogstatsd.hostname,
+          port: config.dogstatsd.port,
+          tags: [
+            // these are the Runtime Metrics default tags
+            // Python also uses these as default Custom Metrics tags
+            `service:${config.tags.service}`,
+            `env:${config.tags.env}`,
+            `version:${config.tags.version}`
+          ]
+        })
+
+        setInterval(() => {
+          this.dogstatsd.flush()
+        }, 10 * 1000).unref()
+      }
+
       if (config.remoteConfig.enabled && !config.isCiVisibility) {
         const rc = remoteConfig.enable(config)
 
@@ -58,7 +79,7 @@ class Tracer extends NoopProxy {
       }
 
       if (config.runtimeMetrics) {
-        metrics.start(config)
+        runtimeMetrics.start(config)
       }
 
       if (config.tracing) {