dd-trace 3.3.1 → 3.12.1

package/packages/dd-trace/src/lambda/runtime/ritm.js

@@ -0,0 +1,138 @@
+/**
+ * Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Modifications copyright 2022 Datadog, Inc.
+ *
+ * Some functions are part of aws-lambda-nodejs-runtime-interface-client
+ * https://github.com/aws/aws-lambda-nodejs-runtime-interface-client/blob/main/src/utils/UserFunction.ts
+ */
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+
+const log = require('../../log')
+const Hook = require('../../../../datadog-instrumentations/src/helpers/hook')
+const instrumentations = require('../../../../datadog-instrumentations/src/helpers/instrumentations')
+const {
+  filename,
+  pathSepExpr
+} = require('../../../../datadog-instrumentations/src/helpers/register')
+
+/**
+ * Breaks the full handler string into two pieces: the module root
+ * and the actual handler string.
+ *
+ * @param {string} fullHandler user's lambda handler, commonly stored in `DD_LAMBDA_HANDLER`.
+ * @returns {string[]} an array containing the module root and the handler string.
+ *
+ * ```js
+ * _extractModuleRootAndHandler('./api/src/index.nested.handler')
+ * // => ['./api/src', 'index.nested.handler']
+ * ```
+ */
+function _extractModuleRootAndHandler (fullHandler) {
+  const handlerString = path.basename(fullHandler)
+  const moduleRoot = fullHandler.substring(0, fullHandler.indexOf(handlerString))
+
+  return [moduleRoot, handlerString]
+}
+
+/**
+ * Splits the handler string into two pieces: the module name
+ * and the path to the handler function.
+ *
+ * @param {string} handler a handler string containing the module and the handler path.
+ * @returns {string[]} an array containing the module name and the handler path.
+ *
+ * ```js
+ * _extractModuleNameAndHandlerPath('index.nested.handler')
+ * // => ['index', 'nested.handler']
+ * ```
+ */
+function _extractModuleNameAndHandlerPath (handler) {
+  const FUNCTION_EXPR = /^([^.]*)\.(.*)$/
+  const match = handler.match(FUNCTION_EXPR)
+  if (!match || match.length !== 3) {
+    // Malformed Handler Name
+    return // TODO: throw error
+  }
+  return [match[1], match[2]] // [module, handler-path]
+}
+
+/**
+ * Returns the correct path of the file to be patched
+ * when required.
+ *
+ * @param {*} lambdaStylePath the path comprised of the `LAMBDA_TASK_ROOT`,
+ * the root of the module of the Lambda handler, and the module name.
+ * @returns the lambdaStylePath with the appropiate extension for the hook.
+ */
+function _getLambdaFilePath (lambdaStylePath) {
+  let lambdaFilePath = lambdaStylePath
+  if (fs.existsSync(lambdaStylePath + '.js')) {
+    lambdaFilePath += '.js'
+  } else if (fs.existsSync(lambdaStylePath + '.mjs')) {
+    lambdaFilePath += '.mjs'
+  } else if (fs.existsSync(lambdaStylePath + '.cjs')) {
+    lambdaFilePath += '.cjs'
+  }
+  return lambdaFilePath
+}
+
+/**
+ * Register a hook for the Lambda handler to be executed when
+ * the file is required.
+ */
+const registerLambdaHook = () => {
+  const lambdaTaskRoot = process.env.LAMBDA_TASK_ROOT
+  const originalLambdaHandler = process.env.DD_LAMBDA_HANDLER
+
+  if (originalLambdaHandler !== undefined) {
+    const [moduleRoot, moduleAndHandler] = _extractModuleRootAndHandler(originalLambdaHandler)
+    const [_module] = _extractModuleNameAndHandlerPath(moduleAndHandler)
+
+    const lambdaStylePath = path.resolve(lambdaTaskRoot, moduleRoot, _module)
+    const lambdaFilePath = _getLambdaFilePath(lambdaStylePath)
+
+    Hook([lambdaFilePath], (moduleExports) => {
+      require('./patch')
+
+      for (const { hook } of instrumentations[lambdaFilePath]) {
+        try {
+          moduleExports = hook(moduleExports)
+        } catch (e) {
+          log.error(e)
+        }
+      }
+
+      return moduleExports
+    })
+  } else {
+    const moduleToPatch = 'datadog-lambda-js'
+    Hook([moduleToPatch], (moduleExports, moduleName, _) => {
+      moduleName = moduleName.replace(pathSepExpr, '/')
+
+      require('./patch')
+
+      for (const { name, file, hook } of instrumentations[moduleToPatch]) {
+        const fullFilename = filename(name, file)
+        if (moduleName === fullFilename) {
+          try {
+            moduleExports = hook(moduleExports)
+          } catch (e) {
+            log.error(e)
+          }
+        }
+      }
+
+      return moduleExports
+    })
+  }
+}
+
+module.exports = {
+  _extractModuleRootAndHandler,
+  _extractModuleNameAndHandlerPath,
+  _getLambdaFilePath,
+  registerLambdaHook
+}

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

@@ -2,6 +2,7 @@
 
 // TODO: capture every second and flush every 10 seconds
 
+const { URL, format } = require('url')
 const v8 = require('v8')
 const os = require('os')
 const Client = require('./dogstatsd')
@@ -48,11 +49,23 @@ module.exports = {
       nativeMetrics = null
     }
 
-    client = new Client({
+    const clientConfig = {
       host: config.dogstatsd.hostname,
       port: config.dogstatsd.port,
       tags
-    })
+    }
+
+    if (config.url) {
+      clientConfig.metricsProxyUrl = config.url
+    } else if (config.port) {
+      clientConfig.metricsProxyUrl = new URL(format({
+        protocol: 'http:',
+        hostname: config.hostname || 'localhost',
+        port: config.port
+      }))
+    }
+
+    client = new Client(clientConfig)
 
     time = process.hrtime()
 

package/packages/dd-trace/src/opentracing/propagation/text_map.js

@@ -130,11 +130,7 @@ class TextMapPropagator {
 
   _injectTraceparent (spanContext, carrier) {
     if (!this._config.experimental.traceparent) return
-
-    const sampling = spanContext._sampling.priority >= AUTO_KEEP ? '01' : '00'
-    const traceId = spanContext._traceId.toString(16).padStart(32, '0')
-    const spanId = spanContext._spanId.toString(16).padStart(16, '0')
-    carrier[traceparentKey] = `01-${traceId}-${spanId}-${sampling}`
+    carrier[traceparentKey] = spanContext.toTraceparent()
   }
 
   _extractSpanContext (carrier) {

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

@@ -1,7 +1,8 @@
 'use strict'
 
 // TODO (new internal tracer): use DC events for lifecycle metrics and test them
-const now = require('perf_hooks').performance.now
+const { performance } = require('perf_hooks')
+const now = performance.now.bind(performance)
 const dateNow = Date.now
 const semver = require('semver')
 const SpanContext = require('./span_context')

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

@@ -1,5 +1,7 @@
 'use strict'
 
+const { AUTO_KEEP } = require('../../../../ext/priority')
+
 class DatadogSpanContext {
   constructor (props) {
     props = props || {}
@@ -27,6 +29,13 @@ class DatadogSpanContext {
   toSpanId () {
     return this._spanId.toString(10)
   }
+
+  toTraceparent () {
+    const sampling = this._sampling.priority >= AUTO_KEEP ? '01' : '00'
+    const traceId = this._traceId.toString(16).padStart(32, '0')
+    const spanId = this._spanId.toString(16).padStart(16, '0')
+    return `01-${traceId}-${spanId}-${sampling}`
+  }
 }
 
 module.exports = DatadogSpanContext

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

@@ -9,6 +9,10 @@ const loadChannel = channel('dd-trace:instrumentation:load')
 
 // instrument everything that needs Plugin System V2 instrumentation
 require('../../datadog-instrumentations')
+if (process.env.AWS_LAMBDA_FUNCTION_NAME !== undefined) {
+  // instrument lambda environment
+  require('./lambda')
+}
 
 const { DD_TRACE_DISABLED_PLUGINS } = process.env
 
@@ -120,10 +124,9 @@ module.exports = class PluginManager {
       logInjection,
       serviceMapping,
       queryStringObfuscation,
-      clientIpHeaderDisabled,
-      clientIpHeader,
-      isIntelligentTestRunnerEnabled,
-      experimental
+      site,
+      url,
+      dbmPropagationMode
     } = this._tracerConfig
 
     const sharedConfig = {}
@@ -136,24 +139,15 @@ module.exports = class PluginManager {
       sharedConfig.queryStringObfuscation = queryStringObfuscation
     }
 
-    if (clientIpHeaderDisabled !== undefined) {
-      sharedConfig.clientIpHeaderDisabled = clientIpHeaderDisabled
-    }
-
-    if (clientIpHeader !== undefined) {
-      sharedConfig.clientIpHeader = clientIpHeader
-    }
-
-    if (experimental) {
-      sharedConfig.isAgentlessEnabled = experimental.exporter === 'datadog'
-    }
-
-    sharedConfig.isIntelligentTestRunnerEnabled = isIntelligentTestRunnerEnabled
+    sharedConfig.dbmPropagationMode = dbmPropagationMode
 
     if (serviceMapping && serviceMapping[name]) {
       sharedConfig.service = serviceMapping[name]
     }
 
+    sharedConfig.site = site
+    sharedConfig.url = url
+
     return sharedConfig
   }
 }

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

@@ -0,0 +1,9 @@
+'use strict'
+
+const StoragePlugin = require('./storage')
+
+class CachePlugin extends StoragePlugin {
+  static get operation () { return 'command' }
+}
+
+module.exports = CachePlugin

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

@@ -0,0 +1,97 @@
+const {
+  getTestEnvironmentMetadata,
+  getCodeOwnersFileEntries,
+  getTestParentSpan,
+  getTestCommonTags,
+  getCodeOwnersForFilename,
+  TEST_CODE_OWNERS,
+  CI_APP_ORIGIN
+} = require('./util/test')
+const { COMPONENT } = require('../constants')
+
+const Plugin = require('./plugin')
+
+module.exports = class CiPlugin extends Plugin {
+  constructor (...args) {
+    super(...args)
+
+    this.addSub(`ci:${this.constructor.name}:itr-configuration`, ({ onDone }) => {
+      if (!this.tracer._exporter || !this.tracer._exporter.getItrConfiguration) {
+        return onDone({ err: new Error('CI Visibility was not initialized correctly') })
+      }
+      this.tracer._exporter.getItrConfiguration(this.testConfiguration, (err, itrConfig) => {
+        if (!err) {
+          this.itrConfig = itrConfig
+        }
+        onDone({ err, itrConfig })
+      })
+    })
+
+    this.addSub(`ci:${this.constructor.name}:test-suite:skippable`, ({ onDone }) => {
+      if (!this.tracer._exporter || !this.tracer._exporter.getSkippableSuites) {
+        return onDone({ err: new Error('CI Visibility was not initialized correctly') })
+      }
+      this.tracer._exporter.getSkippableSuites(this.testConfiguration, (err, skippableSuites) => {
+        onDone({ err, skippableSuites })
+      })
+    })
+  }
+
+  configure (config) {
+    super.configure(config)
+    this.testEnvironmentMetadata = getTestEnvironmentMetadata(this.constructor.name, this.config)
+    this.codeOwnersEntries = getCodeOwnersFileEntries()
+
+    const {
+      'git.repository_url': repositoryUrl,
+      'git.commit.sha': sha,
+      'os.version': osVersion,
+      'os.platform': osPlatform,
+      'os.architecture': osArchitecture,
+      'runtime.name': runtimeName,
+      'runtime.version': runtimeVersion,
+      'git.branch': branch
+    } = this.testEnvironmentMetadata
+
+    this.testConfiguration = {
+      repositoryUrl,
+      sha,
+      osVersion,
+      osPlatform,
+      osArchitecture,
+      runtimeName,
+      runtimeVersion,
+      branch
+    }
+  }
+
+  startTestSpan (name, suite, extraTags, childOf) {
+    const parent = childOf || getTestParentSpan(this.tracer)
+    const testCommonTags = getTestCommonTags(name, suite, this.tracer._version)
+
+    const testTags = {
+      ...testCommonTags,
+      [COMPONENT]: this.constructor.name,
+      ...extraTags
+    }
+
+    const codeOwners = getCodeOwnersForFilename(suite, this.codeOwnersEntries)
+
+    if (codeOwners) {
+      testTags[TEST_CODE_OWNERS] = codeOwners
+    }
+
+    const testSpan = this.tracer
+      .startSpan(`${this.constructor.name}.test`, {
+        childOf: parent,
+        tags: {
+          ...this.testEnvironmentMetadata,
+          ...testTags
+        }
+      })
+
+    testSpan.context()._trace.origin = CI_APP_ORIGIN
+
+    return testSpan
+  }
+}

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

@@ -0,0 +1,9 @@
+'use strict'
+
+const OutgoingPlugin = require('./outgoing')
+
+class ClientPlugin extends OutgoingPlugin {
+  static get operation () { return 'request' }
+}
+
+module.exports = ClientPlugin

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

@@ -0,0 +1,26 @@
+'use strict'
+
+const Plugin = require('./plugin')
+
+class CompositePlugin extends Plugin {
+  constructor (...args) {
+    super(...args)
+
+    for (const [name, PluginClass] of Object.entries(this.constructor.plugins)) {
+      this[name] = new PluginClass(...args)
+    }
+  }
+
+  configure (config) {
+    for (const name in this.constructor.plugins) {
+      const pluginConfig = config[name] === false ? false : {
+        ...config,
+        ...config[name]
+      }
+
+      this[name].configure(pluginConfig)
+    }
+  }
+}
+
+module.exports = CompositePlugin

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

@@ -0,0 +1,9 @@
+'use strict'
+
+const IncomingPlugin = require('./incoming')
+
+class ConsumerPlugin extends IncomingPlugin {
+  static get operation () { return 'receive' }
+}
+
+module.exports = ConsumerPlugin

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

@@ -0,0 +1,55 @@
+'use strict'
+
+const StoragePlugin = require('./storage')
+
+class DatabasePlugin extends StoragePlugin {
+  static get operation () { return 'query' }
+
+  constructor (...args) {
+    super(...args)
+    this.serviceTags = {
+      dddbs: '',
+      encodedDddbs: '',
+      dde: '',
+      encodedDde: '',
+      ddps: '',
+      encodedDdps: '',
+      ddpv: '',
+      encodedDdpv: ''
+    }
+  }
+  encodingServiceTags (serviceTag, encodeATag, spanConfig) {
+    if (serviceTag !== spanConfig) {
+      this.serviceTags[serviceTag] = spanConfig
+      this.serviceTags[encodeATag] = encodeURIComponent(spanConfig)
+    }
+  }
+
+  createDBMPropagationCommentService (serviceName) {
+    this.encodingServiceTags('dddbs', 'encodedDddbs', serviceName)
+    this.encodingServiceTags('dde', 'encodedDde', this.tracer._env)
+    this.encodingServiceTags('ddps', 'encodedDdps', this.tracer._service)
+    this.encodingServiceTags('ddpv', 'encodedDdpv', this.tracer._version)
+
+    const { encodedDddbs, encodedDde, encodedDdps, encodedDdpv } = this.serviceTags
+
+    return `dddbs='${encodedDddbs}',dde='${encodedDde}',` +
+    `ddps='${encodedDdps}',ddpv='${encodedDdpv}'`
+  }
+
+  injectDbmQuery (query, serviceName) {
+    if (this.config.dbmPropagationMode === 'disabled') {
+      return query
+    }
+    const servicePropagation = this.createDBMPropagationCommentService(serviceName)
+    if (this.config.dbmPropagationMode === 'service') {
+      return `/*${servicePropagation}*/ ${query}`
+    } else if (this.config.dbmPropagationMode === 'full') {
+      this.activeSpan.setTag('_dd.dbm_trace_injected', 'true')
+      const traceparent = this.activeSpan._spanContext.toTraceparent()
+      return `/*${servicePropagation},traceparent='${traceparent}'*/ ${query}`
+    }
+  }
+}
+
+module.exports = DatabasePlugin

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

@@ -0,0 +1,7 @@
+'use strict'
+
+const TracingPlugin = require('./tracing')
+
+class IncomingPlugin extends TracingPlugin {}
+
+module.exports = IncomingPlugin

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

@@ -10,6 +10,8 @@ module.exports = {
   get '@jest/core' () { 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') },
+  get '@opensearch-project/opensearch' () { return require('../../../datadog-plugin-opensearch/src') },
+  get '@redis/client' () { return require('../../../datadog-plugin-redis/src') },
   get 'amqp10' () { return require('../../../datadog-plugin-amqp10/src') },
   get 'amqplib' () { return require('../../../datadog-plugin-amqplib/src') },
   get 'aws-sdk' () { return require('../../../datadog-plugin-aws-sdk/src') },
@@ -38,6 +40,7 @@ module.exports = {
   get 'koa' () { return require('../../../datadog-plugin-koa/src') },
   get 'koa-router' () { return require('../../../datadog-plugin-koa/src') },
   get 'kafkajs' () { return require('../../../datadog-plugin-kafkajs/src') },
+  get 'mariadb' () { return require('../../../datadog-plugin-mariadb/src') },
   get 'memcached' () { return require('../../../datadog-plugin-memcached/src') },
   get 'microgateway-core' () { return require('../../../datadog-plugin-microgateway-core/src') },
   get 'mocha' () { return require('../../../datadog-plugin-mocha/src') },

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

@@ -43,8 +43,8 @@ module.exports = class LogPlugin extends Plugin {
       const store = storage.getStore()
       const span = store && store.span
 
-      if (!span) return
-
+      // NOTE: This needs to run whether or not there is a span
+      // so service, version, and env will always get injected.
       const holder = {}
       this.tracer.inject(span, LOG, holder)
       arg.message = messageProxy(arg.message, holder)

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

@@ -0,0 +1,31 @@
+'use strict'
+
+const TracingPlugin = require('./tracing')
+
+// TODO: Exit span on finish when AsyncResource instances are removed.
+class OutgoingPlugin extends TracingPlugin {
+  constructor (...args) {
+    super(...args)
+
+    this.addTraceSub('connect', message => {
+      this.connect(message)
+    })
+  }
+
+  connect (url) {
+    this.addHost(url.hostname, url.port)
+  }
+
+  addHost (hostname, port) {
+    const span = this.activeSpan
+
+    if (!span) return
+
+    span.addTags({
+      'out.host': hostname,
+      'out.port': port
+    })
+  }
+}
+
+module.exports = OutgoingPlugin

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

@@ -1,5 +1,7 @@
 'use strict'
 
+// TODO: move anything related to tracing to TracingPlugin instead
+
 const dc = require('diagnostics_channel')
 const { storage } = require('../../../datadog-core')
 
@@ -39,6 +41,7 @@ module.exports = class Plugin {
     storage.enterWith({ ...store, span })
   }
 
+  // TODO: Implement filters on resource name for all plugins.
   /** Prevents creation of spans here and for all async descendants. */
   skip () {
     storage.enterWith({ noop: true })

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

@@ -0,0 +1,9 @@
+'use strict'
+
+const OutgoingPlugin = require('./outgoing')
+
+class ProducerPlugin extends OutgoingPlugin {
+  static get operation () { return 'publish' }
+}
+
+module.exports = ProducerPlugin

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

@@ -0,0 +1,9 @@
+'use strict'
+
+const IncomingPlugin = require('./incoming')
+
+class ServerPlugin extends IncomingPlugin {
+  static get operation () { return 'request' }
+}
+
+module.exports = ServerPlugin

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

@@ -0,0 +1,21 @@
+'use strict'
+
+const ClientPlugin = require('./client')
+
+class StoragePlugin extends ClientPlugin {
+  constructor (...args) {
+    super(...args)
+
+    this.system = this.constructor.system || this.component
+  }
+
+  startSpan (name, options) {
+    if (!options.service && this.system) {
+      options.service = `${this.tracer._service}-${this.system}`
+    }
+
+    return super.startSpan(name, options)
+  }
+}
+
+module.exports = StoragePlugin