dd-trace 2.4.2 → 2.7.0

package/packages/dd-trace/src/profiling/profilers/{heap.js → space.js}

@@ -1,6 +1,6 @@
 'use strict'
 
-class NativeHeapProfiler {
+class NativeSpaceProfiler {
   constructor (options = {}) {
     this.type = 'space'
     this._samplingInterval = options.samplingInterval || 512 * 1024
@@ -27,4 +27,4 @@ class NativeHeapProfiler {
   }
 }
 
-module.exports = NativeHeapProfiler
+module.exports = NativeSpaceProfiler

package/packages/dd-trace/src/profiling/profilers/{cpu.js → wall.js}

@@ -1,9 +1,9 @@
 'use strict'
 
-class NativeCpuProfiler {
+class NativeWallProfiler {
   constructor (options = {}) {
     this.type = 'wall'
-    this._samplingInterval = options.samplingInterval || 10 * 1000
+    this._samplingInterval = options.samplingInterval || 1e6 / 99 // 99hz
     this._mapper = undefined
     this._pprof = undefined
   }
@@ -43,4 +43,4 @@ class NativeCpuProfiler {
   }
 }
 
-module.exports = NativeCpuProfiler
+module.exports = NativeWallProfiler

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

@@ -10,6 +10,7 @@ const metrics = require('./metrics')
 const log = require('./log')
 const { isFalse } = require('./util')
 const { setStartupLogInstrumenter } = require('./startup-log')
+const telemetry = require('./telemetry')
 
 const noop = new NoopTracer()
 
@@ -63,6 +64,7 @@ class Tracer extends BaseTracer {
         this._instrumenter.enable(config)
         this._pluginManager.configure(config)
         setStartupLogInstrumenter(this._instrumenter)
+        telemetry.start(config, this._instrumenter, this._pluginManager)
       }
     } catch (e) {
       log.error(e)

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

@@ -32,7 +32,10 @@ class SpanProcessor {
         }
       }
 
-      this._exporter.export(formatted)
+      if (formatted.length !== 0 && trace.isRecording !== false) {
+        this._exporter.export(formatted)
+      }
+
       this._erase(trace, active)
     }
   }

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

@@ -0,0 +1,187 @@
+'use strict'
+
+const tracerVersion = require('../lib/version')
+const pkg = require('./pkg')
+const containerId = require('./exporters/common/docker').id()
+const requirePackageJson = require('./require-package-json')
+const path = require('path')
+const os = require('os')
+const request = require('./exporters/common/request')
+
+let config
+let instrumenter
+let pluginManager
+
+let seqId = 0
+let application
+let host
+let interval
+const sentIntegrations = new Set()
+
+function getIntegrations () {
+  const newIntegrations = []
+  for (const plugin of instrumenter._instrumented.keys()) {
+    if (sentIntegrations.has(plugin.name)) {
+      continue
+    }
+    newIntegrations.push({
+      name: plugin.name,
+      enabled: true,
+      auto_enabled: true
+    })
+    sentIntegrations.add(plugin.name)
+  }
+  for (const pluginName in pluginManager._pluginsByName) {
+    if (sentIntegrations.has(pluginName)) {
+      continue
+    }
+    newIntegrations.push({
+      name: pluginName,
+      enabled: pluginManager._pluginsByName[pluginName]._enabled,
+      auto_enabled: true
+    })
+    sentIntegrations.add(pluginName)
+  }
+  return newIntegrations
+}
+
+function getDependencies () {
+  const deps = []
+  const { dependencies } = pkg
+  if (!dependencies) {
+    return deps
+  }
+  const rootDir = pkg.findRoot()
+  for (const [name, version] of Object.entries(dependencies)) {
+    const dep = { name }
+    try {
+      dep.version = requirePackageJson(
+        path.join(rootDir, 'node_modules', name.replace('/', path.sep))
+      ).version
+    } catch (e) {
+      dep.version = version
+    }
+    deps.push(dep)
+  }
+  return deps
+}
+
+function flatten (input, result = [], prefix = [], traversedObjects = null) {
+  traversedObjects = traversedObjects || new WeakSet()
+  if (traversedObjects.has(input)) {
+    return
+  }
+  traversedObjects.add(input)
+  for (const [key, value] of Object.entries(input)) {
+    if (typeof value === 'object' && value !== null) {
+      flatten(value, result, [...prefix, key], traversedObjects)
+    } else {
+      result.push({ name: [...prefix, key].join('.'), value })
+    }
+  }
+  return result
+}
+
+function appStarted () {
+  return {
+    integrations: getIntegrations(),
+    dependencies: getDependencies(),
+    configuration: flatten(config),
+    additional_payload: []
+  }
+}
+
+function onBeforeExit () {
+  process.removeListener('beforeExit', onBeforeExit)
+  sendData('app-closing')
+}
+
+function createAppObject () {
+  return {
+    service_name: config.service,
+    env: config.env,
+    service_version: config.version,
+    tracer_version: tracerVersion,
+    language_name: 'nodejs',
+    language_version: process.versions.node
+  }
+}
+
+function createHostObject () {
+  return {
+    hostname: os.hostname(), // TODO is this enough?
+    container_id: containerId
+  }
+}
+
+function sendData (reqType, payload = {}) {
+  const {
+    hostname,
+    port
+  } = config
+  const options = {
+    hostname,
+    port,
+    method: 'POST',
+    path: '/telemetry/proxy/api/v2/apmtelemetry',
+    headers: {
+      'content-type': 'application/json',
+      'dd-telemetry-api-version': 'v1',
+      'dd-telemetry-request-type': reqType
+    }
+  }
+  const data = JSON.stringify({
+    api_version: 'v1',
+    request_type: reqType,
+    tracer_time: Math.floor(Date.now() / 1000),
+    runtime_id: config.tags['runtime-id'],
+    seq_id: ++seqId,
+    payload,
+    application,
+    host
+  })
+
+  request(data, options, true, () => {
+    // ignore errors
+  })
+}
+
+function start (aConfig, theInstrumenter, thePluginManager) {
+  if (!aConfig.telemetryEnabled) {
+    return
+  }
+  config = aConfig
+  instrumenter = theInstrumenter
+  pluginManager = thePluginManager
+  application = createAppObject()
+  host = createHostObject()
+  sendData('app-started', appStarted())
+  interval = setInterval(() => sendData('app-heartbeat'), 60000)
+  interval.unref()
+  process.on('beforeExit', onBeforeExit)
+}
+
+function stop () {
+  if (!config) {
+    return
+  }
+  clearInterval(interval)
+  process.removeListener('beforeExit', onBeforeExit)
+}
+
+function updateIntegrations () {
+  if (!config || !config.telemetryEnabled) {
+    return
+  }
+  const integrations = getIntegrations()
+  if (integrations.length === 0) {
+    return
+  }
+  sendData('app-integrations-change', { integrations })
+}
+
+module.exports = {
+  start,
+  stop,
+  updateIntegrations
+}

package/scripts/install_plugin_modules.js

@@ -186,6 +186,7 @@ const requirePackageJson = require('${requirePackageJsonPath}')
 
 module.exports = {
   get (id) { return require(id || '${name}') },
+  getPath (id) { return require.resolve(id || '${name}' ) },
   version () { return requirePackageJson('${name}', module).version }
 }
 `

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

@@ -1,198 +0,0 @@
-'use strict'
-
-const methods = require('methods').concat('all')
-const web = require('../../dd-trace/src/plugins/util/web')
-
-function createWrapFastify (tracer, config) {
-  config = web.normalizeConfig(config)
-
-  return function wrapFastify (fastify) {
-    if (typeof fastify !== 'function') return fastify
-
-    return function fastifyWithTrace () {
-      const app = fastify.apply(this, arguments)
-
-      if (!app) return app
-
-      if (typeof app.addHook === 'function') {
-        app.addHook('onRequest', createOnRequest(tracer, config))
-        app.addHook('preHandler', preHandler)
-        app.addHook = createWrapAddHook(tracer, config)(app.addHook)
-      }
-
-      methods.forEach(method => {
-        app[method] = wrapMethod(app[method])
-      })
-
-      app.route = wrapRoute(app.route)
-
-      return app
-    }
-  }
-}
-
-function createWrapAddHook (tracer, config) {
-  return function wrapAddHook (addHook) {
-    return function addHookWithTrace (name, fn) {
-      fn = arguments[arguments.length - 1]
-
-      if (typeof fn !== 'function') return addHook.apply(this, arguments)
-
-      arguments[arguments.length - 1] = safeWrap(fn, function (request, reply, done) {
-        const req = getReq(request)
-
-        if (!req) return fn.apply(this, arguments)
-
-        done = arguments[arguments.length - 1]
-
-        try {
-          if (typeof done === 'function') {
-            arguments[arguments.length - 1] = function (err) {
-              web.addError(req, err)
-              return done.apply(this, arguments)
-            }
-
-            return fn.apply(this, arguments)
-          } else {
-            const promise = fn.apply(this, arguments)
-
-            if (promise && typeof promise.catch === 'function') {
-              return promise.catch(err => {
-                web.addError(req, err)
-                throw err
-              })
-            }
-
-            return promise
-          }
-        } catch (e) {
-          web.addError(req, e)
-          throw e
-        }
-      })
-
-      return addHook.apply(this, arguments)
-    }
-  }
-}
-
-function createOnRequest (tracer, config) {
-  return function onRequest (request, reply, next) {
-    if (typeof next !== 'function') return
-
-    const req = getReq(request)
-    const res = getRes(reply)
-    const name = 'fastify.request'
-
-    return web.instrument(tracer, config, req, res, name, () => next())
-  }
-}
-
-function preHandler (request, reply, next) {
-  if (typeof next !== 'function') return
-  if (!reply || typeof reply.send !== 'function') return next()
-
-  reply.send = wrapSend(reply.send)
-
-  next()
-}
-
-function wrapSend (send) {
-  return function sendWithTrace (payload) {
-    const req = getReq(this && this.request)
-
-    web.addError(req, payload)
-
-    return send.apply(this, arguments)
-  }
-}
-
-function wrapRoute (route) {
-  if (typeof route !== 'function') return route
-
-  return function routeWithTrace (opts) {
-    opts.handler = wrapHandler(opts.handler)
-
-    return route.apply(this, arguments)
-  }
-}
-
-function wrapMethod (method) {
-  if (typeof method !== 'function') return method
-
-  return function methodWithTrace (url, opts, handler) {
-    const lastIndex = arguments.length - 1
-
-    handler = arguments[lastIndex]
-
-    if (typeof handler === 'function') {
-      arguments[lastIndex] = wrapHandler(handler)
-    } else if (handler) {
-      arguments[lastIndex].handler = wrapHandler(handler.handler)
-    }
-
-    return method.apply(this, arguments)
-  }
-}
-
-function wrapHandler (handler) {
-  if (!handler || typeof handler !== 'function' || handler.name === 'handlerWithTrace') {
-    return handler
-  }
-
-  return function handlerWithTrace (request, reply) {
-    const req = getReq(request)
-
-    return web.reactivate(req, () => handler.apply(this, arguments))
-  }
-}
-
-// TODO: move this to a common util
-function safeWrap (fn, wrapper) {
-  Object.defineProperty(wrapper, 'length', Object.getOwnPropertyDescriptor(fn, 'length'))
-
-  return wrapper
-}
-
-function getReq (request) {
-  return request && (request.raw || request.req || request)
-}
-
-function getRes (reply) {
-  return reply && (reply.raw || reply.res || reply)
-}
-
-module.exports = [
-  {
-    name: 'fastify',
-    versions: ['>=3'],
-    patch (fastify, tracer, config) {
-      // `fastify` is a function so we return a wrapper that will replace its export.
-      const wrapped = this.wrapExport(fastify, createWrapFastify(tracer, config)(fastify))
-
-      wrapped.fastify = wrapped
-      wrapped.default = wrapped
-
-      return wrapped
-    },
-    unpatch (fastify) {
-      const unwrapped = this.unwrapExport(fastify)
-
-      unwrapped.fastify = unwrapped
-      unwrapped.default = unwrapped
-
-      return unwrapped
-    }
-  },
-  {
-    name: 'fastify',
-    versions: ['1 - 2'],
-    patch (fastify, tracer, config) {
-      // `fastify` is a function so we return a wrapper that will replace its export.
-      return this.wrapExport(fastify, createWrapFastify(tracer, config)(fastify))
-    },
-    unpatch (fastify) {
-      this.unwrapExport(fastify)
-    }
-  }
-]

package/packages/datadog-plugin-fastify/src/find-my-way.js

@@ -1,37 +0,0 @@
-'use strict'
-
-const web = require('../../dd-trace/src/plugins/util/web')
-
-function createWrapOn () {
-  return function wrapOn (on) {
-    return function onWithTrace (method, path, opts) {
-      const index = typeof opts === 'function' ? 2 : 3
-      const handler = arguments[index]
-      const wrapper = function (req) {
-        web.patch(req)
-        web.enterRoute(req, path)
-
-        return handler.apply(this, arguments)
-      }
-
-      if (typeof handler === 'function') {
-        arguments[index] = wrapper
-      }
-
-      return on.apply(this, arguments)
-    }
-  }
-}
-
-module.exports = [
-  {
-    name: 'find-my-way',
-    versions: ['>=1'],
-    patch (Router, tracer, config) {
-      this.wrap(Router.prototype, 'on', createWrapOn(tracer, config))
-    },
-    unpatch (Router) {
-      this.unwrap(Router.prototype, 'on')
-    }
-  }
-]