@depup/dd-trace 5.90.0-depup.0

package/packages/datadog-plugin-graphql/src/validate.js

@@ -0,0 +1,40 @@
+'use strict'
+
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+const { extractErrorIntoSpanEvent } = require('./utils')
+
+class GraphQLValidatePlugin extends TracingPlugin {
+  static id = 'graphql'
+  static operation = 'validate'
+
+  bindStart (ctx) {
+    const { docSource, document } = ctx
+    const source = this.config.source && document && docSource
+
+    this.startSpan('graphql.validate', {
+      service: this.config.service,
+      type: 'graphql',
+      meta: {
+        'graphql.source': source,
+      },
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  finish (ctx) {
+    const { document, errors } = ctx
+    const span = ctx?.currentStore?.span || this.activeSpan
+    this.config.hooks.validate(span, document, errors)
+    if (errors) {
+      for (const err of errors) {
+        extractErrorIntoSpanEvent(this._tracerConfig, span, err)
+      }
+    }
+    super.finish(ctx)
+
+    return ctx.parentStore
+  }
+}
+
+module.exports = GraphQLValidatePlugin

package/packages/datadog-plugin-grpc/src/client.js

@@ -0,0 +1,129 @@
+'use strict'
+
+const { storage } = require('../../datadog-core')
+const ClientPlugin = require('../../dd-trace/src/plugins/client')
+const { TEXT_MAP } = require('../../../ext/formats')
+const { addMetadataTags, getFilter, getMethodMetadata } = require('./util')
+
+class GrpcClientPlugin extends ClientPlugin {
+  static id = 'grpc'
+  static operation = 'client:request'
+  static prefix = 'apm:grpc:client:request'
+  static peerServicePrecursors = ['rpc.service']
+
+  constructor (...args) {
+    super(...args)
+
+    this.addTraceBind('emit', ({ parentStore }) => {
+      return parentStore
+    })
+  }
+
+  bindStart (message) {
+    const store = storage('legacy').getStore()
+    const { metadata, path, type } = message
+    const metadataFilter = this.config.metadataFilter
+    const method = getMethodMetadata(path, type)
+    const span = this.startSpan(this.operationName(), {
+      service: this.config.service || this.serviceName(),
+      resource: path,
+      kind: 'client',
+      type: 'http',
+      meta: {
+        component: 'grpc',
+        'grpc.method.kind': method.kind,
+        'grpc.method.path': method.path,
+        'grpc.method.name': method.name,
+        'grpc.method.service': method.service,
+        'grpc.method.package': method.package,
+      },
+      metrics: {
+        'grpc.status.code': 0,
+      },
+    }, false)
+    // needed as precursor for peer.service
+    if (method.service && method.package) {
+      span.setTag('rpc.service', method.package + '.' + method.service)
+    }
+
+    if (metadata) {
+      addMetadataTags(span, metadata, metadataFilter, 'request')
+      inject(this.tracer, span, metadata)
+    }
+
+    message.span = span
+    message.parentStore = store
+    message.currentStore = { ...store, span }
+
+    return message.currentStore
+  }
+
+  bindAsyncStart ({ parentStore }) {
+    return parentStore
+  }
+
+  error ({ span = this.activeSpan, error }) {
+    this.addCode(span, error.code)
+    if (error.code && !this._tracerConfig.grpc.client.error.statuses.includes(error.code)) {
+      return
+    }
+    this.addError(error, span)
+  }
+
+  finish ({ span, result, peer }) {
+    if (!span) return
+
+    const { code, metadata } = result || {}
+    const metadataFilter = this.config.metadataFilter
+
+    this.addCode(span, code)
+
+    if (metadata && metadataFilter) {
+      addMetadataTags(span, metadata, metadataFilter, 'response')
+    }
+
+    if (peer) {
+      // The only scheme we want to support here is ipv[46]:port, although
+      // more are supported by the library
+      // https://github.com/grpc/grpc/blob/v1.60.0/doc/naming.md
+      const parts = peer.split(':')
+      if (/^\d+/.test(parts.at(-1))) {
+        const port = parts.at(-1)
+        const ip = parts.slice(0, -1).join(':')
+        span.setTag('network.destination.ip', ip)
+        span.setTag('network.destination.port', port)
+      } else {
+        span.setTag('network.destination.ip', peer)
+      }
+    }
+
+    this.tagPeerService(span)
+    span.finish()
+  }
+
+  configure (config) {
+    const metadataFilter = getFilter(config, 'metadata')
+
+    return super.configure({ ...config, metadataFilter })
+  }
+
+  addCode (span, code) {
+    if (code !== undefined && span) {
+      span.setTag('grpc.status.code', code)
+    }
+  }
+}
+
+function inject (tracer, span, metadata) {
+  if (typeof metadata.set !== 'function') return
+
+  const carrier = {}
+
+  tracer.inject(span, TEXT_MAP, carrier)
+
+  for (const key in carrier) {
+    metadata.set(key, carrier[key])
+  }
+}
+
+module.exports = GrpcClientPlugin

package/packages/datadog-plugin-grpc/src/index.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+const GrpcServerPlugin = require('./server')
+const GrpcClientPlugin = require('./client')
+
+class GrpcPlugin extends CompositePlugin {
+  static id = 'grpc'
+  static get plugins () {
+    return {
+      server: GrpcServerPlugin,
+      client: GrpcClientPlugin,
+    }
+  }
+}
+
+module.exports = GrpcPlugin

package/packages/datadog-plugin-grpc/src/server.js

@@ -0,0 +1,112 @@
+'use strict'
+
+const { storage } = require('../../datadog-core')
+const ServerPlugin = require('../../dd-trace/src/plugins/server')
+const { TEXT_MAP } = require('../../../ext/formats')
+const { addMetadataTags, getFilter, getMethodMetadata } = require('./util')
+
+class GrpcServerPlugin extends ServerPlugin {
+  static id = 'grpc'
+  static operation = 'server:request'
+  static prefix = 'apm:grpc:server:request'
+
+  constructor (...args) {
+    super(...args)
+
+    this.addTraceSub('update', ({ code }) => {
+      const span = this.activeSpan
+
+      if (!span) return
+
+      this.addCode(span, code)
+    })
+
+    this.addTraceBind('emit', ({ currentStore }) => {
+      return currentStore
+    })
+  }
+
+  bindStart (message) {
+    const store = storage('legacy').getStore()
+    const { name, metadata, type } = message
+    const metadataFilter = this.config.metadataFilter
+    const childOf = extract(this.tracer, metadata)
+    const method = getMethodMetadata(name, type)
+    const span = this.startSpan(this.operationName(), {
+      childOf,
+      service: this.config.service || this.serviceName(),
+      resource: name,
+      kind: 'server',
+      type: 'web',
+      meta: {
+        component: 'grpc',
+        'grpc.method.kind': method.kind,
+        'grpc.method.path': method.path,
+        'grpc.method.name': method.name,
+        'grpc.method.service': method.service,
+        'grpc.method.package': method.package,
+      },
+      metrics: {
+        'grpc.status.code': 0,
+      },
+    })
+
+    addMetadataTags(span, metadata, metadataFilter, 'request')
+
+    message.span = span
+    message.parentStore = store
+    message.currentStore = { ...store, span }
+
+    return message.currentStore
+  }
+
+  bindAsyncStart ({ parentStore }) {
+    return parentStore
+  }
+
+  error ({ error }) {
+    const span = this.activeSpan
+
+    if (!span) return
+
+    this.addCode(span, error.code)
+    if (error.code && !this._tracerConfig.grpc.server.error.statuses.includes(error.code)) {
+      return
+    }
+    this.addError(error)
+  }
+
+  finish ({ span, code, trailer }) {
+    if (!span) return
+
+    const metadataFilter = this.config.metadataFilter
+
+    this.addCode(span, code)
+
+    if (trailer && metadataFilter) {
+      addMetadataTags(span, trailer, metadataFilter, 'response')
+    }
+
+    span.finish()
+  }
+
+  configure (config) {
+    const metadataFilter = getFilter(config, 'metadata')
+
+    return super.configure({ ...config, metadataFilter })
+  }
+
+  addCode (span, code) {
+    if (code !== undefined) {
+      span.setTag('grpc.status.code', code)
+    }
+  }
+}
+
+function extract (tracer, metadata) {
+  if (!metadata || typeof metadata.getMap !== 'function') return null
+
+  return tracer.extract(TEXT_MAP, metadata.getMap())
+}
+
+module.exports = GrpcServerPlugin

package/packages/datadog-plugin-grpc/src/util.js

@@ -0,0 +1,66 @@
+'use strict'
+
+const pick = require('../../datadog-core/src/utils/src/pick')
+const log = require('../../dd-trace/src/log')
+
+function getEmptyObject () {
+  return {}
+}
+
+module.exports = {
+  getMethodMetadata (path, kind) {
+    const tags = {
+      path,
+      kind,
+      name: '',
+      service: '',
+      package: '',
+    }
+
+    if (typeof path !== 'string') return tags
+
+    const methodParts = path.split('/')
+
+    if (methodParts.length > 2) {
+      const serviceParts = methodParts[1].split('.')
+      const name = methodParts[2]
+      const service = serviceParts.pop()
+      const pkg = serviceParts.join('.')
+
+      tags.name = name
+      tags.service = service
+      tags.package = pkg
+    } else {
+      tags.name = methodParts.at(-1)
+    }
+
+    return tags
+  },
+
+  addMetadataTags (span, metadata, filter, type) {
+    if (!metadata || typeof metadata.getMap !== 'function') return
+
+    const values = filter(metadata.getMap())
+
+    for (const key in values) {
+      span.setTag(`grpc.${type}.metadata.${key}`, values[key])
+    }
+  },
+
+  // TODO: extract this to shared utils and add unit tests
+  getFilter (config, filter) {
+    if (typeof config[filter] === 'function') {
+      return config[filter]
+    }
+
+    if (Array.isArray(config[filter])) {
+      return element => pick(element, config[filter])
+    }
+
+    if (config.hasOwnProperty(filter)) {
+      log.error('Expected \'%s\' to be an array or function.', filter)
+    }
+
+    return getEmptyObject
+  },
+}

package/packages/datadog-plugin-hapi/src/index.js

@@ -0,0 +1,39 @@
+'use strict'
+
+const { storage } = require('../../datadog-core')
+const RouterPlugin = require('../../datadog-plugin-router/src')
+const web = require('../../dd-trace/src/plugins/util/web')
+
+class HapiPlugin extends RouterPlugin {
+  static id = 'hapi'
+
+  constructor (...args) {
+    super(...args)
+
+    this._requestSpans = new WeakMap()
+
+    this.addSub('apm:hapi:request:handle', ({ req }) => {
+      const store = storage('legacy').getStore()
+      const span = store && store.span
+
+      this.setFramework(req, 'hapi', this.config)
+      this._requestSpans.set(req, span)
+    })
+
+    this.addSub('apm:hapi:request:route', ({ req, route }) => {
+      web.setRoute(req, route)
+    })
+
+    this.addSub('apm:hapi:request:error', error => {
+      if (!error || !error.isBoom || !this.config.validateStatus(error.output.statusCode)) {
+        this.addError(error)
+      }
+    })
+
+    this.addBind('apm:hapi:extension:start', ({ req }) => {
+      return this._requestSpans.get(req)
+    })
+  }
+}
+
+module.exports = HapiPlugin

package/packages/datadog-plugin-hono/src/index.js

@@ -0,0 +1,26 @@
+'use strict'
+
+const RouterPlugin = require('../../datadog-plugin-router/src')
+const web = require('../../dd-trace/src/plugins/util/web')
+
+class HonoPlugin extends RouterPlugin {
+  static id = 'hono'
+
+  constructor (...args) {
+    super(...args)
+
+    this.addSub('apm:hono:request:handle', ({ req }) => {
+      this.setFramework(req, 'hono', this.config)
+    })
+
+    this.addSub('apm:hono:request:route', ({ req, route }) => {
+      web.setRoute(req, route)
+    })
+
+    this.addSub('apm:hono:request:error', ({ req, error }) => {
+      web.addError(req, error)
+    })
+  }
+}
+
+module.exports = HonoPlugin

package/packages/datadog-plugin-http/src/client.js

@@ -0,0 +1,244 @@
+'use strict'
+
+const { URL } = require('url')
+
+const ClientPlugin = require('../../dd-trace/src/plugins/client')
+const { storage } = require('../../datadog-core')
+const tags = require('../../../ext/tags')
+const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
+const formats = require('../../../ext/formats')
+const HTTP_HEADERS = formats.HTTP_HEADERS
+const urlFilter = require('../../dd-trace/src/plugins/util/urlfilter')
+const log = require('../../dd-trace/src/log')
+const { CLIENT_PORT_KEY, COMPONENT, ERROR_MESSAGE, ERROR_TYPE, ERROR_STACK } = require('../../dd-trace/src/constants')
+
+const HTTP_STATUS_CODE = tags.HTTP_STATUS_CODE
+const HTTP_REQUEST_HEADERS = tags.HTTP_REQUEST_HEADERS
+const HTTP_RESPONSE_HEADERS = tags.HTTP_RESPONSE_HEADERS
+
+class HttpClientPlugin extends ClientPlugin {
+  static id = 'http'
+  static prefix = 'apm:http:client:request'
+
+  bindStart (message) {
+    const { args, http = {} } = message
+    const store = storage('legacy').getStore()
+    const options = args.options
+    const agent = options.agent || options._defaultAgent || http.globalAgent || {}
+    const protocol = options.protocol || agent.protocol || 'http:'
+    const hostname = options.hostname || options.host || 'localhost'
+    const host = options.port ? `${hostname}:${options.port}` : hostname
+    const pathname = options.path || options.pathname
+    const path = pathname ? pathname.split(/[?#]/)[0] : '/'
+    const uri = `${protocol}//${host}${path}`
+
+    const allowed = this.config.filter(uri)
+
+    const method = (options.method || 'GET').toUpperCase()
+    const childOf = store && allowed ? store.span : null
+    // TODO delegate to super.startspan
+    const span = this.startSpan(this.operationName(), {
+      childOf,
+      integrationName: this.constructor.id,
+      meta: {
+        [COMPONENT]: this.constructor.id,
+        'span.kind': 'client',
+        'service.name': this.serviceName({ pluginConfig: this.config, sessionDetails: extractSessionDetails(options) }),
+        'resource.name': method,
+        'span.type': 'http',
+        'http.method': method,
+        'http.url': uri,
+        'out.host': hostname,
+      },
+      metrics: {
+        [CLIENT_PORT_KEY]: Number.parseInt(options.port),
+      },
+    }, false)
+
+    // TODO: Figure out a better way to do this for any span.
+    if (!allowed) {
+      span._spanContext._trace.record = false
+    }
+
+    if (this.shouldInjectTraceHeaders(options, uri)) {
+      // Clone the headers object in case an upstream lib has a reference to the original headers
+      // Implemented due to aws-sdk issue where request signing is broken if we mutate the headers
+      // Explained further in:
+      // https://github.com/open-telemetry/opentelemetry-js-contrib/issues/1609#issuecomment-1826167348
+      options.headers = { ...options.headers }
+      this.tracer.inject(span, HTTP_HEADERS, options.headers)
+    }
+
+    analyticsSampler.sample(span, this.config.measured)
+
+    message.span = span
+    message.parentStore = store
+    message.currentStore = { ...store, span }
+
+    return message.currentStore
+  }
+
+  shouldInjectTraceHeaders (options, uri) {
+    if (!this.config.propagationFilter(uri)) {
+      return false
+    }
+
+    return true
+  }
+
+  bindAsyncStart ({ parentStore }) {
+    return parentStore
+  }
+
+  finish (ctx) {
+    const { req, res, span } = ctx
+    if (!span) return
+    if (res) {
+      const status = res.status || res.statusCode
+
+      span.setTag(HTTP_STATUS_CODE, status)
+
+      if (!this.config.validateStatus(status)) {
+        span.setTag('error', 1)
+      }
+
+      addResponseHeaders(res, span, this.config)
+    }
+
+    if (req) {
+      addRequestHeaders(req, span, this.config)
+    }
+
+    this.config.hooks.request(span, req, res)
+
+    super.finish(ctx)
+  }
+
+  error ({ span, error, args, customRequestTimeout }) {
+    if (!span) return
+    if (error) {
+      span.addTags({
+        [ERROR_TYPE]: error.name,
+        [ERROR_MESSAGE]: error.message || error.code,
+        [ERROR_STACK]: error.stack,
+      })
+    } else {
+      // conditions for no error:
+      // 1. not using a custom agent instance with custom timeout specified
+      // 2. no invocation of `req.setTimeout`
+      if (!args.options.agent?.options?.timeout && !customRequestTimeout) return
+
+      span.setTag('error', 1)
+    }
+  }
+
+  configure (config) {
+    return super.configure(normalizeClientConfig(config))
+  }
+}
+
+function addResponseHeaders (res, span, config) {
+  if (!res.headers) return
+
+  const headers = typeof res.headers.entries === 'function'
+    ? Object.fromEntries(res.headers.entries())
+    : res.headers
+
+  for (const [key, tag] of config.headers) {
+    const value = headers[key]
+
+    if (value) {
+      span.setTag(tag || `${HTTP_RESPONSE_HEADERS}.${key}`, value)
+    }
+  }
+}
+
+function addRequestHeaders (req, span, config) {
+  const headers = req.headers && typeof req.headers.entries === 'function'
+    ? Object.fromEntries(req.headers.entries())
+    : req.headers || req.getHeaders()
+
+  for (const [key, tag] of config.headers) {
+    const value = Array.isArray(headers[key]) ? headers[key].toString() : headers[key]
+
+    if (value) {
+      span.setTag(tag || `${HTTP_REQUEST_HEADERS}.${key}`, value)
+    }
+  }
+}
+
+function normalizeClientConfig (config) {
+  const validateStatus = getStatusValidator(config)
+  const filter = getFilter(config)
+  const propagationFilter = getFilter({ blocklist: config.propagationBlocklist })
+  const headers = getHeaders(config)
+  const hooks = getHooks(config)
+
+  return {
+    ...config,
+    validateStatus,
+    filter,
+    propagationFilter,
+    headers,
+    hooks,
+  }
+}
+
+function is400ErrorCode (code) {
+  return code < 400 || code >= 500
+}
+
+function getStatusValidator (config) {
+  if (typeof config.validateStatus === 'function') {
+    return config.validateStatus
+  } else if (config.hasOwnProperty('validateStatus')) {
+    log.error('Expected `validateStatus` to be a function.')
+  }
+  return is400ErrorCode
+}
+
+function getFilter (config) {
+  config = { ...config, blocklist: config.blocklist || [] }
+
+  return urlFilter.getFilter(config)
+}
+
+function getHeaders (config) {
+  if (!Array.isArray(config.headers)) return []
+
+  const result = []
+  for (const header of config.headers) {
+    if (typeof header === 'string') {
+      const separatorIndex = header.indexOf(':')
+      result.push(separatorIndex === -1
+        ? [header, undefined]
+        : [
+            header.slice(0, separatorIndex).toLowerCase(),
+            header.slice(separatorIndex + 1),
+          ]
+      )
+    }
+  }
+  return result
+}
+
+const noop = () => {}
+
+function getHooks (config) {
+  const request = config.hooks?.request ?? noop
+
+  return { request }
+}
+
+function extractSessionDetails (options) {
+  if (typeof options === 'string') {
+    return new URL(options).host
+  }
+
+  const host = options.hostname || options.host || 'localhost'
+  const port = options.port
+
+  return { host, port }
+}
+
+module.exports = HttpClientPlugin