dd-trace 4.18.0 → 5.6.0

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

@@ -1,9 +1,14 @@
+
 const request = require('../exporters/common/request')
+const log = require('../log')
+const { isTrue } = require('../util')
+
+let agentTelemetry = true
 
 function getHeaders (config, application, reqType) {
   const headers = {
     'content-type': 'application/json',
-    'dd-telemetry-api-version': 'v1',
+    'dd-telemetry-api-version': 'v2',
     'dd-telemetry-request-type': reqType,
     'dd-client-library-language': application.language_name,
     'dd-client-library-version': application.tracer_version
@@ -12,9 +17,19 @@ function getHeaders (config, application, reqType) {
   if (debug) {
     headers['dd-telemetry-debug-enabled'] = 'true'
   }
+  if (config.apiKey) {
+    headers['dd-api-key'] = config.apiKey
+  }
   return headers
 }
 
+function getAgentlessTelemetryEndpoint (site) {
+  if (site === 'datad0g.com') { // staging
+    return 'https://all-http-intake.logs.datad0g.com'
+  }
+  return `https://instrumentation-telemetry-intake.${site}`
+}
+
 let seqId = 0
 
 function getPayload (payload) {
@@ -28,23 +43,39 @@ function getPayload (payload) {
   }
 }
 
-function sendData (config, application, host, reqType, payload = {}) {
+function sendData (config, application, host, reqType, payload = {}, cb = () => {}) {
   const {
     hostname,
     port,
-    url
+    isCiVisibility
   } = config
 
+  let url = config.url
+
+  const isCiVisibilityAgentlessMode = isCiVisibility && isTrue(process.env.DD_CIVISIBILITY_AGENTLESS_ENABLED)
+
+  if (isCiVisibilityAgentlessMode) {
+    try {
+      url = url || new URL(getAgentlessTelemetryEndpoint(config.site))
+    } catch (err) {
+      log.error(err)
+      // No point to do the request if the URL is invalid
+      return cb(err, { payload, reqType })
+    }
+  }
+
   const options = {
     url,
     hostname,
     port,
     method: 'POST',
-    path: '/telemetry/proxy/api/v2/apmtelemetry',
+    path: isCiVisibilityAgentlessMode ? '/api/v2/apmtelemetry' : '/telemetry/proxy/api/v2/apmtelemetry',
     headers: getHeaders(config, application, reqType)
   }
+
   const data = JSON.stringify({
-    api_version: 'v1',
+    api_version: 'v2',
+    naming_schema_version: config.spanAttributeSchema ? config.spanAttributeSchema : '',
     request_type: reqType,
     tracer_time: Math.floor(Date.now() / 1000),
     runtime_id: config.tags['runtime-id'],
@@ -54,8 +85,35 @@ function sendData (config, application, host, reqType, payload = {}) {
     host
   })
 
-  request(data, options, () => {
-    // ignore errors
+  request(data, options, (error) => {
+    if (error && process.env.DD_API_KEY && config.site) {
+      if (agentTelemetry) {
+        log.warn('Agent telemetry failed, started agentless telemetry')
+        agentTelemetry = false
+      }
+      // figure out which data center to send to
+      const backendUrl = getAgentlessTelemetryEndpoint(config.site)
+      const backendHeader = { ...options.headers, 'DD-API-KEY': process.env.DD_API_KEY }
+      const backendOptions = {
+        ...options,
+        url: backendUrl,
+        headers: backendHeader,
+        path: '/api/v2/apmtelemetry'
+      }
+      if (backendUrl) {
+        request(data, backendOptions, (error) => { log.error(error) })
+      } else {
+        log.error('Invalid Telemetry URL')
+      }
+    }
+
+    if (!error && !agentTelemetry) {
+      agentTelemetry = true
+      log.info('Started agent telemetry')
+    }
+
+    // call the callback function so that we can track the error and payload
+    cb(error, { payload, reqType })
   })
 }
 

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

@@ -8,7 +8,7 @@ const { isError } = require('./util')
 const { setStartupLogConfig } = require('./startup-log')
 const { ERROR_MESSAGE, ERROR_TYPE, ERROR_STACK } = require('../../dd-trace/src/constants')
 const { DataStreamsProcessor } = require('./datastreams/processor')
-const { decodePathwayContext } = require('./datastreams/pathway')
+const { DsmPathwayCodec } = require('./datastreams/pathway')
 const { DD_MAJOR } = require('../../../version')
 const DataStreamsContext = require('./data_streams_context')
 
@@ -31,19 +31,25 @@ class DatadogTracer extends Tracer {
 
   // todo[piochelepiotr] These two methods are not related to the tracer, but to data streams monitoring.
   // They should be moved outside of the tracer in the future.
-  setCheckpoint (edgeTags) {
-    const ctx = this._dataStreamsProcessor.setCheckpoint(edgeTags, DataStreamsContext.getDataStreamsContext())
+  setCheckpoint (edgeTags, span, payloadSize = 0) {
+    const ctx = this._dataStreamsProcessor.setCheckpoint(
+      edgeTags, span, DataStreamsContext.getDataStreamsContext(), payloadSize
+    )
     DataStreamsContext.setDataStreamsContext(ctx)
     return ctx
   }
 
-  decodeDataStreamsContext (data) {
-    const ctx = decodePathwayContext(data)
+  decodeDataStreamsContext (carrier) {
+    const ctx = DsmPathwayCodec.decode(carrier)
     // we erase the previous context everytime we decode a new one
     DataStreamsContext.setDataStreamsContext(ctx)
     return ctx
   }
 
+  setOffset (offsetData) {
+    return this._dataStreamsProcessor.setOffset(offsetData)
+  }
+
   trace (name, options, fn) {
     options = Object.assign({
       childOf: this.scope().active()
@@ -129,6 +135,7 @@ class DatadogTracer extends Tracer {
 
   setUrl (url) {
     this._exporter.setUrl(url)
+    this._dataStreamsProcessor.setUrl(url)
   }
 
   scope () {

package/register.js

@@ -0,0 +1,4 @@
+const { register } = require('node:module')
+const { pathToFileURL } = require('node:url')
+
+register('./loader-hook.mjs', pathToFileURL(__filename))

package/scripts/install_plugin_modules.js

@@ -80,7 +80,9 @@ async function assertVersions () {
 }
 
 async function assertInstrumentation (instrumentation, external) {
-  const versions = [].concat(instrumentation.versions || [])
+  const versions = process.env.PACKAGE_VERSION_RANGE ? [process.env.PACKAGE_VERSION_RANGE]
+    : [].concat(instrumentation.versions || [])
+
   for (const version of versions) {
     if (version) {
       await assertModules(instrumentation.name, semver.coerce(version).version, external)
@@ -130,8 +132,14 @@ async function assertPackage (name, version, dependency, external) {
   }
 
   if (!external) {
-    pkg.workspaces = {
-      nohoist: ['**/**']
+    if (name === 'aerospike') {
+      pkg.installConfig = {
+        'hoistingLimits': 'workspaces'
+      }
+    } else {
+      pkg.workspaces = {
+        nohoist: ['**/**']
+      }
     }
   }
   fs.writeFileSync(filename(name, version, 'package.json'), JSON.stringify(pkg, null, 2) + '\n')

package/scripts/st.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+/* eslint-disable no-console, no-fallthrough */
+'use strict'
+
+const path = require('path')
+const { writeFileSync } = require('fs')
+const { execSync } = require('child_process')
+
+const ddtracePath = path.join(__dirname, '..')
+const defaultTestPath = process.env.DD_ST_PATH || path.join(ddtracePath, '..', 'system-tests')
+
+const { buildAll, npm, testDir, testArgs } = parseArgs()
+
+const binariesPath = path.join(testDir, 'binaries')
+
+if (npm) {
+  console.log('Using NPM package:', npm)
+
+  writeFileSync(path.join(binariesPath, 'nodejs-load-from-npm'), npm)
+} else {
+  console.log('Using local repo')
+
+  const packName = execSync(`npm pack ${ddtracePath}`, {
+    cwd: binariesPath,
+    stdio: [null, null, 'inherit'],
+    encoding: 'utf8'
+  }).slice(0, -1) // remove trailing newline
+
+  writeFileSync(path.join(binariesPath, 'nodejs-load-from-npm'), `/binaries/${packName}`)
+}
+
+try {
+  execSync(`./build.sh ${buildAll ? '' : '-i weblog'} && ./run.sh ${testArgs}`, {
+    cwd: testDir,
+    stdio: [null, 'inherit', 'inherit']
+  })
+} catch (err) {
+  process.exit(err.status || 1)
+}
+
+function parseArgs () {
+  const args = {
+    buildAll: false,
+    npm: null,
+    testDir: defaultTestPath,
+    testArgs: ''
+  }
+
+  for (let i = 2; i < process.argv.length; i++) {
+    switch (process.argv[i]) {
+      case '-b':
+      case '--build-all':
+        args.buildAll = true
+        break
+
+      case '-h':
+      case '--help':
+        helpAndExit()
+        break
+
+      case '-n':
+      case '--npm': {
+        const arg = process.argv[i + 1]
+        if (!arg || arg[0] === '-') {
+          args.npm = 'dd-trace'
+        } else {
+          args.npm = arg
+          i++
+        }
+        break
+      }
+
+      case '-t':
+      case '--test-dir': {
+        const arg = process.argv[++i]
+        if (!arg || arg[0] === '-') helpAndExit()
+        args.testDir = arg
+        break
+      }
+
+      case '--':
+        args.testArgs = process.argv.slice(i + 1).join(' ')
+        return args
+
+      default:
+        console.log('Unknown option:', process.argv[i], '\n')
+        helpAndExit()
+    }
+  }
+
+  return args
+}
+
+function helpAndExit () {
+  console.log('Usage: node st.js [options...] [-- test-args]')
+  console.log('Options:')
+  console.log('  -b, --build-all       Rebuild all images (default: only build weblog)')
+  console.log('  -h, --help            Print this message')
+  console.log('  -n, --npm [package]   Build a remote package instead of the local repo (default: "dd-trace")')
+  console.log('                        Can be a package name (e.g. "dd-trace@4.2.0") or a git URL (e.g.')
+  console.log('                        "git+https://github.com/DataDog/dd-trace-js.git#mybranch")')
+  console.log('  -t, --test-dir <path> Specify the system-tests directory (default: "dd-trace/../system-tests/")')
+  console.log('  -- <test-args>        Passed to system-tests run.sh (e.g. "-- SCENARIO_NAME tests/path_to_test.py")')
+  process.exit()
+}

package/packages/datadog-instrumentations/src/child-process.js

@@ -1,30 +0,0 @@
-'use strict'
-
-const {
-  channel,
-  addHook
-} = require('./helpers/instrument')
-const shimmer = require('../../datadog-shimmer')
-
-const childProcessChannel = channel('datadog:child_process:execution:start')
-const execMethods = ['exec', 'execFile', 'fork', 'spawn', 'execFileSync', 'execSync', 'spawnSync']
-const names = ['child_process', 'node:child_process']
-names.forEach(name => {
-  addHook({ name }, childProcess => {
-    shimmer.massWrap(childProcess, execMethods, wrapChildProcessMethod())
-    return childProcess
-  })
-})
-
-function wrapChildProcessMethod () {
-  function wrapMethod (childProcessMethod) {
-    return function () {
-      if (childProcessChannel.hasSubscribers && arguments.length > 0) {
-        const command = arguments[0]
-        childProcessChannel.publish({ command })
-      }
-      return childProcessMethod.apply(this, arguments)
-    }
-  }
-  return wrapMethod
-}

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

@@ -1,13 +0,0 @@
-const cp = require('child_process')
-const log = require('../../log')
-
-const sanitizedExec = (cmd, flags, options = { stdio: 'pipe' }) => {
-  try {
-    return cp.execFileSync(cmd, flags, options).toString().replace(/(\r\n|\n|\r)/gm, '')
-  } catch (e) {
-    log.error(e)
-    return ''
-  }
-}
-
-module.exports = { sanitizedExec }

package/packages/diagnostics_channel/index.js

@@ -1,3 +0,0 @@
-'use strict'
-
-module.exports = require('./src')

package/packages/diagnostics_channel/src/index.js

@@ -1,121 +0,0 @@
-'use strict'
-
-const {
-  Channel,
-  channel
-} = require('diagnostics_channel') // eslint-disable-line n/no-restricted-require
-
-const [major, minor] = process.versions.node.split('.')
-const channels = new WeakSet()
-
-// Our own DC with a limited subset of functionality stable across Node versions.
-// TODO: Move the rest of the polyfill here.
-// TODO: Switch to using global subscribe/unsubscribe/hasSubscribers.
-const dc = { channel }
-
-// Prevent going to 0 subscribers to avoid bug in Node.
-// See https://github.com/nodejs/node/pull/47520
-if (major === '19' && minor === '9') {
-  dc.channel = function () {
-    const ch = channel.apply(this, arguments)
-
-    if (!channels.has(ch)) {
-      const subscribe = ch.subscribe
-      const unsubscribe = ch.unsubscribe
-
-      ch.subscribe = function () {
-        delete ch.subscribe
-        delete ch.unsubscribe
-
-        const result = subscribe.apply(this, arguments)
-
-        this.subscribe(() => {}) // Keep it active forever.
-
-        return result
-      }
-
-      if (ch.unsubscribe === Channel.prototype.unsubscribe) {
-        // Needed because another subscriber could have subscribed to something
-        // that we unsubscribe to before the library is loaded.
-        ch.unsubscribe = function () {
-          delete ch.subscribe
-          delete ch.unsubscribe
-
-          this.subscribe(() => {}) // Keep it active forever.
-
-          return unsubscribe.apply(this, arguments)
-        }
-      }
-
-      channels.add(ch)
-    }
-
-    return ch
-  }
-}
-
-if (!Channel.prototype.runStores) {
-  const ActiveChannelPrototype = getActiveChannelPrototype()
-
-  Channel.prototype.bindStore = ActiveChannelPrototype.bindStore = function (store, transform) {
-    if (!this._stores) {
-      this._stores = new Map()
-    }
-    this._stores.set(store, transform)
-  }
-
-  Channel.prototype.unbindStore = ActiveChannelPrototype.unbindStore = function (store) {
-    if (!this._stores) return
-    this._stores.delete(store)
-  }
-
-  Channel.prototype.runStores = ActiveChannelPrototype.runStores = function (data, fn, thisArg, ...args) {
-    if (!this._stores) return Reflect.apply(fn, thisArg, args)
-
-    let run = () => {
-      this.publish(data)
-      return Reflect.apply(fn, thisArg, args)
-    }
-
-    for (const entry of this._stores.entries()) {
-      const store = entry[0]
-      const transform = entry[1]
-      run = wrapStoreRun(store, data, run, transform)
-    }
-
-    return run()
-  }
-}
-
-function defaultTransform (data) {
-  return data
-}
-
-function wrapStoreRun (store, data, next, transform = defaultTransform) {
-  return () => {
-    let context
-    try {
-      context = transform(data)
-    } catch (err) {
-      process.nextTick(() => {
-        throw err
-      })
-      return next()
-    }
-
-    return store.run(context, next)
-  }
-}
-
-function getActiveChannelPrototype () {
-  const dummyChannel = channel('foo')
-  const listener = () => {}
-
-  dummyChannel.subscribe(listener)
-  const ActiveChannelPrototype = Object.getPrototypeOf(dummyChannel)
-  dummyChannel.unsubscribe(listener)
-
-  return ActiveChannelPrototype
-}
-
-module.exports = dc