dd-trace 5.0.0-pre-471478b → 5.0.0-pre-2fed3ce

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.0.0-pre-471478b",
+  "version": "5.0.0-pre-2fed3ce",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",

package/packages/datadog-instrumentations/src/cassandra-driver.js

@@ -28,7 +28,8 @@ addHook({ name: 'cassandra-driver', versions: ['>=3.0.0'] }, cassandra => {
     }
 
     return asyncResource.runInAsyncScope(() => {
-      startCh.publish({ keyspace: this.keyspace, query: queries, contactPoints: this.options?.contactPoints })
+      const contactPoints = this.options && this.options.contactPoints
+      startCh.publish({ keyspace: this.keyspace, query: queries, contactPoints })
       try {
         const res = batch.apply(this, arguments)
         if (typeof res === 'function' || !res) {
@@ -56,7 +57,8 @@ addHook({ name: 'cassandra-driver', versions: ['>=4.4'] }, cassandra => {
     }
     const asyncResource = new AsyncResource('bound-anonymous-fn')
     return asyncResource.runInAsyncScope(() => {
-      startCh.publish({ keyspace: this.keyspace, query, contactPoints: this.options?.contactPoints })
+      const contactPoints = this.options && this.options.contactPoints
+      startCh.publish({ keyspace: this.keyspace, query, contactPoints })
       const promise = _execute.apply(this, arguments)
 
       const promiseAsyncResource = new AsyncResource('bound-anonymous-fn')
@@ -88,7 +90,8 @@ addHook({ name: 'cassandra-driver', versions: ['3 - 4.3'] }, cassandra => {
       }
 
       return asyncResource.runInAsyncScope(() => {
-        startCh.publish({ keyspace: this.keyspace, query, contactPoints: this.options?.contactPoints })
+        const contactPoints = this.options && this.options.contactPoints
+        startCh.publish({ keyspace: this.keyspace, query, contactPoints })
 
         const lastIndex = arguments.length - 1
         let cb = arguments[lastIndex]

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

@@ -34,7 +34,7 @@ function createWrapGetConnection (name) {
   return function wrapRequest (request) {
     return function () {
       const connection = request.apply(this, arguments)
-      if (connectCh.hasSubscribers && connection?.url) {
+      if (connectCh.hasSubscribers && connection && connection.url) {
         connectCh.publish(connection.url)
       }
       return connection
@@ -49,7 +49,7 @@ function createWrapSelect () {
       if (arguments.length === 1) {
         const cb = arguments[0]
         arguments[0] = function (err, connection) {
-          if (connectCh.hasSubscribers && connection?.host) {
+          if (connectCh.hasSubscribers && connection && connection.host) {
             connectCh.publish({ hostname: connection.host.host, port: connection.host.port })
           }
           cb(err, connection)

package/packages/datadog-instrumentations/src/http2/client.js

@@ -1,32 +1,27 @@
 'use strict'
 
 const shimmer = require('../../../datadog-shimmer')
-const { addHook, channel, AsyncResource } = require('../helpers/instrument')
+const { addHook, channel } = require('../helpers/instrument')
 
 const connectChannel = channel('apm:http2:client:connect:start')
 const startChannel = channel('apm:http2:client:request:start')
-const finishChannel = channel('apm:http2:client:request:finish')
+const endChannel = channel('apm:http2:client:request:end')
+const asyncStartChannel = channel('apm:http2:client:request:asyncStart')
+const asyncEndChannel = channel('apm:http2:client:request:asyncEnd')
 const errorChannel = channel('apm:http2:client:request:error')
-const responseChannel = channel('apm:http2:client:response')
 
-function createWrapEmit (requestResource, parentResource) {
+function createWrapEmit (ctx) {
   return function wrapEmit (emit) {
     return function (event, arg1) {
-      requestResource.runInAsyncScope(() => {
-        switch (event) {
-          case 'response':
-            responseChannel.publish(arg1)
-            break
-          case 'error':
-            errorChannel.publish(arg1)
-          case 'close': // eslint-disable-line no-fallthrough
-            finishChannel.publish()
-            break
-        }
-      })
+      ctx.eventName = event
+      ctx.eventData = arg1
 
-      return parentResource.runInAsyncScope(() => {
-        return emit.apply(this, arguments)
+      return asyncStartChannel.runStores(ctx, () => {
+        try {
+          return emit.apply(this, arguments)
+        } finally {
+          asyncEndChannel.publish(ctx)
+        }
       })
     }
   }
@@ -35,17 +30,21 @@ function createWrapEmit (requestResource, parentResource) {
 function createWrapRequest (authority, options) {
   return function wrapRequest (request) {
     return function (headers) {
-      const parentResource = new AsyncResource('bound-anonymous-fn')
-      const requestResource = new AsyncResource('bound-anonymous-fn')
+      const ctx = { headers, authority, options }
 
-      return requestResource.runInAsyncScope(() => {
-        startChannel.publish({ headers, authority, options })
+      return startChannel.runStores(ctx, () => {
+        try {
+          const req = request.apply(this, arguments)
 
-        const req = request.apply(this, arguments)
+          shimmer.wrap(req, 'emit', createWrapEmit(ctx))
 
-        shimmer.wrap(req, 'emit', createWrapEmit(requestResource, parentResource))
-
-        return req
+          return req
+        } catch (e) {
+          ctx.error = e
+          errorChannel.publish(ctx)
+        } finally {
+          endChannel.publish(ctx)
+        }
       })
     }
   }

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

@@ -16,10 +16,19 @@ const consumerFinishCh = channel('apm:kafkajs:consume:finish')
 const consumerErrorCh = channel('apm:kafkajs:consume:error')
 
 addHook({ name: 'kafkajs', versions: ['>=1.4'] }, (obj) => {
-  const Kafka = obj.Kafka
+  class Kafka extends obj.Kafka {
+    constructor (options) {
+      super(options)
+      this._brokers = (options.brokers && typeof options.brokers !== 'function')
+        ? options.brokers.join(',') : undefined
+    }
+  }
+  obj.Kafka = Kafka
+
   shimmer.wrap(Kafka.prototype, 'producer', createProducer => function () {
     const producer = createProducer.apply(this, arguments)
     const send = producer.send
+    const bootstrapServers = this._brokers
 
     producer.send = function () {
       const innerAsyncResource = new AsyncResource('bound-anonymous-fn')
@@ -36,7 +45,7 @@ addHook({ name: 'kafkajs', versions: ['>=1.4'] }, (obj) => {
               message.headers = message.headers || {}
             }
           }
-          producerStartCh.publish({ topic, messages })
+          producerStartCh.publish({ topic, messages, bootstrapServers })
 
           const result = send.apply(this, arguments)
 

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

@@ -11,6 +11,8 @@ const startCh = channel('apm:redis:command:start')
 const finishCh = channel('apm:redis:command:finish')
 const errorCh = channel('apm:redis:command:error')
 
+let createClientUrl
+
 function wrapAddCommand (addCommand) {
   return function (command) {
     if (!startCh.hasSubscribers) {
@@ -22,7 +24,7 @@ function wrapAddCommand (addCommand) {
 
     const asyncResource = new AsyncResource('bound-anonymous-fn')
     return asyncResource.runInAsyncScope(() => {
-      start(this, name, args)
+      start(this, name, args, this._url)
 
       const res = addCommand.apply(this, arguments)
       const onResolve = asyncResource.bind(() => finish(finishCh, errorCh))
@@ -35,12 +37,53 @@ function wrapAddCommand (addCommand) {
   }
 }
 
-addHook({ name: '@redis/client', file: 'dist/lib/client/commands-queue.js', versions: ['>=1.1'] }, redis => {
+function wrapCommandQueueClass (cls) {
+  const ret = class RedisCommandQueue extends cls {
+    constructor () {
+      super(arguments)
+      if (createClientUrl) {
+        try {
+          const parsed = new URL(createClientUrl)
+          if (parsed) {
+            this._url = { host: parsed.hostname, port: +parsed.port || 6379 }
+          }
+        } catch (error) {
+          // ignore
+        }
+      }
+      this._url = this._url || { host: 'localhost', port: 6379 }
+    }
+  }
+  return ret
+}
+
+function wrapCreateClient (request) {
+  return function (opts) {
+    createClientUrl = opts && opts.url
+    const ret = request.apply(this, arguments)
+    createClientUrl = undefined
+    return ret
+  }
+}
+
+addHook({ name: '@node-redis/client', file: 'dist/lib/client/commands-queue.js', versions: ['>=1'] }, redis => {
+  redis.default = wrapCommandQueueClass(redis.default)
   shimmer.wrap(redis.default.prototype, 'addCommand', wrapAddCommand)
   return redis
 })
 
-addHook({ name: '@node-redis/client', file: 'dist/lib/client/commands-queue.js', versions: ['>=1'] }, redis => {
+addHook({ name: '@node-redis/client', file: 'dist/lib/client/index.js', versions: ['>=1'] }, redis => {
+  shimmer.wrap(redis.default, 'create', wrapCreateClient)
+  return redis
+})
+
+addHook({ name: '@redis/client', file: 'dist/lib/client/index.js', versions: ['>=1.1'] }, redis => {
+  shimmer.wrap(redis.default, 'create', wrapCreateClient)
+  return redis
+})
+
+addHook({ name: '@redis/client', file: 'dist/lib/client/commands-queue.js', versions: ['>=1.1'] }, redis => {
+  redis.default = wrapCommandQueueClass(redis.default)
   shimmer.wrap(redis.default.prototype, 'addCommand', wrapAddCommand)
   return redis
 })
@@ -106,9 +149,9 @@ addHook({ name: 'redis', versions: ['>=0.12 <2.6'] }, redis => {
   return redis
 })
 
-function start (client, command, args) {
+function start (client, command, args, url = {}) {
   const db = client.selected_db
-  const connectionOptions = client.connection_options || client.connection_option || client.connectionOption || {}
+  const connectionOptions = client.connection_options || client.connection_option || client.connectionOption || url
   startCh.publish({ db, command, args, connectionOptions })
 }
 

package/packages/datadog-plugin-cypress/src/plugin.js

@@ -37,7 +37,7 @@ const CYPRESS_STATUS_TO_TEST_STATUS = {
 function getTestSpanMetadata (tracer, testName, testSuite, cypressConfig) {
   const childOf = getTestParentSpan(tracer)
 
-  const commonTags = getTestCommonTags(testName, testSuite, cypressConfig.version)
+  const commonTags = getTestCommonTags(testName, testSuite, cypressConfig.version, TEST_FRAMEWORK_NAME)
 
   return {
     childOf,

package/packages/datadog-plugin-http2/src/client.js

@@ -8,7 +8,6 @@ const log = require('../../dd-trace/src/log')
 const tags = require('../../../ext/tags')
 const kinds = require('../../../ext/kinds')
 const formats = require('../../../ext/formats')
-const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 const { COMPONENT, CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
 const urlFilter = require('../../dd-trace/src/plugins/util/urlfilter')
 
@@ -25,32 +24,11 @@ const HTTP2_HEADER_STATUS = ':status'
 const HTTP2_METHOD_GET = 'GET'
 
 class Http2ClientPlugin extends ClientPlugin {
-  static get id () {
-    return 'http2'
-  }
-
-  constructor (...args) {
-    super(...args)
-
-    this.addSub('apm:http2:client:response', (headers) => {
-      const span = storage.getStore().span
-      const status = headers && headers[HTTP2_HEADER_STATUS]
-
-      span.setTag(HTTP_STATUS_CODE, status)
-
-      if (!this.config.validateStatus(status)) {
-        this.addError()
-      }
+  static get id () { return 'http2' }
+  static get prefix () { return `apm:http2:client:request` }
 
-      addHeaderTags(span, headers, HTTP_RESPONSE_HEADERS, this.config)
-    })
-  }
-
-  addTraceSub (eventName, handler) {
-    this.addSub(`apm:${this.constructor.id}:client:${this.operation}:${eventName}`, handler)
-  }
-
-  start ({ authority, options, headers = {} }) {
+  bindStart (message) {
+    const { authority, options, headers = {} } = message
     const sessionDetails = extractSessionDetails(authority, options)
     const path = headers[HTTP2_HEADER_PATH] || '/'
     const pathname = path.split(/[?#]/)[0]
@@ -75,7 +53,7 @@ class Http2ClientPlugin extends ClientPlugin {
       metrics: {
         [CLIENT_PORT_KEY]: parseInt(sessionDetails.port)
       }
-    })
+    }, false)
 
     // TODO: Figure out a better way to do this for any span.
     if (!allowed) {
@@ -88,14 +66,53 @@ class Http2ClientPlugin extends ClientPlugin {
       this.tracer.inject(span, HTTP_HEADERS, headers)
     }
 
-    analyticsSampler.sample(span, this.config.measured)
+    message.parentStore = store
+    message.currentStore = { ...store, span }
+
+    return message.currentStore
+  }
+
+  bindAsyncStart ({ eventName, eventData, currentStore, parentStore }) {
+    switch (eventName) {
+      case 'response':
+        this._onResponse(currentStore, eventData)
+        return parentStore
+      case 'error':
+        this._onError(currentStore, eventData)
+        return parentStore
+      case 'close':
+        this._onClose(currentStore, eventData)
+        return parentStore
+    }
 
-    this.enter(span, store)
+    return storage.getStore()
   }
 
   configure (config) {
     return super.configure(normalizeConfig(config))
   }
+
+  _onResponse (store, headers) {
+    const status = headers && headers[HTTP2_HEADER_STATUS]
+
+    store.span.setTag(HTTP_STATUS_CODE, status)
+
+    if (!this.config.validateStatus(status)) {
+      storage.run(store, () => this.addError())
+    }
+
+    addHeaderTags(store.span, headers, HTTP_RESPONSE_HEADERS, this.config)
+  }
+
+  _onError ({ span }, error) {
+    span.setTag('error', error)
+    span.finish()
+  }
+
+  _onClose ({ span }) {
+    this.tagPeerService(span)
+    span.finish()
+  }
 }
 
 function extractSessionDetails (authority, options) {

package/packages/datadog-plugin-kafkajs/src/producer.js

@@ -2,12 +2,14 @@
 
 const ProducerPlugin = require('../../dd-trace/src/plugins/producer')
 const { encodePathwayContext } = require('../../dd-trace/src/datastreams/pathway')
+const BOOTSTRAP_SERVERS_KEY = 'messaging.kafka.bootstrap.servers'
 
 class KafkajsProducerPlugin extends ProducerPlugin {
   static get id () { return 'kafkajs' }
   static get operation () { return 'produce' }
+  static get peerServicePrecursors () { return [BOOTSTRAP_SERVERS_KEY] }
 
-  start ({ topic, messages }) {
+  start ({ topic, messages, bootstrapServers }) {
     let pathwayCtx
     if (this.config.dsmEnabled) {
       const dataStreamsContext = this.tracer
@@ -24,6 +26,9 @@ class KafkajsProducerPlugin extends ProducerPlugin {
         'kafka.batch_size': messages.length
       }
     })
+    if (bootstrapServers) {
+      span.setTag(BOOTSTRAP_SERVERS_KEY, bootstrapServers)
+    }
     for (const message of messages) {
       if (typeof message === 'object') {
         if (this.config.dsmEnabled) message.headers['dd-pathway-ctx'] = pathwayCtx

package/packages/datadog-plugin-openai/src/services.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const DogStatsDClient = require('../../dd-trace/src/dogstatsd')
+const { DogStatsDClient, NoopDogStatsDClient } = require('../../dd-trace/src/dogstatsd')
 const ExternalLogger = require('../../dd-trace/src/external-logger/src')
 
 const FLUSH_INTERVAL = 10 * 1000
@@ -10,15 +10,19 @@ let logger = null
 let interval = null
 
 module.exports.init = function (tracerConfig) {
-  metrics = new DogStatsDClient({
-    host: tracerConfig.dogstatsd.hostname,
-    port: tracerConfig.dogstatsd.port,
-    tags: [
-      `service:${tracerConfig.tags.service}`,
-      `env:${tracerConfig.tags.env}`,
-      `version:${tracerConfig.tags.version}`
-    ]
-  })
+  if (tracerConfig.dogstatsd) {
+    metrics = new DogStatsDClient({
+      host: tracerConfig.dogstatsd.hostname,
+      port: tracerConfig.dogstatsd.port,
+      tags: [
+        `service:${tracerConfig.tags.service}`,
+        `env:${tracerConfig.tags.env}`,
+        `version:${tracerConfig.tags.version}`
+      ]
+    })
+  } else {
+    metrics = new NoopDogStatsDClient()
+  }
 
   logger = new ExternalLogger({
     ddsource: 'openai',

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

@@ -156,7 +156,7 @@ function isMoreSpecificThan (routeA, routeB) {
 }
 
 function routeIsRegex (route) {
-  return route.includes('(/') && route.includes('/)')
+  return route.includes('(/')
 }
 
 module.exports = RouterPlugin

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

@@ -143,4 +143,17 @@ class DogStatsDClient {
   }
 }
 
-module.exports = DogStatsDClient
+class NoopDogStatsDClient {
+  gauge () { }
+
+  increment () { }
+
+  distribution () { }
+
+  flush () { }
+}
+
+module.exports = {
+  DogStatsDClient,
+  NoopDogStatsDClient
+}

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

@@ -5,7 +5,7 @@
 const { URL, format } = require('url')
 const v8 = require('v8')
 const os = require('os')
-const Client = require('./dogstatsd')
+const { DogStatsDClient } = require('./dogstatsd')
 const log = require('./log')
 const Histogram = require('./histogram')
 const { performance } = require('perf_hooks')
@@ -67,7 +67,7 @@ module.exports = {
       }))
     }
 
-    client = new Client(clientConfig)
+    client = new DogStatsDClient(clientConfig)
 
     time = process.hrtime()
 

package/packages/dd-trace/src/plugins/ci_plugin.js

@@ -111,7 +111,12 @@ module.exports = class CiPlugin extends Plugin {
     const childOf = getTestParentSpan(this.tracer)
 
     let testTags = {
-      ...getTestCommonTags(testName, testSuite, this.frameworkVersion),
+      ...getTestCommonTags(
+        testName,
+        testSuite,
+        this.frameworkVersion,
+        this.constructor.id
+      ),
       [COMPONENT]: this.constructor.id,
       ...extraTags
     }

package/packages/dd-trace/src/plugins/outbound.js

@@ -62,13 +62,17 @@ class OutboundPlugin extends TracingPlugin {
 
   finish () {
     const span = this.activeSpan
+    this.tagPeerService(span)
+    super.finish(...arguments)
+  }
+
+  tagPeerService (span) {
     if (this.tracer._computePeerService) {
       const peerData = this.getPeerService(span.context()._tags)
       if (peerData) {
         span.addTags(peerData)
       }
     }
-    super.finish(...arguments)
   }
 
   connect (url) {

package/packages/dd-trace/src/plugins/plugin.js

@@ -25,9 +25,31 @@ class Subscription {
   }
 }
 
+class StoreBinding {
+  constructor (event, transform) {
+    this._channel = dc.channel(event)
+    this._transform = data => {
+      const store = storage.getStore()
+
+      return !store || !store.noop
+        ? transform(data)
+        : store
+    }
+  }
+
+  enable () {
+    this._channel.bindStore(storage, this._transform)
+  }
+
+  disable () {
+    this._channel.unbindStore(storage, this._transform)
+  }
+}
+
 module.exports = class Plugin {
   constructor (tracer, tracerConfig) {
     this._subscriptions = []
+    this._bindings = []
     this._enabled = false
     this._tracer = tracer
     this.config = {} // plugin-specific configuration, unset until .configure() is called
@@ -53,6 +75,10 @@ module.exports = class Plugin {
     this._subscriptions.push(new Subscription(channelName, handler))
   }
 
+  addBind (channelName, transform) {
+    this._bindings.push(new StoreBinding(channelName, transform))
+  }
+
   addError (error) {
     const store = storage.getStore()
 
@@ -71,9 +97,11 @@ module.exports = class Plugin {
     if (config.enabled && !this._enabled) {
       this._enabled = true
       this._subscriptions.forEach(sub => sub.enable())
+      this._bindings.forEach(sub => sub.enable())
     } else if (!config.enabled && this._enabled) {
       this._enabled = false
       this._subscriptions.forEach(sub => sub.disable())
+      this._bindings.forEach(sub => sub.disable())
     }
   }
 }

package/packages/dd-trace/src/plugins/tracing.js

@@ -13,17 +13,7 @@ class TracingPlugin extends Plugin {
     this.component = this.constructor.component || this.constructor.id
     this.operation = this.constructor.operation
 
-    this.addTraceSub('start', message => {
-      this.start(message)
-    })
-
-    this.addTraceSub('error', err => {
-      this.error(err)
-    })
-
-    this.addTraceSub('finish', message => {
-      this.finish(message)
-    })
+    this.addTraceSubs()
   }
 
   get activeSpan () {
@@ -65,19 +55,45 @@ class TracingPlugin extends Plugin {
     this.addError(error)
   }
 
+  addTraceSubs () {
+    const events = ['start', 'end', 'asyncStart', 'asyncEnd', 'error', 'finish']
+
+    for (const event of events) {
+      const bindName = `bind${event.charAt(0).toUpperCase()}${event.slice(1)}`
+
+      if (this[event]) {
+        this.addTraceSub(event, message => {
+          this[event](message)
+        })
+      }
+
+      if (this[bindName]) {
+        this.addTraceBind(event, message => this[bindName](message))
+      }
+    }
+  }
+
   addTraceSub (eventName, handler) {
-    this.addSub(`apm:${this.component}:${this.operation}:${eventName}`, handler)
+    const prefix = this.constructor.prefix || `apm:${this.component}:${this.operation}`
+    this.addSub(`${prefix}:${eventName}`, handler)
+  }
+
+  addTraceBind (eventName, transform) {
+    const prefix = this.constructor.prefix || `apm:${this.component}:${this.operation}`
+    this.addBind(`${prefix}:${eventName}`, transform)
   }
 
   addError (error) {
     const span = this.activeSpan
 
     if (!span._spanContext._tags['error']) {
+      // Errors may be wrapped in a context.
+      error = (error && error.error) || error
       span.setTag('error', error || 1)
     }
   }
 
-  startSpan (name, { childOf, kind, meta, metrics, service, resource, type } = {}) {
+  startSpan (name, { childOf, kind, meta, metrics, service, resource, type } = {}, enter = true) {
     const store = storage.getStore()
 
     if (store && childOf === undefined) {
@@ -100,7 +116,10 @@ class TracingPlugin extends Plugin {
 
     analyticsSampler.sample(span, this.config.measured)
 
-    storage.enterWith({ ...store, span })
+    // TODO: Remove this after migration to TracingChannel is done.
+    if (enter) {
+      storage.enterWith({ ...store, span })
+    }
 
     return span
   }

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

@@ -77,7 +77,7 @@ function filterSensitiveInfoFromRepository (repositoryUrl) {
 
     return `${protocol}//${hostname}${pathname}`
   } catch (e) {
-    return repositoryUrl
+    return ''
   }
 }
 

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

@@ -1,11 +1,13 @@
 const path = require('path')
 const fs = require('fs')
+const { URL } = require('url')
+const log = require('../../log')
 
 const istanbul = require('istanbul-lib-coverage')
 const ignore = require('ignore')
 
 const { getGitMetadata } = require('./git')
-const { getUserProviderGitMetadata } = require('./user-provided-git')
+const { getUserProviderGitMetadata, validateGitRepositoryUrl, validateGitCommitSha } = require('./user-provided-git')
 const { getCIMetadata } = require('./ci')
 const { getRuntimeAndOSMetadata } = require('./env')
 const {
@@ -16,7 +18,8 @@ const {
   GIT_COMMIT_AUTHOR_EMAIL,
   GIT_COMMIT_AUTHOR_NAME,
   GIT_COMMIT_MESSAGE,
-  CI_WORKSPACE_PATH
+  CI_WORKSPACE_PATH,
+  CI_PIPELINE_URL
 } = require('./tags')
 const id = require('../../id')
 
@@ -104,7 +107,8 @@ module.exports = {
   mergeCoverage,
   fromCoverageMapToCoverage,
   getTestLineStart,
-  getCallSites
+  getCallSites,
+  removeInvalidMetadata
 }
 
 // Returns pkg manager and its version, separated by '-', e.g. npm-8.15.0 or yarn-1.22.19
@@ -116,6 +120,39 @@ function getPkgManager () {
   }
 }
 
+function validateUrl (url) {
+  try {
+    const urlObject = new URL(url)
+    return (urlObject.protocol === 'https:' || urlObject.protocol === 'http:')
+  } catch (e) {
+    return false
+  }
+}
+
+function removeInvalidMetadata (metadata) {
+  return Object.keys(metadata).reduce((filteredTags, tag) => {
+    if (tag === GIT_REPOSITORY_URL) {
+      if (!validateGitRepositoryUrl(metadata[GIT_REPOSITORY_URL])) {
+        log.error('DD_GIT_REPOSITORY_URL must be a valid URL')
+        return filteredTags
+      }
+    }
+    if (tag === GIT_COMMIT_SHA) {
+      if (!validateGitCommitSha(metadata[GIT_COMMIT_SHA])) {
+        log.error('DD_GIT_COMMIT_SHA must be a full-length git SHA')
+        return filteredTags
+      }
+    }
+    if (tag === CI_PIPELINE_URL) {
+      if (!validateUrl(metadata[CI_PIPELINE_URL])) {
+        return filteredTags
+      }
+    }
+    filteredTags[tag] = metadata[tag]
+    return filteredTags
+  }, {})
+}
+
 function getTestEnvironmentMetadata (testFramework, config) {
   // TODO: eventually these will come from the tracer (generally available)
   const ciMetadata = getCIMetadata()
@@ -155,7 +192,7 @@ function getTestEnvironmentMetadata (testFramework, config) {
   if (config && config.service) {
     metadata['service.name'] = config.service
   }
-  return metadata
+  return removeInvalidMetadata(metadata)
 }
 
 function getTestParametersString (parametersByTestName, testName) {
@@ -173,6 +210,13 @@ function getTestParametersString (parametersByTestName, testName) {
   }
 }
 
+function getTestTypeFromFramework (testFramework) {
+  if (testFramework === 'playwright' || testFramework === 'cypress') {
+    return 'browser'
+  }
+  return 'test'
+}
+
 function finishAllTraceSpans (span) {
   span.context()._trace.started.forEach(traceSpan => {
     if (traceSpan !== span) {
@@ -188,10 +232,10 @@ function getTestParentSpan (tracer) {
   })
 }
 
-function getTestCommonTags (name, suite, version) {
+function getTestCommonTags (name, suite, version, testFramework) {
   return {
     [SPAN_TYPE]: 'test',
-    [TEST_TYPE]: 'test',
+    [TEST_TYPE]: getTestTypeFromFramework(testFramework),
     [SAMPLING_RULE_DECISION]: 1,
     [SAMPLING_PRIORITY]: AUTO_KEEP,
     [TEST_NAME]: name,
@@ -269,12 +313,12 @@ function getCodeOwnersForFilename (filename, entries) {
   return null
 }
 
-function getTestLevelCommonTags (command, testFrameworkVersion) {
+function getTestLevelCommonTags (command, testFrameworkVersion, testFramework) {
   return {
     [TEST_FRAMEWORK_VERSION]: testFrameworkVersion,
     [LIBRARY_VERSION]: ddTraceVersion,
     [TEST_COMMAND]: command,
-    [TEST_TYPE]: 'test'
+    [TEST_TYPE]: getTestTypeFromFramework(testFramework)
   }
 }
 
@@ -284,7 +328,7 @@ function getTestSessionCommonTags (command, testFrameworkVersion, testFramework)
     [RESOURCE_NAME]: `test_session.${command}`,
     [TEST_MODULE]: testFramework,
     [TEST_TOOLCHAIN]: getPkgManager(),
-    ...getTestLevelCommonTags(command, testFrameworkVersion)
+    ...getTestLevelCommonTags(command, testFrameworkVersion, testFramework)
   }
 }
 
@@ -293,7 +337,7 @@ function getTestModuleCommonTags (command, testFrameworkVersion, testFramework)
     [SPAN_TYPE]: 'test_module_end',
     [RESOURCE_NAME]: `test_module.${command}`,
     [TEST_MODULE]: testFramework,
-    ...getTestLevelCommonTags(command, testFrameworkVersion)
+    ...getTestLevelCommonTags(command, testFrameworkVersion, testFramework)
   }
 }
 
@@ -303,7 +347,7 @@ function getTestSuiteCommonTags (command, testFrameworkVersion, testSuite, testF
     [RESOURCE_NAME]: `test_suite.${testSuite}`,
     [TEST_MODULE]: testFramework,
     [TEST_SUITE]: testSuite,
-    ...getTestLevelCommonTags(command, testFrameworkVersion)
+    ...getTestLevelCommonTags(command, testFrameworkVersion, testFramework)
   }
 }
 

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

@@ -13,7 +13,6 @@ const {
 } = require('./tags')
 
 const { normalizeRef } = require('./ci')
-const log = require('../../log')
 const { URL } = require('url')
 
 function removeEmptyValues (tags) {
@@ -53,25 +52,6 @@ function validateGitCommitSha (gitCommitSha) {
   return isValidSha1 || isValidSha256
 }
 
-function removeInvalidGitMetadata (metadata) {
-  return Object.keys(metadata).reduce((filteredTags, tag) => {
-    if (tag === GIT_REPOSITORY_URL) {
-      if (!validateGitRepositoryUrl(metadata[GIT_REPOSITORY_URL])) {
-        log.error('DD_GIT_REPOSITORY_URL must be a valid URL')
-        return filteredTags
-      }
-    }
-    if (tag === GIT_COMMIT_SHA) {
-      if (!validateGitCommitSha(metadata[GIT_COMMIT_SHA])) {
-        log.error('DD_GIT_COMMIT_SHA must be a full-length git SHA')
-        return filteredTags
-      }
-    }
-    filteredTags[tag] = metadata[tag]
-    return filteredTags
-  }, {})
-}
-
 function getUserProviderGitMetadata () {
   const {
     DD_GIT_COMMIT_SHA,
@@ -95,7 +75,7 @@ function getUserProviderGitMetadata () {
     tag = normalizeRef(DD_GIT_BRANCH)
   }
 
-  const metadata = removeEmptyValues({
+  return removeEmptyValues({
     [GIT_COMMIT_SHA]: DD_GIT_COMMIT_SHA,
     [GIT_BRANCH]: branch,
     [GIT_REPOSITORY_URL]: filterSensitiveInfoFromRepository(DD_GIT_REPOSITORY_URL),
@@ -108,7 +88,6 @@ function getUserProviderGitMetadata () {
     [GIT_COMMIT_AUTHOR_EMAIL]: DD_GIT_COMMIT_AUTHOR_EMAIL,
     [GIT_COMMIT_AUTHOR_DATE]: DD_GIT_COMMIT_AUTHOR_DATE
   })
-  return removeInvalidGitMetadata(metadata)
 }
 
 module.exports = { getUserProviderGitMetadata, validateGitRepositoryUrl, validateGitCommitSha }

package/packages/dd-trace/src/service-naming/schemas/v0/web.js

@@ -1,9 +1,10 @@
 const { identityService } = require('../util')
+const { DD_MAJOR } = require('../../../../../../version')
 
 const web = {
   client: {
     grpc: {
-      opName: () => 'grpc.client',
+      opName: () => DD_MAJOR <= 2 ? 'grpc.request' : 'grpc.client',
       serviceName: identityService
     },
     moleculer: {
@@ -13,7 +14,7 @@ const web = {
   },
   server: {
     grpc: {
-      opName: () => 'grpc.server',
+      opName: () => DD_MAJOR <= 2 ? 'grpc.request' : 'grpc.server',
       serviceName: identityService
     },
     moleculer: {

package/packages/dd-trace/src/telemetry/metrics.js

@@ -89,6 +89,26 @@ class CountMetric extends Metric {
   }
 }
 
+class DistributionMetric extends Metric {
+  get type () {
+    return 'distribution'
+  }
+
+  track (value = 1) {
+    this.points.push(value)
+  }
+
+  toJSON () {
+    const { metric, points, tags, common } = this
+    return {
+      metric,
+      points,
+      common,
+      tags
+    }
+  }
+}
+
 class GaugeMetric extends Metric {
   get type () {
     return 'gauge'
@@ -129,11 +149,12 @@ class RateMetric extends Metric {
 
 const metricsTypes = {
   count: CountMetric,
+  distribution: DistributionMetric,
   gauge: GaugeMetric,
   rate: RateMetric
 }
 
-class Namespace extends Map {
+class MetricsCollection extends Map {
   constructor (namespace) {
     super()
     this.namespace = namespace
@@ -146,43 +167,68 @@ class Namespace extends Map {
   }
 
   toString () {
-    return `dd.instrumentation_telemetry_data.${this.namespace}`
+    return this.namespace
+  }
+
+  toJSON () {
+    if (!this.size) return
+    const { namespace } = this
+    return {
+      namespace,
+      series: mapToJsonArray(this)
+    }
   }
+}
 
-  getMetric (type, name, tags, interval) {
-    const metricId = getId(type, this, name, tags)
+function getMetric (collection, type, name, tags, interval) {
+  const metricId = getId(type, collection, name, tags)
 
-    let metric = this.get(metricId)
-    if (metric) return metric
+  let metric = collection.get(metricId)
+  if (metric) return metric
 
-    const Factory = metricsTypes[type]
-    if (!Factory) {
-      throw new Error(`Unknown metric type ${type}`)
-    }
+  const Factory = metricsTypes[type]
+  if (!Factory) {
+    throw new Error(`Unknown metric type ${type}`)
+  }
+
+  metric = new Factory(collection, name, true, tags, interval)
+  collection.set(metricId, metric)
 
-    metric = new Factory(this, name, true, tags, interval)
-    this.set(metricId, metric)
+  return metric
+}
 
-    return metric
+class Namespace {
+  constructor (namespace) {
+    this.distributions = new MetricsCollection(namespace)
+    this.metrics = new MetricsCollection(namespace)
+  }
+
+  reset () {
+    this.metrics.reset()
+    this.distributions.reset()
   }
 
   count (name, tags) {
-    return this.getMetric('count', name, tags)
+    return getMetric(this.metrics, 'count', name, tags)
   }
 
   gauge (name, tags) {
-    return this.getMetric('gauge', name, tags)
+    return getMetric(this.metrics, 'gauge', name, tags)
   }
 
   rate (name, interval, tags) {
-    return this.getMetric('rate', name, tags, interval)
+    return getMetric(this.metrics, 'rate', name, tags, interval)
+  }
+
+  distribution (name, tags) {
+    return getMetric(this.distributions, 'distribution', name, tags)
   }
 
   toJSON () {
-    const { namespace } = this
+    const { distributions, metrics } = this
     return {
-      namespace,
-      series: mapToJsonArray(this)
+      distributions: distributions.toJSON(),
+      metrics: metrics.toJSON()
     }
   }
 }
@@ -203,7 +249,15 @@ class NamespaceManager extends Map {
 
   send (config, application, host) {
     for (const namespace of this.values()) {
-      sendData(config, application, host, 'generate-metrics', namespace.toJSON())
+      const { metrics, distributions } = namespace.toJSON()
+
+      if (metrics) {
+        sendData(config, application, host, 'generate-metrics', metrics)
+      }
+
+      if (distributions) {
+        sendData(config, application, host, 'distributions', distributions)
+      }
 
       // TODO: This could also be clear() but then it'd have to rebuild all
       // metric instances on every send. This may be desirable if we want tags
@@ -217,8 +271,10 @@ const manager = new NamespaceManager()
 
 module.exports = {
   CountMetric,
+  DistributionMetric,
   GaugeMetric,
   RateMetric,
+  MetricsCollection,
   Namespace,
   NamespaceManager,
   manager

package/packages/diagnostics_channel/src/index.js

@@ -54,4 +54,68 @@ if (major === '19' && minor === '9') {
   }
 }
 
+if (!Channel.prototype.runStores) {
+  const ActiveChannelPrototype = getActiveChannelPrototype()
+
+  Channel.prototype.bindStore = ActiveChannelPrototype.bindStore = function (store, transform) {
+    if (!this._stores) {
+      this._stores = new Map()
+    }
+    this._stores.set(store, transform)
+  }
+
+  Channel.prototype.unbindStore = ActiveChannelPrototype.runStores = function (store) {
+    if (!this._stores) return
+    this._stores.delete(store)
+  }
+
+  Channel.prototype.runStores = ActiveChannelPrototype.runStores = function (data, fn, thisArg, ...args) {
+    if (!this._stores) return Reflect.apply(fn, thisArg, args)
+
+    let run = () => {
+      this.publish(data)
+      return Reflect.apply(fn, thisArg, args)
+    }
+
+    for (const entry of this._stores.entries()) {
+      const store = entry[0]
+      const transform = entry[1]
+      run = wrapStoreRun(store, data, run, transform)
+    }
+
+    return run()
+  }
+}
+
+function defaultTransform (data) {
+  return data
+}
+
+function wrapStoreRun (store, data, next, transform = defaultTransform) {
+  return () => {
+    let context
+    try {
+      context = transform(data)
+    } catch (err) {
+      process.nextTick(() => {
+        throw err
+      })
+      return next()
+    }
+
+    return store.run(context, next)
+  }
+}
+
+function getActiveChannelPrototype () {
+  const dummyChannel = channel('foo')
+  const listener = () => {}
+
+  dummyChannel.subscribe(listener)
+  const ActiveChannelPrototype = Object.getPrototypeOf(dummyChannel)
+  dummyChannel.unsubscribe(listener)
+
+  return ActiveChannelPrototype
+}
+
 module.exports = dc