dd-trace 5.86.0 → 5.87.0

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

@@ -7,71 +7,57 @@ class DatabasePlugin extends StoragePlugin {
   static operation = 'query'
   static peerServicePrecursors = ['db.name']
 
-  constructor (...args) {
-    super(...args)
-    this.serviceTags = {
-      dddbs: '',
-      encodedDddbs: '',
-      dde: '',
-      encodedDde: '',
-      ddps: '',
-      encodedDdps: '',
-      ddpv: '',
-      encodedDdpv: '',
-    }
-  }
-
-  encodingServiceTags (serviceTag, encodeATag, spanConfig) {
-    if (serviceTag !== spanConfig) {
-      this.serviceTags[serviceTag] = spanConfig
-      this.serviceTags[encodeATag] = encodeURIComponent(spanConfig)
-    }
-  }
-
-  createDBMPropagationCommentService (serviceName, span) {
-    this.encodingServiceTags('dddbs', 'encodedDddbs', serviceName)
-    this.encodingServiceTags('dde', 'encodedDde', this.tracer._env)
-    this.encodingServiceTags('ddps', 'encodedDdps', this.tracer._service)
-    this.encodingServiceTags('ddpv', 'encodedDdpv', this.tracer._version)
-    if (span.context()._tags['out.host']) {
-      this.encodingServiceTags('ddh', 'encodedDdh', span._spanContext._tags['out.host'])
-    }
-    if (span.context()._tags['db.name']) {
-      this.encodingServiceTags('dddb', 'encodedDddb', span._spanContext._tags['db.name'])
-    }
-
-    const { encodedDddb, encodedDddbs, encodedDde, encodedDdh, encodedDdps, encodedDdpv } = this.serviceTags
+  /**
+   * @param {string} serviceName
+   * @param {import('../../../..').Span} span
+   * @param {object} peerData
+   * @returns {string}
+   */
+  #createDBMPropagationCommentService (serviceName, span, peerData) {
+    const spanTags = span.context()._tags
+    const encodedDddb = encode(spanTags['db.name'])
+    const encodedDddbs = encode(serviceName)
+    const encodedDde = encode(this.tracer._env)
+    const encodedDdh = encode(spanTags['out.host'])
+    const encodedDdps = this.tracer._service ?? ''
+    const encodedDdpv = this.tracer._version
 
     let dbmComment = `dddb='${encodedDddb}',dddbs='${encodedDddbs}',dde='${encodedDde}',ddh='${encodedDdh}',` +
       `ddps='${encodedDdps}',ddpv='${encodedDdpv}'`
 
-    const peerData = this.getPeerService(span.context()._tags)
     if (peerData !== undefined && peerData[PEER_SERVICE_SOURCE_KEY] === PEER_SERVICE_KEY) {
-      this.encodingServiceTags('ddprs', 'encodedDdprs', peerData[PEER_SERVICE_KEY])
-
-      const { encodedDdprs } = this.serviceTags
-      dbmComment += `,ddprs='${encodedDdprs}'`
+      dbmComment += `,ddprs='${encode(peerData[PEER_SERVICE_KEY])}'`
     }
     return dbmComment
   }
 
-  getDbmServiceName (span, tracerService) {
+  /**
+   * @param {string} tracerService
+   * @param {object} peerData
+   * @returns {string}
+   */
+  #getDbmServiceName (tracerService, peerData) {
     if (this._tracerConfig.spanComputePeerService) {
-      const peerData = this.getPeerService(span.context()._tags)
       return this.getPeerServiceRemap(peerData)[PEER_SERVICE_KEY] || tracerService
     }
     return tracerService
   }
 
+  /**
+   * @param {import('../../../..').Span} span
+   * @param {string} serviceName
+   * @param {boolean} disableFullMode
+   */
   createDbmComment (span, serviceName, disableFullMode = false) {
     const mode = this.config.dbmPropagationMode
-    const dbmService = this.getDbmServiceName(span, serviceName)
 
     if (mode === 'disabled') {
       return null
     }
 
-    const servicePropagation = this.createDBMPropagationCommentService(dbmService, span)
+    const peerData = this.getPeerService(span.context()._tags)
+    const dbmService = this.#getDbmServiceName(serviceName, peerData)
+    const servicePropagation = this.#createDBMPropagationCommentService(dbmService, span, peerData)
 
     if (disableFullMode || mode === 'service') {
       return servicePropagation
@@ -83,6 +69,13 @@ class DatabasePlugin extends StoragePlugin {
     }
   }
 
+  /**
+   * @param {import('../../../..').Span} span
+   * @param {string} query
+   * @param {string} serviceName
+   * @param {boolean} disableFullMode
+   * @returns {string}
+   */
   injectDbmQuery (span, query, serviceName, disableFullMode = false) {
     const dbmTraceComment = this.createDbmComment(span, serviceName, disableFullMode)
 
@@ -95,6 +88,10 @@ class DatabasePlugin extends StoragePlugin {
       : `/*${dbmTraceComment}*/ ${query}`
   }
 
+  /**
+   * @param {string} query
+   * @returns {string}
+   */
   maybeTruncate (query) {
     const maxLength = typeof this.config.truncate === 'number'
       ? this.config.truncate
@@ -108,4 +105,6 @@ class DatabasePlugin extends StoragePlugin {
   }
 }
 
+const encode = value => value ? encodeURIComponent(value) : ''
+
 module.exports = DatabasePlugin

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

@@ -18,6 +18,10 @@ const COMMON_PEER_SVC_SOURCE_TAGS = [
 
 // TODO: Exit span on finish when AsyncResource instances are removed.
 class OutboundPlugin extends TracingPlugin {
+  /**
+   *
+   * @type {string[]}
+   */
   static peerServicePrecursors = []
 
   constructor (...args) {
@@ -28,12 +32,15 @@ class OutboundPlugin extends TracingPlugin {
     })
   }
 
+  /**
+   * @param {{ parentStore?: { span: import('../../../..').Span } }} ctx
+   */
   bindFinish (ctx) {
     return ctx.parentStore
   }
 
-  startSpan (...args) {
-    const span = super.startSpan(...args)
+  startSpan (name, options, enterOrCtx) {
+    const span = super.startSpan(name, options, enterOrCtx)
     if (
       this._tracerConfig.codeOriginForSpans.enabled &&
       this._tracerConfig.codeOriginForSpans.experimental.exit_spans.enabled
@@ -43,6 +50,9 @@ class OutboundPlugin extends TracingPlugin {
     return span
   }
 
+  /**
+   * @param {Record<string, string>} tags
+   */
   getPeerService (tags) {
     /**
      * Compute `peer.service` and associated metadata from available tags, based
@@ -75,6 +85,9 @@ class OutboundPlugin extends TracingPlugin {
     }
   }
 
+  /**
+   * @param {Record<string, string>} peerData
+   */
   getPeerServiceRemap (peerData) {
     /**
      * If DD_TRACE_PEER_SERVICE_MAPPING is matched, we need to override the existing
@@ -92,6 +105,9 @@ class OutboundPlugin extends TracingPlugin {
     return peerData
   }
 
+  /**
+   * @param {{ currentStore?: { span: import('../../../..').Span } }} ctx
+   */
   finish (ctx) {
     const span = ctx?.currentStore?.span || this.activeSpan
     this.tagPeerService(span)
@@ -104,6 +120,9 @@ class OutboundPlugin extends TracingPlugin {
     super.finish(...arguments)
   }
 
+  /**
+   * @param {import('../../../..').Span} span
+   */
   tagPeerService (span) {
     if (this._tracerConfig.spanComputePeerService) {
       const peerData = this.getPeerService(span.context()._tags)
@@ -113,10 +132,16 @@ class OutboundPlugin extends TracingPlugin {
     }
   }
 
+  /**
+   * @param {object} ctx
+   */
   connect (ctx) {
     this.addHost(ctx)
   }
 
+  /**
+   * @param {{ hostname: string, port: number, currentStore?: { span: import('../../../..').Span } }} ctx
+   */
   addHost (ctx) {
     const { hostname, port } = ctx
 

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

@@ -16,11 +16,18 @@ class TracingPlugin extends Plugin {
   }
 
   get activeSpan () {
-    const store = storage('legacy').getStore()
+    const store = /** @type {{ span?: import('../../../..').Span }} */ (storage('legacy').getStore())
 
-    return store && store.span
+    return store?.span
   }
 
+  /**
+   * @param {object} opts
+   * @param {string} [opts.type]
+   * @param {string} [opts.id]
+   * @param {string} [opts.kind]
+   * @returns {string}
+   */
   serviceName (opts = {}) {
     const {
       type = this.constructor.type,
@@ -31,6 +38,13 @@ class TracingPlugin extends Plugin {
     return this._tracer._nomenclature.serviceName(type, kind, id, opts)
   }
 
+  /**
+   * @param {object} opts
+   * @param {string} [opts.type]
+   * @param {string} [opts.id]
+   * @param {string} [opts.kind]
+   * @returns {string}
+   */
   operationName (opts = {}) {
     const {
       type = this.constructor.type,
@@ -41,6 +55,10 @@ class TracingPlugin extends Plugin {
     return this._tracer._nomenclature.opName(type, kind, id, opts)
   }
 
+  /**
+   * @param {object} config
+   * @returns {object}
+   */
   configure (config) {
     return super.configure({
       ...config,
@@ -53,11 +71,17 @@ class TracingPlugin extends Plugin {
 
   start () {} // implemented by individual plugins
 
+  /**
+   * @param {{ currentStore?: { span: import('../../../..').Span } }} ctx
+   */
   finish (ctx) {
     const span = ctx?.currentStore?.span || this.activeSpan
     span?.finish()
   }
 
+  /**
+   * @param {{ currentStore?: { span: import('../../../..').Span }, error?: unknown }} ctxOrError
+   */
   error (ctxOrError) {
     if (ctxOrError?.currentStore) {
       ctxOrError.currentStore?.span.setTag('error', ctxOrError?.error)
@@ -84,21 +108,32 @@ class TracingPlugin extends Plugin {
     }
   }
 
+  /**
+   * @param {string} eventName
+   * @param {Function} handler
+   */
   addTraceSub (eventName, handler) {
     const prefix = this.constructor.prefix || `apm:${this.component}:${this.operation}`
     this.addSub(`${prefix}:${eventName}`, handler)
   }
 
+  /**
+   * @param {string} eventName
+   * @param {Function} transform
+   */
   addTraceBind (eventName, transform) {
     const prefix = this.constructor.prefix || `apm:${this.component}:${this.operation}`
     this.addBind(`${prefix}:${eventName}`, transform)
   }
 
+  /**
+   * @param {unknown} error
+   * @param {import('../../../..').Span} [span]
+   */
   addError (error, span = this.activeSpan) {
     if (span && !span._spanContext._tags.error) {
       // Errors may be wrapped in a context.
-      error = (error && error.error) || error
-      span.setTag('error', error || 1)
+      span.setTag('error', error?.error || error || 1)
     }
   }
 

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

@@ -14,12 +14,17 @@ 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 PROXY_HEADER_REGION = 'x-dd-proxy-region'
 
 const supportedProxies = {
   'aws-apigateway': {
     spanName: 'aws.apigateway',
     component: 'aws-apigateway',
   },
+  'azure-apim': {
+    spanName: 'azure.apim',
+    component: 'azure-apim',
+  },
 }
 
 function createInferredProxySpan (headers, childOf, tracer, reqCtx, traceCtx, config, startSpanHelper) {
@@ -53,6 +58,7 @@ function createInferredProxySpan (headers, childOf, tracer, reqCtx, traceCtx, co
       [HTTP_METHOD]: proxyContext.method,
       [HTTP_URL]: proxyContext.domainName + proxyContext.path,
       stage: proxyContext.stage,
+      region: proxyContext.region,
     },
   }, traceCtx, config)
 
@@ -91,6 +97,7 @@ function extractInferredProxyContext (headers) {
     stage: headers[PROXY_HEADER_STAGE],
     domainName: headers[PROXY_HEADER_DOMAIN],
     proxySystemName: headers[PROXY_HEADER_SYSTEM],
+    region: headers[PROXY_HEADER_REGION],
   }
 }
 

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

@@ -119,7 +119,7 @@ const web = {
       context.span.context()._name = name
       span = context.span
     } else {
-      span = web.startChildSpan(tracer, config, name, req, traceCtx)
+      span = web.startServerlessSpanWithInferredProxy(tracer, config, name, req, traceCtx)
     }
 
     context.tracer = tracer
@@ -275,7 +275,7 @@ const web = {
     return context.middleware.at(-1)
   },
 
-  startChildSpan (tracer, config, name, req, traceCtx) {
+  startServerlessSpanWithInferredProxy (tracer, config, name, req, traceCtx) {
     const headers = req.headers
     const reqCtx = contexts.get(req)
     const { storage } = require('../../../../datadog-core')
@@ -338,12 +338,12 @@ const web = {
     }
   },
 
-  finishSpan (context) {
+  finishSpan (context, spanType) {
     const { req, res } = context
 
     if (context.finished && !req.stream) return
 
-    addRequestTags(context, this.TYPE)
+    addRequestTags(context, spanType)
     addResponseTags(context)
 
     context.config.hooks.request(context.span, req, res)
@@ -353,14 +353,14 @@ const web = {
     context.finished = true
   },
 
-  finishAll (context) {
+  finishAll (context, spanType) {
     for (const beforeEnd of context.beforeEnd) {
       beforeEnd()
     }
 
     web.finishMiddleware(context)
 
-    web.finishSpan(context)
+    web.finishSpan(context, spanType)
 
     finishInferredProxySpan(context)
   },
@@ -457,12 +457,13 @@ function reactivate (req, fn) {
 function addRequestTags (context, spanType) {
   const { req, span, inferredProxySpan, config } = context
   const url = extractURL(req)
+  const type = spanType ?? WEB
 
   span.addTags({
     [HTTP_URL]: obfuscateQs(config, url),
     [HTTP_METHOD]: req.method,
     [SPAN_KIND]: SERVER,
-    [SPAN_TYPE]: spanType,
+    [SPAN_TYPE]: type,
     [HTTP_USERAGENT]: req.headers['user-agent'],
   })
 

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

@@ -4,7 +4,7 @@ const os = require('os')
 const { inspect } = require('util')
 const tracerVersion = require('../../../package.json').version
 const { getAgentUrl } = require('./agent/url')
-const { info, warn } = require('./log/writer')
+const { warn } = require('./log/writer')
 
 const errors = {}
 let config
@@ -29,7 +29,7 @@ function startupLog (agentError) {
     out.agent_error = agentError.message
   }
 
-  info('DATADOG TRACER CONFIGURATION - ' + out)
+  warn('DATADOG TRACER CONFIGURATION - ' + out)
   if (agentError) {
     warn('DATADOG TRACER DIAGNOSTIC - Agent Error: ' + agentError.message)
     errors.agentError = {

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

@@ -1,8 +0,0 @@
-'use strict'
-
-const types = require('../../../../../ext/types')
-const web = require('./web')
-
-const serverless = { ...web, TYPE: types.SERVERLESS }
-
-module.exports = serverless