dd-trace 4.8.1 → 4.10.0

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

@@ -10,6 +10,7 @@ module.exports = {
   get '@grpc/grpc-js' () { return require('../../../datadog-plugin-grpc/src') },
   get '@hapi/hapi' () { return require('../../../datadog-plugin-hapi/src') },
   get '@jest/core' () { return require('../../../datadog-plugin-jest/src') },
+  get '@jest/test-sequencer' () { return require('../../../datadog-plugin-jest/src') },
   get '@jest/transform' () { return require('../../../datadog-plugin-jest/src') },
   get '@koa/router' () { return require('../../../datadog-plugin-koa/src') },
   get '@node-redis/client' () { return require('../../../datadog-plugin-redis/src') },

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

@@ -22,17 +22,24 @@ class TracingPlugin extends Plugin {
     return store && store.span
   }
 
-  serviceName (...serviceArgs) {
-    if (Nomenclature.shouldUseConsistentServiceNaming) {
-      return Nomenclature.shortCircuitServiceName(this.config, ...serviceArgs)
-    }
-    const { type, id, kind } = this.constructor
-    return Nomenclature.serviceName(type, kind, id, ...serviceArgs)
+  serviceName (opts = {}) {
+    const {
+      type = this.constructor.type,
+      id = this.constructor.id,
+      kind = this.constructor.kind
+    } = opts
+
+    return Nomenclature.serviceName(type, kind, id, opts)
   }
 
-  operationName (...opNameArgs) {
-    const { type, id, kind } = this.constructor
-    return Nomenclature.opName(type, kind, id, ...opNameArgs)
+  operationName (opts = {}) {
+    const {
+      type = this.constructor.type,
+      id = this.constructor.id,
+      kind = this.constructor.kind
+    } = opts
+
+    return Nomenclature.opName(type, kind, id, opts)
   }
 
   configure (config) {

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

@@ -30,8 +30,8 @@ class Tracer extends NoopProxy {
         remoteConfig.enable(config)
       }
 
-      if (config.isGCPFunction) {
-        require('./serverless').maybeStartServerlessMiniAgent()
+      if (config.isGCPFunction || config.isAzureFunctionConsumptionPlan) {
+        require('./serverless').maybeStartServerlessMiniAgent(config)
       }
 
       if (config.profiling.enabled) {

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

@@ -1,14 +1,19 @@
 'use strict'
 
-function maybeStartServerlessMiniAgent () {
-  let rustBinaryPath =
-    '/workspace/node_modules/@datadog/sma/datadog-serverless-agent-linux-amd64/datadog-serverless-trace-mini-agent'
-  if (process.env.DD_MINI_AGENT_PATH !== undefined) {
-    rustBinaryPath = process.env.DD_MINI_AGENT_PATH
+const log = require('./log')
+
+function maybeStartServerlessMiniAgent (config) {
+  if (process.platform !== 'win32' && process.platform !== 'linux') {
+    log.error(`Serverless Mini Agent is only supported on Windows and Linux.`)
+    return
   }
-  const log = require('./log')
+
+  const rustBinaryPath = getRustBinaryPath(config)
+
   const fs = require('fs')
 
+  log.debug(`Trying to spawn the Serverless Mini Agent at path: ${rustBinaryPath}`)
+
   // trying to spawn with an invalid path will return a non-descriptive error, so we want to catch
   // invalid paths and log our own error.
   if (!fs.existsSync(rustBinaryPath)) {
@@ -22,4 +27,43 @@ function maybeStartServerlessMiniAgent () {
   }
 }
 
-module.exports = { maybeStartServerlessMiniAgent }
+function getRustBinaryPath (config) {
+  if (process.env.DD_MINI_AGENT_PATH !== undefined) {
+    return process.env.DD_MINI_AGENT_PATH
+  }
+
+  const rustBinaryPathRoot = config.isGCPFunction ? '/workspace' : '/home/site/wwwroot'
+  const rustBinaryPathOsFolder = process.platform === 'win32'
+    ? 'datadog-serverless-agent-windows-amd64' : 'datadog-serverless-agent-linux-amd64'
+
+  const rustBinaryExtension = process.platform === 'win32' ? '.exe' : ''
+
+  const rustBinaryPath =
+    `${rustBinaryPathRoot}/node_modules/@datadog/sma/${rustBinaryPathOsFolder}/\
+datadog-serverless-trace-mini-agent${rustBinaryExtension}`
+
+  return rustBinaryPath
+}
+
+function getIsGCPFunction () {
+  const isDeprecatedGCPFunction = process.env.FUNCTION_NAME !== undefined && process.env.GCP_PROJECT !== undefined
+  const isNewerGCPFunction = process.env.K_SERVICE !== undefined && process.env.FUNCTION_TARGET !== undefined
+
+  return isDeprecatedGCPFunction || isNewerGCPFunction
+}
+
+function getIsAzureFunctionConsumptionPlan () {
+  const isAzureFunction =
+    process.env.FUNCTIONS_EXTENSION_VERSION !== undefined && process.env.FUNCTIONS_WORKER_RUNTIME !== undefined
+  const azureWebsiteSKU = process.env.WEBSITE_SKU
+  const isConsumptionPlan = azureWebsiteSKU === undefined || azureWebsiteSKU === 'Dynamic'
+
+  return isAzureFunction && isConsumptionPlan
+}
+
+module.exports = {
+  maybeStartServerlessMiniAgent,
+  getIsGCPFunction,
+  getIsAzureFunctionConsumptionPlan,
+  getRustBinaryPath
+}

package/packages/dd-trace/src/service-naming/index.js

@@ -18,20 +18,16 @@ class SchemaManager {
     return this.config.spanRemoveIntegrationFromService && this.version === 'v0'
   }
 
-  opName (type, kind, plugin, ...opNameArgs) {
-    return this.schema.getOpName(type, kind, plugin, ...opNameArgs)
+  opName (type, kind, plugin, opts) {
+    return this.schema.getOpName(type, kind, plugin, opts)
   }
 
-  serviceName (type, kind, plugin, ...serviceNameArgs) {
-    return this.schema.getServiceName(type, kind, plugin, this.config.service, ...serviceNameArgs)
-  }
+  serviceName (type, kind, plugin, opts) {
+    const schema = this.shouldUseConsistentServiceNaming
+      ? this.schemas.v1
+      : this.schema
 
-  shortCircuitServiceName (pluginConfig, ...args) {
-    // We're short-circuiting, so we do not obey custom service functions
-    if (typeof pluginConfig.service === 'function') {
-      return this.config.service
-    }
-    return pluginConfig.service || this.config.service
+    return schema.getServiceName(type, kind, plugin, { ...opts, tracerService: this.config.service })
   }
 
   configure (config = {}) {

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

@@ -10,14 +10,14 @@ class SchemaDefinition {
     }
   }
 
-  getOpName (type, kind, plugin, ...opNameArgs) {
+  getOpName (type, kind, plugin, opts) {
     const item = this.getSchemaItem(type, kind, plugin)
-    return item.opName(...opNameArgs)
+    return item.opName(opts)
   }
 
-  getServiceName (type, kind, plugin, service, ...serviceNameArgs) {
+  getServiceName (type, kind, plugin, opts) {
     const item = this.getSchemaItem(type, kind, plugin)
-    return item.serviceName(service, ...serviceNameArgs)
+    return item.serviceName(opts)
   }
 }
 

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

@@ -1,5 +1,23 @@
-function identityService (service) {
-  return service
+function identityService ({ tracerService }) {
+  return tracerService
 }
 
-module.exports = { identityService }
+function getFormattedHostString ({ host, port }) {
+  return [host, port].filter(val => val).join(':')
+}
+
+function httpPluginClientService ({ tracerService, pluginConfig, sessionDetails }) {
+  if (pluginConfig.splitByDomain) {
+    return getFormattedHostString(sessionDetails)
+  } else if (pluginConfig.service) {
+    return pluginConfig.service
+  }
+
+  return tracerService
+}
+
+function awsServiceV0 ({ tracerService, awsService }) {
+  return `${tracerService}-aws-${awsService}`
+}
+
+module.exports = { identityService, httpPluginClientService, awsServiceV0 }

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

@@ -1,7 +1,7 @@
-const { identityService } = require('../util')
+const { identityService, awsServiceV0 } = require('../util')
 
-function amqpServiceName (service) {
-  return `${service}-amqp`
+function amqpServiceName ({ tracerService }) {
+  return `${tracerService}-amqp`
 }
 
 const messaging = {
@@ -16,15 +16,23 @@ const messaging = {
     },
     'google-cloud-pubsub': {
       opName: () => 'pubsub.request',
-      serviceName: service => `${service}-pubsub`
+      serviceName: ({ tracerService }) => `${tracerService}-pubsub`
     },
     kafkajs: {
       opName: () => 'kafka.produce',
-      serviceName: service => `${service}-kafka`
+      serviceName: ({ tracerService }) => `${tracerService}-kafka`
     },
     rhea: {
       opName: () => 'amqp.send',
-      serviceName: service => `${service}-amqp-producer`
+      serviceName: ({ tracerService }) => `${tracerService}-amqp-producer`
+    },
+    sqs: {
+      opName: () => 'aws.request',
+      serviceName: awsServiceV0
+    },
+    sns: {
+      opName: () => 'aws.request',
+      serviceName: awsServiceV0
     }
   },
   consumer: {
@@ -42,11 +50,15 @@ const messaging = {
     },
     kafkajs: {
       opName: () => 'kafka.consume',
-      serviceName: service => `${service}-kafka`
+      serviceName: ({ tracerService }) => `${tracerService}-kafka`
     },
     rhea: {
       opName: () => 'amqp.receive',
       serviceName: identityService
+    },
+    sqs: {
+      opName: () => 'aws.request',
+      serviceName: awsServiceV0
     }
   },
   client: {
@@ -56,7 +68,7 @@ const messaging = {
     },
     'google-cloud-pubsub': {
       opName: () => 'pubsub.request',
-      serviceName: service => `${service}-pubsub`
+      serviceName: ({ tracerService }) => `${tracerService}-pubsub`
     }
   }
 }

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

@@ -1,37 +1,37 @@
-function getRedisService (config, connectionName) {
-  if (config.splitByInstance && connectionName) {
-    return config.service
-      ? `${config.service}-${connectionName}`
+function getRedisService (pluginConfig, connectionName) {
+  if (pluginConfig.splitByInstance && connectionName) {
+    return pluginConfig.service
+      ? `${pluginConfig.service}-${connectionName}`
       : connectionName
   }
 
-  return config.service
+  return pluginConfig.service
 }
 
-function fromSystem (service, system) {
-  return system ? `${service}-${system}` : undefined
+function fromSystem (tracerService, system) {
+  return system ? `${tracerService}-${system}` : undefined
 }
 
-function mysqlServiceName (service, config, dbConfig, system) {
-  if (typeof config.service === 'function') {
-    return config.service(dbConfig)
+function mysqlServiceName ({ tracerService, pluginConfig, dbConfig, system }) {
+  if (typeof pluginConfig.service === 'function') {
+    return pluginConfig.service(dbConfig)
   }
-  return config.service || fromSystem(service, system)
+  return pluginConfig.service || fromSystem(tracerService, system)
 }
 
 function withSuffixFunction (suffix) {
-  return (service, config, params) => {
-    if (typeof config.service === 'function') {
-      return config.service(params)
+  return ({ tracerService, pluginConfig, params }) => {
+    if (typeof pluginConfig.service === 'function') {
+      return pluginConfig.service(params)
     }
-    return config.service || `${service}-${suffix}`
+    return pluginConfig.service || `${tracerService}-${suffix}`
   }
 }
 
 const redisConfig = {
   opName: () => 'redis.command',
-  serviceName: (service, config, system, connectionName) => {
-    return getRedisService(config, connectionName) || fromSystem(service, system)
+  serviceName: ({ tracerService, pluginConfig, system, connectionName }) => {
+    return getRedisService(pluginConfig, connectionName) || fromSystem(tracerService, system)
   }
 }
 
@@ -39,11 +39,17 @@ const storage = {
   client: {
     'cassandra-driver': {
       opName: () => 'cassandra.query',
-      serviceName: (service, config, system) => config.service || fromSystem(service, system)
+      serviceName: ({ tracerService, pluginConfig, system }) =>
+        pluginConfig.service || fromSystem(tracerService, system)
+    },
+    couchbase: {
+      opName: ({ operation }) => `couchbase.${operation}`,
+      serviceName: ({ tracerService, pluginConfig }) => pluginConfig.service || `${tracerService}-couchbase`
     },
     elasticsearch: {
       opName: () => 'elasticsearch.query',
-      serviceName: (service, config) => config.service || `${service}-elasticsearch`
+      serviceName: ({ tracerService, pluginConfig }) =>
+        pluginConfig.service || `${tracerService}-elasticsearch`
     },
     ioredis: redisConfig,
     mariadb: {
@@ -52,11 +58,13 @@ const storage = {
     },
     memcached: {
       opName: () => 'memcached.command',
-      serviceName: (service, config, system) => config.service || fromSystem(service, system)
+      serviceName: ({ tracerService, pluginConfig, system }) =>
+        pluginConfig.service || fromSystem(tracerService, system)
     },
     'mongodb-core': {
       opName: () => 'mongodb.query',
-      serviceName: (service, config) => config.service || `${service}-mongodb`
+      serviceName: ({ tracerService, pluginConfig }) =>
+        pluginConfig.service || `${tracerService}-mongodb`
     },
     mysql: {
       opName: () => 'mysql.query',
@@ -68,7 +76,8 @@ const storage = {
     },
     opensearch: {
       opName: () => 'opensearch.query',
-      serviceName: (service, config) => config.service || `${service}-opensearch`
+      serviceName: ({ tracerService, pluginConfig }) =>
+        pluginConfig.service || `${tracerService}-opensearch`
     },
     oracledb: {
       opName: () => 'oracle.query',
@@ -81,7 +90,8 @@ const storage = {
     redis: redisConfig,
     tedious: {
       opName: () => 'tedious.request',
-      serviceName: (service, config, system) => config.service || fromSystem(service, system)
+      serviceName: ({ tracerService, pluginConfig, system }) =>
+        pluginConfig.service || fromSystem(tracerService, system)
     }
   }
 }

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

@@ -1,4 +1,4 @@
-const { identityService } = require('../util')
+const { identityService, httpPluginClientService, awsServiceV0 } = require('../util')
 const { DD_MAJOR } = require('../../../../../../version')
 
 const web = {
@@ -10,6 +10,26 @@ const web = {
     moleculer: {
       opName: () => 'moleculer.call',
       serviceName: identityService
+    },
+    http: {
+      opName: () => 'http.request',
+      serviceName: httpPluginClientService
+    },
+    fetch: {
+      opName: () => 'http.request',
+      serviceName: httpPluginClientService
+    },
+    http2: {
+      opName: () => 'http.request',
+      serviceName: httpPluginClientService
+    },
+    aws: {
+      opName: () => 'aws.request',
+      serviceName: awsServiceV0
+    },
+    lambda: {
+      opName: () => 'aws.request',
+      serviceName: awsServiceV0
     }
   },
   server: {
@@ -20,6 +40,18 @@ const web = {
     moleculer: {
       opName: () => 'moleculer.action',
       serviceName: identityService
+    },
+    http: {
+      opName: () => 'web.request',
+      serviceName: identityService
+    },
+    http2: {
+      opName: () => 'web.request',
+      serviceName: identityService
+    },
+    next: {
+      opName: () => 'next.request',
+      serviceName: identityService
     }
   }
 }

package/packages/dd-trace/src/service-naming/schemas/v1/messaging.js

@@ -22,7 +22,15 @@ const messaging = {
       opName: () => 'kafka.send',
       serviceName: identityService
     },
-    rhea: amqpOutbound
+    rhea: amqpOutbound,
+    sqs: {
+      opName: () => 'aws.sqs.send',
+      serviceName: identityService
+    },
+    sns: {
+      opName: () => 'aws.sns.send',
+      serviceName: identityService
+    }
   },
   consumer: {
     amqplib: amqpInbound,
@@ -35,7 +43,11 @@ const messaging = {
       opName: () => 'kafka.process',
       serviceName: identityService
     },
-    rhea: amqpInbound
+    rhea: amqpInbound,
+    sqs: {
+      opName: () => 'aws.sqs.process',
+      serviceName: identityService
+    }
   },
   client: {
     amqplib: {

package/packages/dd-trace/src/service-naming/schemas/v1/storage.js

@@ -1,7 +1,6 @@
-const { identityService } = require('../util')
 
-function configWithFallback (service, config) {
-  return config.service || service
+function configWithFallback ({ tracerService, pluginConfig }) {
+  return pluginConfig.service || tracerService
 }
 
 const redisNaming = {
@@ -11,14 +10,14 @@ const redisNaming = {
 
 const mySQLNaming = {
   opName: () => 'mysql.query',
-  serviceName: identityService
+  serviceName: withFunction
 }
 
-function withFunction (service, config, params) {
-  if (typeof config.service === 'function') {
-    return config.service(params)
+function withFunction ({ tracerService, pluginConfig, params }) {
+  if (typeof pluginConfig.service === 'function') {
+    return pluginConfig.service(params)
   }
-  return configWithFallback(service, config)
+  return configWithFallback({ tracerService, pluginConfig })
 }
 
 const storage = {
@@ -27,6 +26,10 @@ const storage = {
       opName: () => 'cassandra.query',
       serviceName: configWithFallback
     },
+    couchbase: {
+      opName: () => 'couchbase.query',
+      serviceName: configWithFallback
+    },
     elasticsearch: {
       opName: () => 'elasticsearch.query',
       serviceName: configWithFallback
@@ -34,7 +37,7 @@ const storage = {
     ioredis: redisNaming,
     mariadb: {
       opName: () => 'mariadb.query',
-      serviceName: identityService
+      serviceName: withFunction
     },
     memcached: {
       opName: () => 'memcached.command',

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

@@ -1,4 +1,4 @@
-const { identityService } = require('../util')
+const { identityService, httpPluginClientService } = require('../util')
 
 const web = {
   client: {
@@ -9,6 +9,26 @@ const web = {
     moleculer: {
       opName: () => 'moleculer.client.request',
       serviceName: identityService
+    },
+    http: {
+      opName: () => 'http.client.request',
+      serviceName: httpPluginClientService
+    },
+    fetch: {
+      opName: () => 'http.client.request',
+      serviceName: httpPluginClientService
+    },
+    http2: {
+      opName: () => 'http.client.request',
+      serviceName: httpPluginClientService
+    },
+    aws: {
+      opName: ({ awsService }) => `aws.${awsService}.request`,
+      serviceName: identityService
+    },
+    lambda: {
+      opName: () => 'aws.lambda.invoke',
+      serviceName: identityService
     }
   },
   server: {
@@ -19,6 +39,18 @@ const web = {
     moleculer: {
       opName: () => 'moleculer.server.request',
       serviceName: identityService
+    },
+    http: {
+      opName: () => 'http.server.request',
+      serviceName: identityService
+    },
+    http2: {
+      opName: () => 'http.server.request',
+      serviceName: identityService
+    },
+    next: {
+      opName: () => 'http.server.request',
+      serviceName: identityService
     }
   }
 }

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

@@ -1,53 +0,0 @@
-'use strict'
-
-// TODO: Figure out why we can't use the internal version.
-// eslint-disable-next-line n/no-restricted-require
-const dc = require('diagnostics_channel')
-
-const CHANNEL_PREFIX = 'dd-trace:bundledModuleLoadStart'
-
-if (!dc.subscribe) {
-  dc.subscribe = (channel, cb) => {
-    dc.channel(channel).subscribe(cb)
-  }
-}
-if (!dc.unsubscribe) {
-  dc.unsubscribe = (channel, cb) => {
-    if (dc.channel(channel).hasSubscribers) {
-      dc.channel(channel).unsubscribe(cb)
-    }
-  }
-}
-
-module.exports = DcitmHook
-
-/**
- * This allows for listening to diagnostic channel events when a module is loaded.
- * Currently it's intended use is for situations like when code runs through a bundler.
- *
- * Unlike RITM and IITM, which have files available on a filesystem at runtime, DCITM
- * requires access to a package's version ahead of time as the package.json file likely
- * won't be available.
- *
- * This function runs many times at startup, once for every module that dd-trace may trace.
- * As it runs on a per-module basis we're creating per-module channels.
- */
-function DcitmHook (moduleNames, options, onrequire) {
-  if (!(this instanceof DcitmHook)) return new DcitmHook(moduleNames, options, onrequire)
-
-  function onModuleLoad (payload) {
-    payload.module = onrequire(payload.module, payload.path, undefined, payload.version)
-  }
-
-  for (const moduleName of moduleNames) {
-    // dc.channel(`${CHANNEL_PREFIX}:${moduleName}`).subscribe(onModuleLoad)
-    dc.subscribe(`${CHANNEL_PREFIX}:${moduleName}`, onModuleLoad)
-  }
-
-  this.unhook = function dcitmUnload () {
-    for (const moduleName of moduleNames) {
-      // dc.channel(`${CHANNEL_PREFIX}:${moduleName}`).unsubscribe(onModuleLoad)
-      dc.unsubscribe(`${CHANNEL_PREFIX}:${moduleName}`, onModuleLoad)
-    }
-  }
-}