dd-trace 2.4.2 → 2.5.0

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/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/packages/dd-trace/src/exporters/agent/request.js

@@ -1,86 +0,0 @@
-'use strict'
-
-const http = require('http')
-const https = require('https')
-const docker = require('./docker')
-const log = require('../../log')
-const { storage } = require('../../../../datadog-core')
-
-const httpAgent = new http.Agent({ keepAlive: true })
-const httpsAgent = new https.Agent({ keepAlive: true })
-const containerId = docker.id()
-
-function retriableRequest (options, callback, client, data) {
-  const store = storage.getStore()
-
-  storage.enterWith({ noop: true })
-
-  const req = client.request(options, res => {
-    let data = ''
-
-    res.setTimeout(options.timeout)
-
-    res.on('data', chunk => { data += chunk })
-    res.on('end', () => {
-      if (res.statusCode >= 200 && res.statusCode <= 299) {
-        callback(null, data, res.statusCode)
-      } else {
-        const error = new Error(`Error from the agent: ${res.statusCode} ${http.STATUS_CODES[res.statusCode]}`)
-        error.status = res.statusCode
-
-        callback(error, null, res.statusCode)
-      }
-    })
-  })
-  req.setTimeout(options.timeout, req.abort)
-  data.forEach(buffer => req.write(buffer))
-
-  storage.enterWith(store)
-
-  return req
-}
-
-function request (options, callback) {
-  options = Object.assign({
-    headers: {},
-    data: [],
-    timeout: 2000
-  }, options)
-
-  const data = [].concat(options.data)
-  const isSecure = options.protocol === 'https:'
-  const client = isSecure ? https : http
-  const agent = isSecure ? httpsAgent : httpAgent
-
-  options.agent = agent
-  options.headers['Content-Length'] = byteLength(data)
-
-  if (containerId) {
-    options.headers['Datadog-Container-ID'] = containerId
-  }
-  const firstRequest = retriableRequest(options, callback, client, data)
-
-  // The first request will be retried if it fails due to a socket connection close
-  const firstRequestErrorHandler = error => {
-    if (firstRequest.reusedSocket && (error.code === 'ECONNRESET' || error.code === 'EPIPE')) {
-      log.debug('Retrying request due to socket connection error')
-      const retriedReq = retriableRequest(options, callback, client, data)
-      // The retried request will fail normally
-      retriedReq.on('error', e => callback(new Error(`Network error trying to reach the agent: ${e.message}`)))
-      retriedReq.end()
-    } else {
-      callback(new Error(`Network error trying to reach the agent: ${error.message}`))
-    }
-  }
-
-  firstRequest.on('error', firstRequestErrorHandler)
-  firstRequest.end()
-
-  return firstRequest
-}
-
-function byteLength (data) {
-  return data.length > 0 ? data.reduce((prev, next) => prev + next.length, 0) : 0
-}
-
-module.exports = request