dd-trace 5.17.0 → 5.19.0

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

@@ -0,0 +1,75 @@
+'use strict'
+
+const fs = require('fs')
+const { spawn } = require('child_process')
+const tracerVersion = require('../../../../package.json').version
+const log = require('../log')
+
+module.exports = sendTelemetry
+
+if (!process.env.DD_INJECTION_ENABLED) {
+  module.exports = () => {}
+}
+
+if (!process.env.DD_TELEMETRY_FORWARDER_PATH) {
+  module.exports = () => {}
+}
+
+if (!fs.existsSync(process.env.DD_TELEMETRY_FORWARDER_PATH)) {
+  module.exports = () => {}
+}
+
+const metadata = {
+  language_name: 'nodejs',
+  language_version: process.versions.node,
+  runtime_name: 'nodejs',
+  runtime_version: process.versions.node,
+  tracer_version: tracerVersion,
+  pid: process.pid
+}
+
+const seen = []
+function hasSeen (point) {
+  if (point.name === 'abort') {
+    // This one can only be sent once, regardless of tags
+    return seen.includes('abort')
+  }
+  if (point.name === 'abort.integration') {
+    // For now, this is the only other one we want to dedupe
+    const compiledPoint = point.name + point.tags.join('')
+    return seen.includes(compiledPoint)
+  }
+  return false
+}
+
+function sendTelemetry (name, tags = []) {
+  let points = name
+  if (typeof name === 'string') {
+    points = [{ name, tags }]
+  }
+  if (['1', 'true', 'True'].includes(process.env.DD_INJECT_FORCE)) {
+    points = points.filter(p => ['error', 'complete'].includes(p.name))
+  }
+  points = points.filter(p => !hasSeen(p))
+  points.forEach(p => {
+    p.name = `library_entrypoint.${p.name}`
+  })
+  if (points.length === 0) {
+    return
+  }
+  const proc = spawn(process.env.DD_TELEMETRY_FORWARDER_PATH, ['library_entrypoint'], {
+    stdio: 'pipe'
+  })
+  proc.on('error', () => {
+    log.error('Failed to spawn telemetry forwarder')
+  })
+  proc.on('exit', (code) => {
+    if (code !== 0) {
+      log.error(`Telemetry forwarder exited with code ${code}`)
+    }
+  })
+  proc.stdin.on('error', () => {
+    log.error('Failed to write telemetry data to telemetry forwarder')
+  })
+  proc.stdin.end(JSON.stringify({ metadata, points }))
+}

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

@@ -20,8 +20,8 @@ const SERVICE_NAME = tags.SERVICE_NAME
 const MEASURED = tags.MEASURED
 
 class DatadogTracer extends Tracer {
-  constructor (config) {
-    super(config)
+  constructor (config, prioritySampler) {
+    super(config, prioritySampler)
     this._dataStreamsProcessor = new DataStreamsProcessor(config)
     this._scope = new Scope()
     setStartupLogConfig(config)

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

@@ -69,10 +69,15 @@ function calculateDDBasePath (dirname) {
   return dirSteps.slice(0, packagesIndex + 1).join(path.sep) + path.sep
 }
 
+function hasOwn (object, prop) {
+  return Object.prototype.hasOwnProperty.call(object, prop)
+}
+
 module.exports = {
   isTrue,
   isFalse,
   isError,
   globMatch,
-  calculateDDBasePath
+  calculateDDBasePath,
+  hasOwn
 }

package/packages/datadog-core/src/storage/async_hooks.js

@@ -1,49 +0,0 @@
-'use strict'
-
-const { executionAsyncId } = require('async_hooks')
-const AsyncResourceStorage = require('./async_resource')
-
-class AsyncHooksStorage extends AsyncResourceStorage {
-  constructor () {
-    super()
-
-    this._resources = new Map()
-  }
-
-  disable () {
-    super.disable()
-
-    this._resources.clear()
-  }
-
-  _createHook () {
-    return {
-      ...super._createHook(),
-      destroy: this._destroy.bind(this)
-    }
-  }
-
-  _init (asyncId, type, triggerAsyncId, resource) {
-    super._init.apply(this, arguments)
-
-    this._resources.set(asyncId, resource)
-  }
-
-  _destroy (asyncId) {
-    this._resources.delete(asyncId)
-  }
-
-  _executionAsyncResource () {
-    const asyncId = executionAsyncId()
-
-    let resource = this._resources.get(asyncId)
-
-    if (!resource) {
-      this._resources.set(asyncId, resource = {})
-    }
-
-    return resource
-  }
-}
-
-module.exports = AsyncHooksStorage