dd-trace 4.18.0 → 5.6.0

package/packages/dd-trace/src/exporters/common/request.js

@@ -7,6 +7,8 @@ const { Readable } = require('stream')
 const http = require('http')
 const https = require('https')
 const { parse: urlParse } = require('url')
+const zlib = require('zlib')
+
 const docker = require('./docker')
 const { httpAgent, httpsAgent } = require('./agents')
 const { storage } = require('../../../../datadog-core')
@@ -93,16 +95,31 @@ function request (data, options, callback) {
   options.agent = isSecure ? httpsAgent : httpAgent
 
   const onResponse = res => {
-    let responseData = ''
+    const chunks = []
 
     res.setTimeout(timeout)
 
-    res.on('data', chunk => { responseData += chunk })
+    res.on('data', chunk => {
+      chunks.push(chunk)
+    })
     res.on('end', () => {
       activeRequests--
+      const buffer = Buffer.concat(chunks)
 
       if (res.statusCode >= 200 && res.statusCode <= 299) {
-        callback(null, responseData, res.statusCode)
+        const isGzip = res.headers['content-encoding'] === 'gzip'
+        if (isGzip) {
+          zlib.gunzip(buffer, (err, result) => {
+            if (err) {
+              log.error(`Could not gunzip response: ${err.message}`)
+              callback(null, '', res.statusCode)
+            } else {
+              callback(null, result.toString(), res.statusCode)
+            }
+          })
+        } else {
+          callback(null, buffer.toString(), res.statusCode)
+        }
       } else {
         let errorMessage = ''
         try {
@@ -114,6 +131,7 @@ function request (data, options, callback) {
         } catch (e) {
           // ignore error
         }
+        const responseData = buffer.toString()
         if (responseData) {
           errorMessage += ` Response from the endpoint: "${responseData}"`
         }

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

@@ -14,7 +14,7 @@ const SPAN_SAMPLING_MECHANISM = constants.SPAN_SAMPLING_MECHANISM
 const SPAN_SAMPLING_RULE_RATE = constants.SPAN_SAMPLING_RULE_RATE
 const SPAN_SAMPLING_MAX_PER_SECOND = constants.SPAN_SAMPLING_MAX_PER_SECOND
 const SAMPLING_MECHANISM_SPAN = constants.SAMPLING_MECHANISM_SPAN
-const { MEASURED, BASE_SERVICE } = tags
+const { MEASURED, BASE_SERVICE, ANALYTICS } = tags
 const ORIGIN_KEY = constants.ORIGIN_KEY
 const HOSTNAME_KEY = constants.HOSTNAME_KEY
 const TOP_LEVEL_KEY = constants.TOP_LEVEL_KEY
@@ -24,6 +24,7 @@ const ERROR_STACK = constants.ERROR_STACK
 const ERROR_TYPE = constants.ERROR_TYPE
 
 const map = {
+  'operation.name': 'name',
   'service.name': 'service',
   'span.type': 'type',
   'resource.name': 'resource'
@@ -32,6 +33,7 @@ const map = {
 function format (span) {
   const formatted = formatSpan(span)
 
+  extractSpanLinks(formatted, span)
   extractRootTags(formatted, span)
   extractChunkTags(formatted, span)
   extractTags(formatted, span)
@@ -52,7 +54,8 @@ function formatSpan (span) {
     meta: {},
     metrics: {},
     start: Math.round(span._startTime * 1e6),
-    duration: Math.round(span._duration * 1e6)
+    duration: Math.round(span._duration * 1e6),
+    links: []
   }
 }
 
@@ -63,6 +66,28 @@ function setSingleSpanIngestionTags (span, options) {
   addTag({}, span.metrics, SPAN_SAMPLING_MAX_PER_SECOND, options.maxPerSecond)
 }
 
+function extractSpanLinks (trace, span) {
+  const links = []
+  if (span._links) {
+    for (const link of span._links) {
+      const { context, attributes } = link
+      const formattedLink = {}
+
+      formattedLink.trace_id = context.toTraceId(true)
+      formattedLink.span_id = context.toSpanId(true)
+
+      if (attributes && Object.keys(attributes).length > 0) {
+        formattedLink.attributes = attributes
+      }
+      if (context?._sampling?.priority >= 0) formattedLink.flags = context._sampling.priority > 0 ? 1 : 0
+      if (context?._tracestate) formattedLink.tracestate = context._tracestate.toString()
+
+      links.push(formattedLink)
+    }
+  }
+  if (links.length > 0) { trace.meta['_dd.span_links'] = JSON.stringify(links) }
+}
+
 function extractTags (trace, span) {
   const context = span.context()
   const origin = context._trace.origin
@@ -92,6 +117,9 @@ function extractTags (trace, span) {
       case 'http.status_code':
         addTag(trace.meta, {}, tag, tags[tag] && String(tags[tag]))
         break
+      case 'analytics.event':
+        addTag({}, trace.metrics, ANALYTICS, tags[tag] === undefined || tags[tag] ? 1 : 0)
+        break
       case HOSTNAME_KEY:
       case MEASURED:
         addTag({}, trace.metrics, tag, tags[tag] === undefined || tags[tag] ? 1 : 0)

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

@@ -42,6 +42,18 @@ class Identifier {
   toJSON () {
     return this.toString()
   }
+
+  equals (other) {
+    const length = this._buffer.length
+    const otherLength = other._buffer.length
+
+    // Only compare the bytes available in both IDs.
+    for (let i = length, j = otherLength; i >= 0 && j >= 0; i--, j--) {
+      if (this._buffer[i] !== other._buffer[j]) return false
+    }
+
+    return true
+  }
 }
 
 // Create a buffer, using an optional hexadecimal value if provided.

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

@@ -3,7 +3,7 @@
 const semver = require('semver')
 const logger = require('./log')
 const { addHook } = require('import-in-the-middle')
-const dc = require('../../diagnostics_channel')
+const dc = require('dc-polyfill')
 
 if (semver.satisfies(process.versions.node, '>=14.13.1')) {
   const moduleLoadStartChannel = dc.channel('dd-trace:moduleLoadStart')

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const { channel } = require('../../../diagnostics_channel')
+const { channel } = require('dc-polyfill')
 
 const Level = {
   Debug: 'debug',

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

@@ -20,6 +20,10 @@ class Tracer {
     return this
   }
 
+  profilerStarted () {
+    return Promise.resolve(false)
+  }
+
   trace (name, options, fn) {
     if (!fn) {
       fn = options

package/packages/dd-trace/src/noop/span.js

@@ -18,6 +18,7 @@ class NoopSpan {
   getBaggageItem (key) {}
   setTag (key, value) { return this }
   addTags (keyValueMap) { return this }
+  addLink (link) { return this }
   log () { return this }
   logEvent () {}
   finish (finishTime) {}

package/packages/dd-trace/src/opentelemetry/span.js

@@ -11,6 +11,7 @@ const tracer = require('../../')
 const DatadogSpan = require('../opentracing/span')
 const { ERROR_MESSAGE, ERROR_TYPE, ERROR_STACK } = require('../constants')
 const { SERVICE_NAME, RESOURCE_NAME } = require('../../../../ext/tags')
+const kinds = require('../../../../ext/kinds')
 
 const SpanContext = require('./span_context')
 
@@ -19,6 +20,93 @@ function hrTimeToMilliseconds (time) {
   return time[0] * 1e3 + time[1] / 1e6
 }
 
+const spanKindNames = {
+  [api.SpanKind.INTERNAL]: kinds.INTERNAL,
+  [api.SpanKind.SERVER]: kinds.SERVER,
+  [api.SpanKind.CLIENT]: kinds.CLIENT,
+  [api.SpanKind.PRODUCER]: kinds.PRODUCER,
+  [api.SpanKind.CONSUMER]: kinds.CONSUMER
+}
+
+/**
+ * Several of these attributes are not yet supported by the Node.js OTel API.
+ * We check for old equivalents where we can, but not all had equivalents.
+ */
+function spanNameMapper (spanName, kind, attributes) {
+  if (spanName) return spanName
+
+  const opName = attributes['operation.name']
+  if (opName) return opName
+
+  const { INTERNAL, SERVER, CLIENT } = api.SpanKind
+
+  // HTTP server and client requests
+  // TODO: Drop http.method when http.request.method is supported.
+  for (const key of ['http.method', 'http.request.method']) {
+    if (key in attributes) {
+      if (kind === SERVER) {
+        return 'http.server.request'
+      }
+      if (kind === CLIENT) {
+        return 'http.client.request'
+      }
+    }
+  }
+
+  // Databases
+  const dbSystem = attributes['db.system']
+  if (dbSystem && kind === CLIENT) {
+    return `${dbSystem}.query`
+  }
+
+  // Messaging
+  const msgSys = attributes['messaging.system']
+  const msgOp = attributes['messaging.operation']
+  if (msgSys && msgOp && kind !== INTERNAL) {
+    return `${msgSys}.${msgOp}`
+  }
+
+  // RPC (and AWS)
+  const rpcSystem = attributes['rpc.system']
+  if (rpcSystem) {
+    if (kind === CLIENT) {
+      return rpcSystem === 'aws-api'
+        ? `aws.${attributes['rpc.service'] || 'client'}.request`
+        : `${rpcSystem}.client.request`
+    }
+    if (kind === SERVER) {
+      return `${rpcSystem}.server.request`
+    }
+  }
+
+  // FaaS
+  const faasProvider = attributes['faas.invoked_provider']
+  const faasName = attributes['faas.invoked_name']
+  const faasTrigger = attributes['faas.trigger']
+  if (kind === CLIENT && faasProvider && faasName) {
+    return `${faasProvider}.${faasName}.invoke`
+  }
+  if (kind === SERVER && faasTrigger) {
+    return `${faasTrigger}.invoke`
+  }
+
+  // GraphQL
+  // NOTE: Not part of Semantic Convention spec yet, but is used in the GraphQL
+  // integration.
+  const isGraphQL = 'graphql.operation.type' in attributes
+  if (isGraphQL) return 'graphql.server.request'
+
+  // Network
+  // TODO: Doesn't exist yet. No equivalent.
+  const protocol = attributes['network.protocol.name']
+  const protocolPrefix = protocol ? `${protocol}.` : ''
+  if (kind === SERVER) return `${protocolPrefix}server.request`
+  if (kind === CLIENT) return `${protocolPrefix}client.request`
+
+  // If all else fails, default to stringified span.kind.
+  return spanKindNames[kind]
+}
+
 class Span {
   constructor (
     parentTracer,
@@ -27,7 +115,8 @@ class Span {
     spanContext,
     kind,
     links = [],
-    timeInput
+    timeInput,
+    attributes
   ) {
     const { _tracer } = tracer
 
@@ -35,7 +124,7 @@ class Span {
     const startTime = hrTimeToMilliseconds(hrStartTime)
 
     this._ddSpan = new DatadogSpan(_tracer, _tracer._processor, _tracer._prioritySampler, {
-      operationName: spanName,
+      operationName: spanNameMapper(spanName, kind, attributes),
       context: spanContext._ddContext,
       startTime,
       hostname: _tracer._hostname,
@@ -43,9 +132,14 @@ class Span {
       tags: {
         [SERVICE_NAME]: _tracer._service,
         [RESOURCE_NAME]: spanName
-      }
+      },
+      links
     }, _tracer._debug)
 
+    if (attributes) {
+      this.setAttributes(attributes)
+    }
+
     this._parentTracer = parentTracer
     this._context = context
 
@@ -55,7 +149,6 @@ class Span {
     // math for computing opentracing timestamps is apparently lossy...
     this.startTime = hrStartTime
     this.kind = kind
-    this.links = links
     this._spanProcessor.onStart(this, context)
   }
 
@@ -98,6 +191,13 @@ class Span {
     return this
   }
 
+  addLink (context, attributes) {
+    // extract dd context
+    const ddSpanContext = context._ddContext
+    this._ddSpan.addLink(ddSpanContext, attributes)
+    return this
+  }
+
   setStatus ({ code, message }) {
     if (!this.ended && !this._hasStatus && code) {
       this._hasStatus = true

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

@@ -78,23 +78,22 @@ class Tracer {
     //   return api.trace.wrapSpanContext(spanContext)
     // }
 
-    const span = new Span(
+    return new Span(
       this,
       context,
       name,
       spanContext,
       spanKind,
       links,
-      options.startTime
+      options.startTime,
+
+      // Set initial span attributes. The attributes object may have been mutated
+      // by the sampler, so we sanitize the merged attributes before setting them.
+      sanitizeAttributes(
+        // Object.assign(attributes, samplingResult.attributes)
+        attributes
+      )
     )
-    // Set initial span attributes. The attributes object may have been mutated
-    // by the sampler, so we sanitize the merged attributes before setting them.
-    const initAttributes = sanitizeAttributes(
-      // Object.assign(attributes, samplingResult.attributes)
-      attributes
-    )
-    span.setAttributes(initAttributes)
-    return span
   }
 
   startActiveSpan (name, options, context, fn) {

package/packages/dd-trace/src/opentracing/propagation/text_map.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const pick = require('lodash.pick')
+const pick = require('../../../../datadog-core/src/utils/src/pick')
 const id = require('../../id')
 const DatadogSpanContext = require('../span_context')
 const log = require('../../log')
@@ -173,7 +173,7 @@ class TextMapPropagator {
     ts.forVendor('dd', state => {
       state.set('s', priority)
       if (mechanism) {
-        state.set('t.dm', mechanism)
+        state.set('t.dm', `-${mechanism}`)
       }
 
       if (typeof origin === 'string') {
@@ -236,11 +236,20 @@ class TextMapPropagator {
   _extractDatadogContext (carrier) {
     const spanContext = this._extractGenericContext(carrier, traceKey, spanKey, 10)
 
-    if (spanContext) {
-      this._extractOrigin(carrier, spanContext)
-      this._extractBaggageItems(carrier, spanContext)
-      this._extractSamplingPriority(carrier, spanContext)
-      this._extractTags(carrier, spanContext)
+    if (!spanContext) return spanContext
+
+    this._extractOrigin(carrier, spanContext)
+    this._extractBaggageItems(carrier, spanContext)
+    this._extractSamplingPriority(carrier, spanContext)
+    this._extractTags(carrier, spanContext)
+
+    if (this._config.tracePropagationExtractFirst) return spanContext
+
+    const tc = this._extractTraceparentContext(carrier)
+
+    if (tc && spanContext._traceId.equals(tc._traceId)) {
+      spanContext._traceparent = tc._traceparent
+      spanContext._tracestate = tc._tracestate
     }
 
     return spanContext

package/packages/dd-trace/src/opentracing/span.js

@@ -12,6 +12,8 @@ const runtimeMetrics = require('../runtime_metrics')
 const log = require('../log')
 const { storage } = require('../../../datadog-core')
 const telemetryMetrics = require('../telemetry/metrics')
+const { channel } = require('dc-polyfill')
+const spanleak = require('../spanleak')
 
 const tracerMetrics = telemetryMetrics.manager.namespace('tracers')
 
@@ -24,12 +26,15 @@ const unfinishedRegistry = createRegistry('unfinished')
 const finishedRegistry = createRegistry('finished')
 
 const OTEL_ENABLED = !!process.env.DD_TRACE_OTEL_ENABLED
+const ALLOWED = ['string', 'number', 'boolean']
 
 const integrationCounters = {
-  span_created: {},
-  span_finished: {}
+  spans_created: {},
+  spans_finished: {}
 }
 
+const finishCh = channel('dd-trace:span:finish')
+
 function getIntegrationCounter (event, integration) {
   const counters = integrationCounters[event]
 
@@ -67,7 +72,7 @@ class DatadogSpan {
     this._name = operationName
     this._integrationName = fields.integrationName || 'opentracing'
 
-    getIntegrationCounter('span_created', this._integrationName).inc()
+    getIntegrationCounter('spans_created', this._integrationName).inc()
 
     this._spanContext = this._createContext(parent, fields)
     this._spanContext._name = operationName
@@ -78,6 +83,9 @@ class DatadogSpan {
 
     this._startTime = fields.startTime || this._getTime()
 
+    this._links = []
+    fields.links && fields.links.forEach(link => this.addLink(link.context, link.attributes))
+
     if (DD_TRACE_EXPERIMENTAL_SPAN_COUNTS && finishedRegistry) {
       runtimeMetrics.increment('runtime.node.spans.unfinished')
       runtimeMetrics.increment('runtime.node.spans.unfinished.by.name', `span_name:${operationName}`)
@@ -87,6 +95,7 @@ class DatadogSpan {
 
       unfinishedRegistry.register(this, operationName, this)
     }
+    spanleak.addSpan(this, operationName)
   }
 
   toString () {
@@ -145,6 +154,13 @@ class DatadogSpan {
 
   logEvent () {}
 
+  addLink (context, attributes) {
+    this._links.push({
+      context: context._ddContext ? context._ddContext : context,
+      attributes: this._sanitizeAttributes(attributes)
+    })
+  }
+
   finish (finishTime) {
     if (this._duration !== undefined) {
       return
@@ -156,7 +172,7 @@ class DatadogSpan {
       }
     }
 
-    getIntegrationCounter('span_finished', this._integrationName).inc()
+    getIntegrationCounter('spans_finished', this._integrationName).inc()
 
     if (DD_TRACE_EXPERIMENTAL_SPAN_COUNTS && finishedRegistry) {
       runtimeMetrics.decrement('runtime.node.spans.unfinished')
@@ -176,9 +192,37 @@ class DatadogSpan {
     this._duration = finishTime - this._startTime
     this._spanContext._trace.finished.push(this)
     this._spanContext._isFinished = true
+    finishCh.publish(this)
     this._processor.process(this)
   }
 
+  _sanitizeAttributes (attributes = {}) {
+    const sanitizedAttributes = {}
+
+    const addArrayOrScalarAttributes = (key, maybeArray) => {
+      if (Array.isArray(maybeArray)) {
+        for (const subkey in maybeArray) {
+          addArrayOrScalarAttributes(`${key}.${subkey}`, maybeArray[subkey])
+        }
+      } else {
+        const maybeScalar = maybeArray
+        if (ALLOWED.includes(typeof maybeScalar)) {
+          // Wrap the value as a string if it's not already a string
+          sanitizedAttributes[key] = typeof maybeScalar === 'string' ? maybeScalar : String(maybeScalar)
+        } else {
+          log.warn(`Dropping span link attribute. It is not of an allowed type`)
+        }
+      }
+    }
+
+    Object.entries(attributes).forEach(entry => {
+      const [key, value] = entry
+      addArrayOrScalarAttributes(key, value)
+    })
+
+    return sanitizedAttributes
+  }
+
   _createContext (parent, fields) {
     let spanContext
     let startTime

package/packages/dd-trace/src/opentracing/span_context.js

@@ -2,6 +2,9 @@
 
 const { AUTO_KEEP } = require('../../../../ext/priority')
 
+// the lowercase, hex encoded upper 64 bits of a 128-bit trace id, if present
+const TRACE_ID_128 = '_dd.p.tid'
+
 class DatadogSpanContext {
   constructor (props) {
     props = props || {}
@@ -25,20 +28,26 @@ class DatadogSpanContext {
     }
   }
 
-  toTraceId () {
+  toTraceId (get128bitId = false) {
+    if (get128bitId) {
+      return this._traceId.toBuffer().length <= 8 && this._trace.tags[TRACE_ID_128]
+        ? this._trace.tags[TRACE_ID_128] + this._traceId.toString(16).padStart(16, '0')
+        : this._traceId.toString(16).padStart(32, '0')
+    }
     return this._traceId.toString(10)
   }
 
-  toSpanId () {
+  toSpanId (get128bitId = false) {
+    if (get128bitId) {
+      return this._spanId.toString(16).padStart(16, '0')
+    }
     return this._spanId.toString(10)
   }
 
   toTraceparent () {
     const flags = this._sampling.priority >= AUTO_KEEP ? '01' : '00'
-    const traceId = this._traceId.toBuffer().length <= 8 && this._trace.tags['_dd.p.tid']
-      ? this._trace.tags['_dd.p.tid'] + this._traceId.toString(16).padStart(16, '0')
-      : this._traceId.toString(16).padStart(32, '0')
-    const spanId = this._spanId.toString(16).padStart(16, '0')
+    const traceId = this.toTraceId(true)
+    const spanId = this.toSpanId(true)
     const version = (this._traceparent && this._traceparent.version) || '00'
     return `${version}-${traceId}-${spanId}-${flags}`
   }

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

@@ -22,10 +22,10 @@ class DatadogTracer {
   constructor (config) {
     const Exporter = getExporter(config.experimental.exporter)
 
+    this._config = config
     this._service = config.service
     this._version = config.version
     this._env = config.env
-    this._tags = config.tags
     this._logInjection = config.logInjection
     this._debug = config.debug
     this._prioritySampler = new PrioritySampler(config.env, config.sampler)
@@ -61,10 +61,11 @@ class DatadogTracer {
       startTime: options.startTime,
       hostname: this._hostname,
       traceId128BitGenerationEnabled: this._traceId128BitGenerationEnabled,
-      integrationName: options.integrationName
+      integrationName: options.integrationName,
+      links: options.links
     }, this._debug)
 
-    span.addTags(this._tags)
+    span.addTags(this._config.tags)
     span.addTags(options.tags)
 
     return span

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const { channel } = require('../../diagnostics_channel')
+const { channel } = require('dc-polyfill')
 const { isFalse } = require('./util')
 const plugins = require('./plugins')
 const log = require('./log')