dd-trace 2.30.1 → 2.32.0

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

@@ -1,203 +0,0 @@
-'use strict'
-
-const shimmer = require('../../datadog-shimmer')
-const log = require('./log')
-const metrics = require('./metrics')
-const Loader = require('./loader')
-const { isTrue } = require('./util')
-const plugins = require('./plugins')
-const Plugin = require('./plugins/plugin')
-const telemetry = require('./telemetry')
-
-const disabledPlugins = process.env.DD_TRACE_DISABLED_PLUGINS
-
-const collectDisabledPlugins = () => {
-  return new Set(disabledPlugins && disabledPlugins.split(',').map(plugin => plugin.trim()))
-}
-
-function cleanEnv (name) {
-  return process.env[`DD_TRACE_${name.toUpperCase()}`.replace(/[^a-z0-9_]/ig, '_')]
-}
-
-function getConfig (name, config = {}) {
-  if (!name) {
-    return config
-  }
-
-  const enabled = cleanEnv(`${name}_ENABLED`)
-  if (enabled !== undefined) {
-    config.enabled = isTrue(enabled)
-  }
-
-  return config
-}
-
-class Instrumenter {
-  constructor (tracer) {
-    this._tracer = tracer
-    this._loader = new Loader(this)
-    this._enabled = false
-    this._names = new Set()
-    this._plugins = new Map()
-    this._instrumented = new Map()
-    this._disabledPlugins = collectDisabledPlugins()
-  }
-
-  use (name, config) {
-    if (typeof name !== 'string') return
-    const plugin = plugins[name.toLowerCase()]
-    if (plugin && plugin.prototype instanceof Plugin) return
-    if (typeof config === 'boolean') {
-      config = { enabled: config }
-    }
-
-    config = getConfig(name, config)
-
-    try {
-      this._set(plugin, { name, config })
-      telemetry.updateIntegrations()
-    } catch (e) {
-      log.debug(`Could not find a plugin named "${name}".`)
-    }
-
-    if (this._enabled) {
-      this._loader.reload(this._plugins)
-    }
-  }
-
-  enable (config) {
-    config = config || {}
-    const serviceMapping = config.serviceMapping
-
-    this._enabled = true
-
-    if (config.plugins !== false) {
-      Object.keys(plugins)
-        .filter(name => !this._plugins.has(plugins[name]))
-        .forEach(name => {
-          if (plugins[name].prototype instanceof Plugin) return
-          const pluginConfig = {}
-          if (serviceMapping && serviceMapping[name]) {
-            pluginConfig.service = serviceMapping[name]
-          }
-          this._set(plugins[name], { name, config: getConfig(name, pluginConfig) })
-        })
-    }
-
-    this._loader.reload(this._plugins)
-  }
-
-  disable () {
-    for (const instrumentation of this._instrumented.keys()) {
-      this.unpatch(instrumentation)
-    }
-
-    this._plugins.clear()
-    this._enabled = false
-    this._loader.reload(this._plugins)
-  }
-
-  wrap (nodules, names, wrapper) {
-    shimmer.massWrap(nodules, names, wrapper)
-  }
-
-  unwrap (nodules, names, wrapper) {
-    shimmer.massUnwrap(nodules, names, wrapper)
-  }
-
-  wrapExport (moduleExports, wrapper) {
-    return shimmer.wrap(moduleExports, wrapper)
-  }
-
-  unwrapExport (moduleExports) {
-    return shimmer.unwrap(moduleExports)
-  }
-
-  load (plugin, meta) {
-    if (!this._enabled) return
-
-    const instrumentations = [].concat(plugin)
-    const enabled = meta.config.enabled !== false
-
-    metrics.boolean(`datadog.tracer.node.plugin.enabled.by.name`, enabled, `name:${meta.name}`)
-
-    try {
-      instrumentations
-        .forEach(instrumentation => {
-          this._loader.load(instrumentation, meta.config)
-        })
-    } catch (e) {
-      log.error(e)
-      this.unload(plugin)
-      log.debug(`Error while trying to patch ${meta.name}. The plugin has been disabled.`)
-
-      metrics.increment(`datadog.tracer.node.plugin.errors`, true)
-    }
-  }
-
-  unload (plugin) {
-    [].concat(plugin)
-      .forEach(instrumentation => {
-        this.unpatch(instrumentation)
-        this._instrumented.delete(instrumentation)
-      })
-
-    const meta = this._plugins.get(plugin)
-
-    if (meta) {
-      this._plugins.delete(plugin)
-
-      metrics.boolean(`datadog.tracer.node.plugin.enabled.by.name`, false, `name:${meta.name}`)
-    }
-  }
-
-  patch (instrumentation, moduleExports, config) {
-    let instrumented = this._instrumented.get(instrumentation)
-
-    if (!instrumented) {
-      this._instrumented.set(instrumentation, instrumented = new Set())
-      telemetry.updateIntegrations()
-    }
-
-    if (!instrumented.has(this._defaultExport(moduleExports))) {
-      try {
-        moduleExports = instrumentation.patch.call(this, moduleExports, this._tracer._tracer, config) || moduleExports
-        return moduleExports
-      } finally {
-        // add even on error since `unpatch` will take care of removing it.
-        instrumented.add(this._defaultExport(moduleExports))
-      }
-    }
-  }
-
-  unpatch (instrumentation) {
-    const instrumented = this._instrumented.get(instrumentation)
-
-    if (instrumented) {
-      instrumented.forEach(moduleExports => {
-        try {
-          instrumentation.unpatch.call(this, moduleExports, this._tracer)
-        } catch (e) {
-          log.error(e)
-        }
-      })
-    }
-  }
-
-  _set (plugin, meta) {
-    if (this._disabledPlugins.has(meta.name)) {
-      log.debug(`Plugin "${meta.name}" was disabled via configuration option.`)
-    } else {
-      this._plugins.set(plugin, meta)
-      this.load(plugin, meta)
-    }
-  }
-
-  // ESM modules have a different export between `import` and `require` so we
-  // use the default export instead when available.
-  _defaultExport (moduleExports) {
-    return moduleExports && (moduleExports.default || moduleExports)
-  }
-}
-
-module.exports = Instrumenter

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

@@ -1,131 +0,0 @@
-'use strict'
-
-const semver = require('semver')
-const Hook = require('../../datadog-instrumentations/src/helpers/hook')
-const parse = require('module-details-from-path')
-const path = require('path')
-const uniq = require('lodash.uniq')
-const log = require('./log')
-const requirePackageJson = require('./require-package-json')
-
-const pathSepExpr = new RegExp(`\\${path.sep}`, 'g')
-
-class Loader {
-  constructor (instrumenter) {
-    this._instrumenter = instrumenter
-  }
-
-  reload (plugins) {
-    this._plugins = plugins
-    this._patched = []
-
-    const instrumentations = Array.from(this._plugins.keys())
-      .reduce((prev, current) => prev.concat(current), [])
-
-    const instrumentedModules = uniq(instrumentations
-      .map(instrumentation => instrumentation.name))
-
-    this._names = new Set(instrumentations
-      .map(instrumentation => filename(instrumentation)))
-
-    this._hook && this._hook.unhook()
-    this._hook = Hook(instrumentedModules, (moduleExports, moduleName, moduleBaseDir) => {
-      return this._hookModule(moduleExports, moduleName, moduleBaseDir)
-    })
-  }
-
-  load (instrumentation, config) {
-    this._getModules(instrumentation).forEach(nodule => {
-      this._instrumenter.patch(instrumentation, nodule, config)
-    })
-  }
-
-  _getModules (instrumentation) {
-    const modules = []
-    const ids = Object.keys(require.cache)
-
-    let pkg
-
-    for (let i = 0, l = ids.length; i < l; i++) {
-      const id = ids[i].replace(pathSepExpr, '/')
-
-      if (!id.includes(`/node_modules/${instrumentation.name}/`)) continue
-
-      if (instrumentation.file) {
-        if (!id.endsWith(`/node_modules/${filename(instrumentation)}`)) continue
-
-        const basedir = getBasedir(ids[i])
-
-        pkg = requirePackageJson(basedir, module)
-      } else {
-        const basedir = getBasedir(ids[i])
-
-        pkg = requirePackageJson(basedir, module)
-
-        const mainFile = path.posix.normalize(pkg.main || 'index.js')
-        if (!id.endsWith(`/node_modules/${instrumentation.name}/${mainFile}`)) continue
-      }
-
-      if (!matchVersion(pkg.version, instrumentation.versions)) continue
-
-      modules.push(require.cache[ids[i]].exports)
-    }
-
-    return modules
-  }
-
-  _hookModule (moduleExports, moduleName, moduleBaseDir) {
-    moduleName = moduleName.replace(pathSepExpr, '/')
-
-    if (!this._names.has(moduleName)) {
-      return moduleExports
-    }
-
-    if (moduleBaseDir) {
-      moduleBaseDir = moduleBaseDir.replace(pathSepExpr, '/')
-    }
-
-    const moduleVersion = getVersion(moduleBaseDir)
-
-    for (const [plugin, meta] of this._plugins) {
-      if (meta.config.enabled === false) {
-        continue
-      }
-      try {
-        for (const instrumentation of [].concat(plugin)) {
-          if (moduleName !== filename(instrumentation) || !matchVersion(moduleVersion, instrumentation.versions)) {
-            continue
-          }
-
-          moduleExports = this._instrumenter.patch(instrumentation, moduleExports, meta.config) || moduleExports
-        }
-      } catch (e) {
-        log.error(e)
-        this._instrumenter.unload(plugin)
-        log.debug(`Error while trying to patch ${meta.name}. The plugin has been disabled.`)
-      }
-    }
-
-    return moduleExports
-  }
-}
-
-function getBasedir (id) {
-  return parse(id).basedir.replace(pathSepExpr, '/')
-}
-
-function matchVersion (version, ranges) {
-  return !version || (ranges && ranges.some(range => semver.satisfies(semver.coerce(version), range)))
-}
-
-function getVersion (moduleBaseDir) {
-  if (moduleBaseDir) {
-    return requirePackageJson(moduleBaseDir, module).version
-  }
-}
-
-function filename (plugin) {
-  return [plugin.name, plugin.file].filter(val => val).join('/')
-}
-
-module.exports = Loader

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

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