dd-trace 5.25.0 → 5.26.0

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

@@ -180,6 +180,20 @@ class DatadogSpan {
     })
   }
 
+  addSpanPointer (ptrKind, ptrDir, ptrHash) {
+    const zeroContext = new SpanContext({
+      traceId: id('0'),
+      spanId: id('0')
+    })
+    const attributes = {
+      'ptr.kind': ptrKind,
+      'ptr.dir': ptrDir,
+      'ptr.hash': ptrHash,
+      'link.kind': 'span-pointer'
+    }
+    this.addLink(zeroContext, attributes)
+  }
+
   addEvent (name, attributesOrStartTime, startTime) {
     const event = { name }
     if (attributesOrStartTime) {

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

@@ -18,6 +18,7 @@ class DatadogSpanContext {
     this._tags = props.tags || {}
     this._sampling = props.sampling || {}
     this._spanSampling = undefined
+    this._links = props.links || []
     this._baggageItems = props.baggageItems || {}
     this._traceparent = props.traceparent
     this._tracestate = props.tracestate

package/packages/dd-trace/src/plugins/tracing.js

@@ -101,9 +101,8 @@ class TracingPlugin extends Plugin {
     }
   }
 
-  startSpan (name, { childOf, kind, meta, metrics, service, resource, type } = {}, enter = true) {
+  startSpan (name, { childOf, kind, meta, metrics, service, resource, type, extractedLinks } = {}, enter = true) {
     const store = storage.getStore()
-
     if (store && childOf === undefined) {
       childOf = store.span
     }
@@ -119,7 +118,8 @@ class TracingPlugin extends Plugin {
         ...meta,
         ...metrics
       },
-      integrationName: type
+      integrationName: type,
+      links: extractedLinks
     })
 
     analyticsSampler.sample(span, this.config.measured)

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

@@ -0,0 +1,121 @@
+const log = require('../../log')
+const tags = require('../../../../../ext/tags')
+
+const RESOURCE_NAME = tags.RESOURCE_NAME
+const HTTP_ROUTE = tags.HTTP_ROUTE
+const SPAN_KIND = tags.SPAN_KIND
+const SPAN_TYPE = tags.SPAN_TYPE
+const HTTP_URL = tags.HTTP_URL
+const HTTP_METHOD = tags.HTTP_METHOD
+
+const PROXY_HEADER_SYSTEM = 'x-dd-proxy'
+const PROXY_HEADER_START_TIME_MS = 'x-dd-proxy-request-time-ms'
+const PROXY_HEADER_PATH = 'x-dd-proxy-path'
+const PROXY_HEADER_HTTPMETHOD = 'x-dd-proxy-httpmethod'
+const PROXY_HEADER_DOMAIN = 'x-dd-proxy-domain-name'
+const PROXY_HEADER_STAGE = 'x-dd-proxy-stage'
+
+const supportedProxies = {
+  'aws-apigateway': {
+    spanName: 'aws.apigateway',
+    component: 'aws-apigateway'
+  }
+}
+
+function createInferredProxySpan (headers, childOf, tracer, context) {
+  if (!headers) {
+    return null
+  }
+
+  if (!tracer._config?.inferredProxyServicesEnabled) {
+    return null
+  }
+
+  const proxyContext = extractInferredProxyContext(headers)
+
+  if (!proxyContext) {
+    return null
+  }
+
+  const proxySpanInfo = supportedProxies[proxyContext.proxySystemName]
+
+  log.debug(`Successfully extracted inferred span info ${proxyContext} for proxy: ${proxyContext.proxySystemName}`)
+
+  const span = tracer.startSpan(
+    proxySpanInfo.spanName,
+    {
+      childOf,
+      type: 'web',
+      startTime: proxyContext.requestTime,
+      tags: {
+        service: proxyContext.domainName || tracer._config.service,
+        component: proxySpanInfo.component,
+        [SPAN_KIND]: 'internal',
+        [SPAN_TYPE]: 'web',
+        [HTTP_METHOD]: proxyContext.method,
+        [HTTP_URL]: proxyContext.domainName + proxyContext.path,
+        [HTTP_ROUTE]: proxyContext.path,
+        stage: proxyContext.stage
+      }
+    }
+  )
+
+  tracer.scope().activate(span)
+  context.inferredProxySpan = span
+  childOf = span
+
+  log.debug('Successfully created inferred proxy span.')
+
+  setInferredProxySpanTags(span, proxyContext)
+
+  return childOf
+}
+
+function setInferredProxySpanTags (span, proxyContext) {
+  span.setTag(RESOURCE_NAME, `${proxyContext.method} ${proxyContext.path}`)
+  span.setTag('_dd.inferred_span', '1')
+  return span
+}
+
+function extractInferredProxyContext (headers) {
+  if (!(PROXY_HEADER_START_TIME_MS in headers)) {
+    return null
+  }
+
+  if (!(PROXY_HEADER_SYSTEM in headers && headers[PROXY_HEADER_SYSTEM] in supportedProxies)) {
+    log.debug(`Received headers to create inferred proxy span but headers include an unsupported proxy type ${headers}`)
+    return null
+  }
+
+  return {
+    requestTime: headers[PROXY_HEADER_START_TIME_MS]
+      ? parseInt(headers[PROXY_HEADER_START_TIME_MS], 10)
+      : null,
+    method: headers[PROXY_HEADER_HTTPMETHOD],
+    path: headers[PROXY_HEADER_PATH],
+    stage: headers[PROXY_HEADER_STAGE],
+    domainName: headers[PROXY_HEADER_DOMAIN],
+    proxySystemName: headers[PROXY_HEADER_SYSTEM]
+  }
+}
+
+function finishInferredProxySpan (context) {
+  const { req } = context
+
+  if (!context.inferredProxySpan) return
+
+  if (context.inferredProxySpanFinished && !req.stream) return
+
+  // context.config.hooks.request(context.inferredProxySpan, req, res) # TODO: Do we need this??
+
+  // Only close the inferred span if one was created
+  if (context.inferredProxySpan) {
+    context.inferredProxySpan.finish()
+    context.inferredProxySpanFinished = true
+  }
+}
+
+module.exports = {
+  createInferredProxySpan,
+  finishInferredProxySpan
+}

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

@@ -8,7 +8,6 @@ const ipHeaderList = [
   'x-real-ip',
   'true-client-ip',
   'x-client-ip',
-  'x-forwarded',
   'forwarded-for',
   'x-cluster-client-ip',
   'fastly-client-ip',

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

@@ -10,6 +10,7 @@ const kinds = require('../../../../../ext/kinds')
 const urlFilter = require('./urlfilter')
 const { extractIp } = require('./ip_extractor')
 const { ERROR_MESSAGE, ERROR_TYPE, ERROR_STACK } = require('../../constants')
+const { createInferredProxySpan, finishInferredProxySpan } = require('./inferred_proxy')
 
 const WEB = types.WEB
 const SERVER = kinds.SERVER
@@ -97,7 +98,7 @@ const web = {
       context.span.context()._name = name
       span = context.span
     } else {
-      span = web.startChildSpan(tracer, name, req.headers)
+      span = web.startChildSpan(tracer, name, req)
     }
 
     context.tracer = tracer
@@ -253,9 +254,20 @@ const web = {
   },
 
   // Extract the parent span from the headers and start a new span as its child
-  startChildSpan (tracer, name, headers) {
-    const childOf = tracer.extract(FORMAT_HTTP_HEADERS, headers)
-    const span = tracer.startSpan(name, { childOf })
+  startChildSpan (tracer, name, req) {
+    const headers = req.headers
+    const context = contexts.get(req)
+    let childOf = tracer.extract(FORMAT_HTTP_HEADERS, headers)
+
+    // we may have headers signaling a router proxy span should be created (such as for AWS API Gateway)
+    if (tracer._config?.inferredProxyServicesEnabled) {
+      const proxySpan = createInferredProxySpan(headers, childOf, tracer, context)
+      if (proxySpan) {
+        childOf = proxySpan
+      }
+    }
+
+    const span = tracer.startSpan(name, { childOf, extractedLinks: childOf?.links })
 
     return span
   },
@@ -263,13 +275,21 @@ const web = {
   // Validate a request's status code and then add error tags if necessary
   addStatusError (req, statusCode) {
     const context = contexts.get(req)
-    const span = context.span
-    const error = context.error
-    const hasExistingError = span.context()._tags.error || span.context()._tags[ERROR_MESSAGE]
+    const { span, inferredProxySpan, error } = context
 
-    if (!hasExistingError && !context.config.validateStatus(statusCode)) {
+    const spanHasExistingError = span.context()._tags.error || span.context()._tags[ERROR_MESSAGE]
+    const inferredSpanContext = inferredProxySpan?.context()
+    const inferredSpanHasExistingError = inferredSpanContext?._tags.error || inferredSpanContext?._tags[ERROR_MESSAGE]
+
+    const isValidStatusCode = context.config.validateStatus(statusCode)
+
+    if (!spanHasExistingError && !isValidStatusCode) {
       span.setTag(ERROR, error || true)
     }
+
+    if (inferredProxySpan && !inferredSpanHasExistingError && !isValidStatusCode) {
+      inferredProxySpan.setTag(ERROR, error || true)
+    }
   },
 
   // Add an error to the request
@@ -316,6 +336,8 @@ const web = {
     web.finishMiddleware(context)
 
     web.finishSpan(context)
+
+    finishInferredProxySpan(context)
   },
 
   obfuscateQs (config, url) {
@@ -426,7 +448,7 @@ function reactivate (req, fn) {
 }
 
 function addRequestTags (context, spanType) {
-  const { req, span, config } = context
+  const { req, span, inferredProxySpan, config } = context
   const url = extractURL(req)
 
   span.addTags({
@@ -443,6 +465,7 @@ function addRequestTags (context, spanType) {
 
     if (clientIp) {
       span.setTag(HTTP_CLIENT_IP, clientIp)
+      inferredProxySpan?.setTag(HTTP_CLIENT_IP, clientIp)
     }
   }
 
@@ -450,7 +473,7 @@ function addRequestTags (context, spanType) {
 }
 
 function addResponseTags (context) {
-  const { req, res, paths, span } = context
+  const { req, res, paths, span, inferredProxySpan } = context
 
   if (paths.length > 0) {
     span.setTag(HTTP_ROUTE, paths.join(''))
@@ -459,6 +482,9 @@ function addResponseTags (context) {
   span.addTags({
     [HTTP_STATUS_CODE]: res.statusCode
   })
+  inferredProxySpan?.addTags({
+    [HTTP_STATUS_CODE]: res.statusCode
+  })
 
   web.addStatusError(req, res.statusCode)
 }
@@ -477,7 +503,7 @@ function addResourceTag (context) {
 }
 
 function addHeaders (context) {
-  const { req, res, config, span } = context
+  const { req, res, config, span, inferredProxySpan } = context
 
   config.headers.forEach(([key, tag]) => {
     const reqHeader = req.headers[key]
@@ -485,10 +511,12 @@ function addHeaders (context) {
 
     if (reqHeader) {
       span.setTag(tag || `${HTTP_REQUEST_HEADERS}.${key}`, reqHeader)
+      inferredProxySpan?.setTag(tag || `${HTTP_REQUEST_HEADERS}.${key}`, reqHeader)
     }
 
     if (resHeader) {
       span.setTag(tag || `${HTTP_RESPONSE_HEADERS}.${key}`, resHeader)
+      inferredProxySpan?.setTag(tag || `${HTTP_RESPONSE_HEADERS}.${key}`, resHeader)
     }
   })
 }

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

@@ -59,6 +59,11 @@ class Tracer extends NoopProxy {
 
     try {
       const config = new Config(options) // TODO: support dynamic code config
+
+      if (config.crashtracking.enabled) {
+        require('./crashtracking').start(config)
+      }
+
       telemetry.start(config, this._pluginManager)
 
       if (config.dogstatsd) {

package/packages/dd-trace/src/telemetry/logs/index.js

@@ -35,18 +35,23 @@ function onLog (log) {
 }
 
 function onErrorLog (msg) {
-  if (msg instanceof Error) {
-    onLog({
-      level: 'ERROR',
-      message: msg.message,
-      stack_trace: msg.stack
-    })
-  } else if (typeof msg === 'string') {
-    onLog({
-      level: 'ERROR',
-      message: msg
-    })
+  const { message, cause } = msg
+  if (!message && !cause) return
+
+  const telLog = {
+    level: 'ERROR',
+
+    // existing log.error(err) without message will be reported as 'Generic Error'
+    message: message ?? 'Generic Error'
   }
+
+  if (cause) {
+    telLog.stack_trace = cause.stack
+    const errorType = cause.name ?? 'Error'
+    telLog.message = `${errorType}: ${telLog.message}`
+  }
+
+  onLog(telLog)
 }
 
 function start (config) {

package/packages/dd-trace/src/telemetry/logs/log-collector.js

@@ -48,16 +48,11 @@ function sanitize (logEntry) {
     .map(line => line.replace(ddBasePath, ''))
 
   logEntry.stack_trace = stackLines.join(EOL)
-  if (logEntry.stack_trace === '') {
-    // If entire stack was removed, we'd just have a message saying "omitted"
-    // in which case we'd rather not log it at all.
+  if (logEntry.stack_trace === '' && !logEntry.message) {
+    // If entire stack was removed and there is no message we'd rather not log it at all.
     return null
   }
 
-  if (!isDDCode) {
-    logEntry.message = 'omitted'
-  }
-
   return logEntry
 }
 
@@ -82,7 +77,7 @@ const logCollector = {
         return true
       }
     } catch (e) {
-      log.error(`Unable to add log to logCollector: ${e.message}`)
+      log.error('Unable to add log to logCollector: %s', e.message)
     }
     return false
   },

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

@@ -27,13 +27,18 @@ function hasPoints (metric) {
   return metric.points.length > 0
 }
 
+let versionTag
+
 class Metric {
   constructor (namespace, metric, common, tags) {
     this.namespace = namespace.toString()
     this.metric = common ? metric : `nodejs.${metric}`
     this.tags = tagArray(tags)
     if (common) {
-      this.tags.push(`version:${process.version}`)
+      if (versionTag === undefined) {
+        versionTag = `version:${process.version}`
+      }
+      this.tags.push(versionTag)
     }
     this.common = common
 

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

@@ -1,5 +1,6 @@
 'use strict'
 
+const crypto = require('crypto')
 const path = require('path')
 
 function isTrue (str) {
@@ -73,11 +74,25 @@ function hasOwn (object, prop) {
   return Object.prototype.hasOwnProperty.call(object, prop)
 }
 
+/**
+ * Generates a unique hash from an array of strings by joining them with | before hashing.
+ * Used to uniquely identify AWS requests for span pointers.
+ * @param {string[]} components - Array of strings to hash
+ * @returns {string} A 32-character hash uniquely identifying the components
+ */
+function generatePointerHash (components) {
+  // If passing S3's ETag as a component, make sure any quotes have already been removed!
+  const dataToHash = components.join('|')
+  const hash = crypto.createHash('sha256').update(dataToHash).digest('hex')
+  return hash.substring(0, 32)
+}
+
 module.exports = {
   isTrue,
   isFalse,
   isError,
   globMatch,
   calculateDDBasePath,
-  hasOwn
+  hasOwn,
+  generatePointerHash
 }

package/version.js

@@ -1,7 +1,9 @@
 'use strict'
 
-const ddMatches = require('./package.json').version.match(/^(\d+)\.(\d+)\.(\d+)/)
-const nodeMatches = process.versions.node.match(/^(\d+)\.(\d+)\.(\d+)/)
+/* eslint-disable no-var */
+
+var ddMatches = require('./package.json').version.match(/^(\d+)\.(\d+)\.(\d+)/)
+var nodeMatches = process.versions.node.match(/^(\d+)\.(\d+)\.(\d+)/)
 
 module.exports = {
   DD_MAJOR: parseInt(ddMatches[1]),