@depup/dd-trace 5.90.0-depup.0

package/packages/dd-trace/src/exporters/log/index.js

@@ -0,0 +1,52 @@
+'use strict'
+
+const log = require('../../log')
+
+const TRACE_PREFIX = '{"traces":[['
+const TRACE_SUFFIX = ']]}\n'
+const TRACE_FORMAT_OVERHEAD = TRACE_PREFIX.length + TRACE_SUFFIX.length
+const MAX_SIZE = 64 * 1024 // 64kb
+
+class LogExporter {
+  export (spans) {
+    log.debug('Adding trace to queue: %j', spans)
+
+    let size = TRACE_FORMAT_OVERHEAD
+    let queue = []
+
+    for (const span of spans) {
+      const spanStr = JSON.stringify(span)
+      if (spanStr.length + TRACE_FORMAT_OVERHEAD > MAX_SIZE) {
+        log.debug('Span too large to send to logs, dropping')
+        continue
+      }
+      if (spanStr.length + size > MAX_SIZE) {
+        this._printSpans(queue)
+        queue = []
+        size = TRACE_FORMAT_OVERHEAD
+      }
+      size += spanStr.length + 1 // includes length of ',' character
+      queue.push(spanStr)
+    }
+    if (queue.length > 0) {
+      this._printSpans(queue)
+    }
+  }
+
+  _printSpans (queue) {
+    let logLine = TRACE_PREFIX
+    let firstTrace = true
+    for (const spanStr of queue) {
+      if (firstTrace) {
+        firstTrace = false
+        logLine += spanStr
+      } else {
+        logLine += ',' + spanStr
+      }
+    }
+    logLine += TRACE_SUFFIX
+    process.stdout.write(logLine)
+  }
+}
+
+module.exports = LogExporter

package/packages/dd-trace/src/exporters/span-stats/index.js

@@ -0,0 +1,20 @@
+'use strict'
+
+const { getAgentUrl } = require('../../agent/url')
+const { Writer } = require('./writer')
+
+class SpanStatsExporter {
+  constructor (config) {
+    this._url = getAgentUrl(config)
+    this._writer = new Writer({ url: this._url })
+  }
+
+  export (payload) {
+    this._writer.append(payload)
+    this._writer.flush()
+  }
+}
+
+module.exports = {
+  SpanStatsExporter,
+}

package/packages/dd-trace/src/exporters/span-stats/writer.js

@@ -0,0 +1,54 @@
+'use strict'
+
+const { SpanStatsEncoder } = require('../../encode/span-stats')
+
+const pkg = require('../../../../../package.json')
+
+const BaseWriter = require('../common/writer')
+const request = require('../common/request')
+const log = require('../../log')
+
+class Writer extends BaseWriter {
+  constructor ({ url }) {
+    super(...arguments)
+    this._url = url
+    this._encoder = new SpanStatsEncoder(this)
+  }
+
+  _sendPayload (data, _, done) {
+    makeRequest(data, this._url, (err, res) => {
+      if (err) {
+        log.error('Error sending span stats', err)
+        done()
+        return
+      }
+      log.debug('Response from the intake:', res)
+      done()
+    })
+  }
+}
+
+function makeRequest (data, url, cb) {
+  const options = {
+    path: '/v0.6/stats',
+    method: 'PUT',
+    headers: {
+      'Datadog-Meta-Lang': 'javascript',
+      'Datadog-Meta-Tracer-Version': pkg.version,
+      'Content-Type': 'application/msgpack',
+    },
+    protocol: url.protocol,
+    hostname: url.hostname,
+    port: url.port,
+  }
+
+  log.debug('Request to the intake: %j', options)
+
+  request(data, options, (err, res) => {
+    cb(err, res)
+  })
+}
+
+module.exports = {
+  Writer,
+}

package/packages/dd-trace/src/external-logger/src/index.js

@@ -0,0 +1,139 @@
+'use strict'
+
+const https = require('https')
+const tracerLogger = require('../../log')// path to require tracer logger
+
+class ExternalLogger {
+  // Note: these attribute names match the corresponding entry in the JSON payload.
+  constructor ({
+    ddsource, hostname, service, apiKey, site = 'datadoghq.com', interval = 10_000, timeout = 2000, limit = 1000,
+  }) {
+    this.enabled = !!apiKey
+
+    this.ddsource = ddsource
+    this.hostname = hostname
+    this.service = service
+    this.interval = interval
+    this.timeout = timeout
+    this.queue = []
+    this.limit = limit
+    this.endpoint = '/api/v2/logs'
+    this.site = site
+    this.intake = `http-intake.logs.${this.site}`
+    this.headers = {
+      'DD-API-KEY': apiKey,
+      'Content-Type': 'application/json',
+    }
+    this.timer = setInterval(() => {
+      this.flush()
+    }, this.interval).unref()
+
+    tracerLogger.debug(`started log writer to https://${this.intake}${this.endpoint}`)
+  }
+
+  static tagString (tags) {
+    const tagArray = []
+    for (const key in tags) {
+      tagArray.push(key + ':' + tags[key])
+    }
+    return tagArray.join(',')
+  }
+
+  // Parses and enqueues a log
+  log (log, span, tags) {
+    if (!this.enabled) return
+
+    const logTags = ExternalLogger.tagString(tags)
+
+    if (span) {
+      log['dd.trace_id'] = String(span.trace_id)
+      log['dd.span_id'] = String(span.span_id)
+    }
+
+    const payload = {
+      ...log,
+      timestamp: Date.now(),
+      hostname: log.hostname || this.hostname,
+      ddsource: log.ddsource || this.ddsource,
+      service: log.service || this.service,
+      ddtags: logTags || undefined,
+    }
+
+    this.enqueue(payload)
+  }
+
+  // Enqueues a raw, non-formatted log object
+  enqueue (log) {
+    if (this.queue.length >= this.limit) {
+      this.flush()
+    }
+    this.queue.push(log)
+  }
+
+  shutdown () {
+    clearInterval(this.timer)
+    this.flush()
+  }
+
+  // Flushes logs with optional callback for when the call is complete
+  flush (cb = () => {}) {
+    let logs
+    let numLogs
+    let encodedLogs
+
+    if (!this.queue.length) {
+      setImmediate(() => cb())
+      return
+    }
+
+    try {
+      logs = this.queue
+      this.queue = []
+
+      numLogs = logs.length
+      encodedLogs = JSON.stringify(logs)
+    } catch (error) {
+      tracerLogger.error(`failed to encode ${numLogs} logs`)
+      setImmediate(() => cb(error))
+      return
+    }
+
+    const options = {
+      hostname: this.intake,
+      port: 443,
+      path: this.endpoint,
+      method: 'POST',
+      headers: this.headers,
+      timeout: this.timeout,
+    }
+
+    const req = https.request(options, (res) => {
+      tracerLogger.info(`statusCode: ${res.statusCode}`)
+    })
+    req.once('error', (e) => {
+      tracerLogger.error(`failed to send ${numLogs} log(s), with error ${e.message}`)
+      cb(e)
+    })
+    req.write(encodedLogs)
+    req.end()
+    req.once('response', (res) => {
+      if (res.statusCode >= 400) {
+        const error = new Error(`failed to send ${numLogs} logs, received response code ${res.statusCode}`)
+        tracerLogger.error(error.message)
+        cb(error)
+        return
+      }
+      cb()
+    })
+  }
+}
+
+class NoopExternalLogger {
+  log () {}
+  enqueue () {}
+  shutdown () {}
+  flush () {}
+}
+
+module.exports.ExternalLogger = ExternalLogger
+module.exports.NoopExternalLogger = NoopExternalLogger

package/packages/dd-trace/src/flare/file.js

@@ -0,0 +1,40 @@
+'use strict'
+
+const { Writable } = require('stream')
+
+const INITIAL_SIZE = 64 * 1024
+
+class FlareFile extends Writable {
+  constructor () {
+    super()
+
+    this.length = 0
+
+    this._buffer = Buffer.alloc(INITIAL_SIZE)
+  }
+
+  get data () {
+    return this._buffer.subarray(0, this.length)
+  }
+
+  _write (chunk, encoding, callback) {
+    const length = Buffer.byteLength(chunk)
+
+    this._reserve(length)
+
+    this.length += Buffer.isBuffer(chunk) ? chunk.copy(this._buffer, this.length) : this._buffer.write(chunk, encoding)
+
+    callback()
+  }
+
+  _reserve (length) {
+    while (this.length + length > this._buffer.length) {
+      const buffer = Buffer.alloc(this.length * 2)
+
+      this._buffer.copy(buffer)
+      this._buffer = buffer
+    }
+  }
+}
+
+module.exports = FlareFile

package/packages/dd-trace/src/flare/index.js

@@ -0,0 +1,101 @@
+'use strict'
+
+const log = require('../log')
+const startupLog = require('../startup-log')
+const { LogChannel } = require('../log/channels')
+const request = require('../exporters/common/request')
+const FormData = require('../exporters/common/form-data')
+const FlareFile = require('./file')
+
+const MAX_LOG_SIZE = 12 * 1024 * 1024 // 12MB soft limit
+const TIMEOUT = 20 * 1000 * 60
+
+let logChannel = null
+let tracerLogs = null
+let timer
+let tracerConfig = null
+
+const logger = {
+  debug: (msg) => recordLog(msg),
+  info: (msg) => recordLog(msg),
+  warn: (msg) => recordLog(msg),
+  error: (err) => recordLog(err.stack),
+}
+
+const flare = {
+  enable (tracerConfig_) {
+    tracerConfig = tracerConfig_
+  },
+
+  disable () {
+    tracerConfig = null
+
+    flare.cleanup()
+  },
+
+  prepare (logLevel) {
+    if (!tracerConfig) return
+
+    logChannel?.unsubscribe(logger)
+    logChannel = new LogChannel(logLevel)
+    logChannel.subscribe(logger)
+    tracerLogs = tracerLogs || new FlareFile()
+    timer = timer || setTimeout(flare.cleanup, TIMEOUT)
+  },
+
+  send (task) {
+    if (!tracerConfig) return
+
+    const tracerInfo = new FlareFile()
+
+    tracerInfo.write(JSON.stringify(startupLog.tracerInfo(), null, 2))
+
+    flare._sendFile(task, tracerInfo, 'tracer_info.txt')
+    flare._sendFile(task, tracerLogs, 'tracer_logs.txt')
+
+    flare.cleanup()
+  },
+
+  cleanup () {
+    logChannel?.unsubscribe(logger)
+    timer = clearTimeout(timer)
+    logChannel = null
+    tracerLogs = null
+  },
+
+  _sendFile (task, file, filename) {
+    if (!file || file.length === 0) return
+
+    const form = new FormData()
+
+    form.append('case_id', task.case_id)
+    form.append('hostname', task.hostname)
+    form.append('email', task.user_handle)
+    form.append('source', 'tracer_nodejs')
+    form.append('flare_file', file.data, { filename })
+
+    request(form, {
+      url: tracerConfig.url,
+      hostname: tracerConfig.hostname,
+      port: tracerConfig.port,
+      method: 'POST',
+      path: '/tracer_flare/v1',
+      headers: form.getHeaders(),
+    }, (err) => {
+      if (err) {
+        log.error('Error sending flare payload', err)
+      }
+    })
+  },
+}
+
+function recordLog (msg) {
+  if (tracerLogs.length > MAX_LOG_SIZE) return
+
+  if (msg && typeof msg === 'object') {
+    msg = JSON.stringify(msg)
+  }
+  tracerLogs.write(`${msg}\n`) // TODO: gzip
+}
+
+module.exports = flare

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

@@ -0,0 +1,19 @@
+'use strict'
+
+const { SCI_COMMIT_SHA, SCI_REPOSITORY_URL } = require('./constants')
+
+class GitMetadataTagger {
+  constructor (config) {
+    this._config = config
+  }
+
+  tagGitMetadata (spanContext) {
+    if (this._config.gitMetadataEnabled) {
+      // These tags are added only to the local root span
+      spanContext._trace.tags[SCI_COMMIT_SHA] = this._config.commitSHA
+      spanContext._trace.tags[SCI_REPOSITORY_URL] = this._config.repositoryUrl
+    }
+  }
+}
+
+module.exports = GitMetadataTagger

package/packages/dd-trace/src/guardrails/index.js

@@ -0,0 +1,76 @@
+'use strict'
+
+var path = require('path')
+var Module = require('module')
+
+var nodeVersion = require('../../../../version')
+var isTrue = require('./util').isTrue
+var log = require('./log')
+var telemetry = require('./telemetry')
+
+var NODE_MAJOR = nodeVersion.NODE_MAJOR
+
+function guard (fn) {
+  var initBailout = false
+  var clobberBailout = false
+  var forced = isTrue(process.env.DD_INJECT_FORCE)
+  var engines = require('../../../../package.json').engines
+  var versions = engines.node.match(/^>=(\d+) <(\d+)$/)
+  var minMajor = versions[1]
+  var nextMajor = versions[2]
+  var version = process.versions.node
+
+  if (process.env.DD_INJECTION_ENABLED) {
+    // If we're running via single-step install, and we're in the app's
+    // node_modules, then we should not initialize the tracer. This prevents
+    // single-step-installed tracer from clobbering the manually-installed tracer.
+    var resolvedInApp
+    var entrypoint = process.argv[1]
+    try {
+      // eslint-disable-next-line n/no-unsupported-features/node-builtins
+      resolvedInApp = Module.createRequire(entrypoint).resolve('dd-trace')
+    } catch (e) {
+      // Ignore. If we can't resolve the module, we assume it's not in the app.
+      // TODO: There's also the possibility that this version of Node.js doesn't have Module.createRequire (pre v12.2.0)
+    }
+    if (resolvedInApp) {
+      var ourselves = path.normalize(path.join(__dirname, '..', '..', '..', '..', 'index.js'))
+      if (ourselves !== resolvedInApp) {
+        clobberBailout = true
+      }
+    }
+  }
+
+  // If the runtime doesn't match the engines field in package.json, then we
+  // should not initialize the tracer.
+  if (!clobberBailout && (NODE_MAJOR < minMajor || NODE_MAJOR >= nextMajor)) {
+    initBailout = true
+    telemetry([
+      { name: 'abort', tags: ['reason:incompatible_runtime'] },
+      { name: 'abort.runtime', tags: [] }
+    ], undefined, {
+      result: 'abort',
+      result_class: 'incompatible_runtime',
+      result_reason: 'Incompatible runtime Node.js ' + version + ', supported runtimes: Node.js ' + engines.node
+    })
+    log.info('Aborting application instrumentation due to incompatible_runtime.')
+    log.info('Found incompatible runtime Node.js %s, Supported runtimes: Node.js %s.', version, engines.node)
+    if (forced) {
+      log.info('DD_INJECT_FORCE enabled, allowing unsupported runtimes and continuing.')
+    }
+  }
+
+  if (!clobberBailout && (!initBailout || forced)) {
+    // Ensure the instrumentation source is set for the current process and potential child processes.
+    var result = fn()
+    telemetry('complete', ['injection_forced:' + (forced && initBailout ? 'true' : 'false')], {
+      result: 'success',
+      result_class: 'success',
+      result_reason: 'Successfully configured ddtrace package'
+    })
+    log.info('Application instrumentation bootstrapping complete')
+    return result
+  }
+}
+
+module.exports = guard

package/packages/dd-trace/src/guardrails/log.js

@@ -0,0 +1,32 @@
+'use strict'
+
+/* eslint-disable no-console */
+
+var isTrue = require('./util').isTrue
+
+var DD_TRACE_DEBUG = process.env.DD_TRACE_DEBUG
+var DD_TRACE_LOG_LEVEL = process.env.DD_TRACE_LOG_LEVEL
+
+var logLevels = {
+  trace: 20,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  critical: 50,
+  off: 100
+}
+
+var logLevel = isTrue(DD_TRACE_DEBUG)
+  ? Number(DD_TRACE_LOG_LEVEL) || logLevels.debug
+  : logLevels.off
+
+var log = {
+  /* eslint n/no-unsupported-features/node-builtins: ['error', { ignores: ['console.debug'] }] */
+  debug: logLevel <= 20 ? (console.debug || console.log).bind(console) : function () {},
+  info: logLevel <= 30 ? console.info.bind(console) : function () {},
+  warn: logLevel <= 40 ? console.warn.bind(console) : function () {},
+  error: logLevel <= 50 ? console.error.bind(console) : function () {}
+}
+
+module.exports = log

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

@@ -0,0 +1,92 @@
+'use strict'
+
+var fs = require('fs')
+var spawn = require('child_process').spawn
+var tracerVersion = require('../../../../package.json').version
+var log = require('./log')
+
+module.exports = sendTelemetry
+
+if (!process.env.DD_INJECTION_ENABLED) {
+  module.exports = function noop () {}
+}
+
+var telemetryForwarderPath = process.env.DD_TELEMETRY_FORWARDER_PATH
+if (typeof telemetryForwarderPath !== 'string' || !fs.existsSync(telemetryForwarderPath)) {
+  module.exports = function noop () {}
+}
+
+var metadata = {
+  language_name: 'nodejs',
+  language_version: process.versions.node,
+  runtime_name: 'nodejs',
+  runtime_version: process.versions.node,
+  tracer_version: tracerVersion,
+  pid: process.pid,
+  result: 'unknown',
+  result_reason: 'unknown',
+  result_class: 'unknown'
+}
+
+var seen = {}
+function shouldSend (point) {
+  if (point.name === 'abort') {
+    // This one can only be sent once, regardless of tags
+    if (seen.abort) {
+      return false
+    }
+    seen.abort = true
+  } else if (point.name === 'abort.integration') {
+    // For now, this is the only other one we want to dedupe
+    var compiledPoint = point.name + point.tags.join('')
+    if (seen[compiledPoint]) {
+      return false
+    }
+    seen[compiledPoint] = true
+  }
+  return true
+}
+
+function sendTelemetry (name, tags, resultMetadata) {
+  var points = name
+  if (typeof name === 'string') {
+    points = [{ name: name, tags: tags || [] }]
+  }
+  if (['1', 'true', 'True'].indexOf(process.env.DD_INJECT_FORCE) !== -1) {
+    points = points.filter(function (p) { return ['error', 'complete'].indexOf(p.name) !== -1 })
+  }
+  points = points.filter(function (p) { return shouldSend(p) })
+  for (var i = 0; i < points.length; i++) {
+    points[i].name = 'library_entrypoint.' + points[i].name
+  }
+  if (points.length === 0) {
+    return
+  }
+
+  // Update metadata with provided result metadata
+  var currentMetadata = {}
+  for (var key in metadata) {
+    currentMetadata[key] = metadata[key]
+  }
+  if (resultMetadata) {
+    for (var resultKey in resultMetadata) {
+      currentMetadata[resultKey] = resultMetadata[resultKey]
+    }
+  }
+
+  var proc = spawn(telemetryForwarderPath, ['library_entrypoint'], {
+    stdio: 'pipe'
+  })
+  proc.on('error', function () {
+    log.error('Failed to spawn telemetry forwarder')
+  })
+  proc.once('exit', function (code) {
+    if (code !== 0) {
+      log.error('Telemetry forwarder exited with code', code)
+    }
+  })
+  proc.stdin.on('error', function () {
+    log.error('Failed to write telemetry data to telemetry forwarder')
+  })
+  proc.stdin.end(JSON.stringify({ metadata: currentMetadata, points: points }))
+}

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

@@ -0,0 +1,8 @@
+'use strict'
+
+function isTrue (str) {
+  str = String(str).toLowerCase()
+  return str === 'true' || str === '1'
+}
+
+module.exports = { isTrue: isTrue }

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

@@ -0,0 +1,58 @@
+'use strict'
+
+const { join } = require('path')
+const { setImmediate, setTimeout } = require('timers/promises')
+const { format } = require('util')
+const { writeHeapSnapshot } = require('v8')
+const { threadId } = require('worker_threads')
+const log = require('./log')
+
+async function scheduleSnapshot (config, total) {
+  if (total > config.heapSnapshot.count) return
+
+  await setTimeout(config.heapSnapshot.interval * 1000, null, { ref: false })
+  await clearMemory()
+  writeHeapSnapshot(getName(config.heapSnapshot.destination))
+  await scheduleSnapshot(config, total + 1)
+}
+
+async function clearMemory () {
+  if (!globalThis.gc) return
+  globalThis.gc()
+  await setImmediate()
+  globalThis.gc() // Run full GC a second time for anything missed in first GC.
+}
+
+function pad (value) {
+  return String(value).padStart(2, 0)
+}
+
+function getName (destination) {
+  const date = new Date()
+  const filename = format(
+    'Heap-%s%s%s-%s%s%s-%s-%s.heapsnapshot',
+    date.getFullYear(),
+    pad(date.getMonth()),
+    pad(date.getDate()),
+    pad(date.getHours()),
+    pad(date.getMinutes()),
+    pad(date.getSeconds()),
+    process.pid,
+    threadId
+  )
+
+  return join(destination, filename)
+}
+
+module.exports = {
+  async start (config) {
+    const destination = config.heapSnapshot.destination
+
+    try {
+      await scheduleSnapshot(config, 1)
+      log.debug('Wrote heap snapshots to %s.', destination)
+    } catch (e) {
+      log.error('Failed to write heap snapshots to %s.', destination, e)
+    }
+  },
+}