@depup/dd-trace 5.90.0-depup.0

package/packages/datadog-instrumentations/src/hono.js

@@ -0,0 +1,150 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const {
+  addHook,
+  channel,
+} = require('./helpers/instrument')
+
+const routeChannel = channel('apm:hono:request:route')
+const handleChannel = channel('apm:hono:request:handle')
+const errorChannel = channel('apm:hono:request:error')
+const nextChannel = channel('apm:hono:middleware:next')
+const enterChannel = channel('apm:hono:middleware:enter')
+const exitChannel = channel('apm:hono:middleware:exit')
+const finishChannel = channel('apm:hono:middleware:finish')
+
+function wrapFetch (fetch) {
+  return function (request, env, executionCtx) {
+    handleChannel.publish({ req: env.incoming })
+    return fetch.apply(this, arguments)
+  }
+}
+
+function onErrorFn (error, _context_) {
+  throw error
+}
+
+function wrapCompose (compose) {
+  return function (middlewares, onError, onNotFound) {
+    onError ??= onErrorFn
+
+    const instrumentedOnError = (...args) => {
+      const [error, context] = args
+      const req = context.env.incoming
+      errorChannel.publish({ req, error })
+      return onError(...args)
+    }
+
+    const instrumentedMiddlewares = middlewares.map(h => {
+      const [[fn, meta], params] = h
+      return [[wrapMiddleware(fn, meta?.path), meta], params]
+    })
+    return compose.call(this, instrumentedMiddlewares, instrumentedOnError, onNotFound)
+  }
+}
+
+function wrapNext (req, route, next) {
+  return shimmer.wrapFunction(
+    next,
+    (next) =>
+      function () {
+        nextChannel.publish({ req, route })
+
+        return next.apply(this, arguments)
+      }
+  )
+}
+
+function wrapMiddleware (middleware, route) {
+  const name = middleware.name
+  return shimmer.wrapFunction(
+    middleware,
+    (middleware) =>
+      function (context, next) {
+        const req = context.env.incoming
+        routeChannel.publish({ req, route })
+        enterChannel.publish({ req, name, route })
+        if (typeof next === 'function') {
+          arguments[1] = wrapNext(req, route, next)
+        }
+        try {
+          const result = middleware.apply(this, arguments)
+          if (result && typeof result.then === 'function') {
+            return result.then(
+              (result) => {
+                finishChannel.publish({ req })
+                return result
+              },
+              (error) => {
+                errorChannel.publish({ req, error })
+                throw error
+              }
+            )
+          }
+          finishChannel.publish({ req })
+          return result
+        } catch (error) {
+          errorChannel.publish({ req, error })
+          throw error
+        } finally {
+          exitChannel.publish({ req, route })
+        }
+      }
+  )
+}
+
+addHook({
+  name: 'hono',
+  versions: ['>=4'],
+  file: 'dist/hono.js',
+}, hono => {
+  class Hono extends hono.Hono {
+    constructor (...args) {
+      super(...args)
+      shimmer.wrap(this, 'fetch', wrapFetch)
+    }
+  }
+
+  hono.Hono = Hono
+
+  return hono
+})
+
+addHook({
+  name: 'hono',
+  versions: ['>=4'],
+  file: 'dist/cjs/hono.js',
+}, hono => {
+  class Hono extends hono.Hono {
+    constructor (...args) {
+      super(...args)
+      shimmer.wrap(this, 'fetch', wrapFetch)
+    }
+  }
+
+  return Object.create(hono, {
+    Hono: {
+      get () {
+        return Hono
+      },
+      enumerable: true,
+    },
+  })
+})
+
+addHook({
+  name: 'hono',
+  versions: ['>=4'],
+  file: 'dist/cjs/compose.js',
+}, Compose => {
+  return shimmer.wrap(Compose, 'compose', wrapCompose, { replaceGetter: true })
+})
+
+addHook({
+  name: 'hono',
+  versions: ['>=4'],
+  file: 'dist/compose.js',
+}, Compose => {
+  return shimmer.wrap(Compose, 'compose', wrapCompose)
+})

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

@@ -0,0 +1,315 @@
+'use strict'
+
+/* eslint-disable no-fallthrough */
+
+const url = require('url')
+const { errorMonitor } = require('events')
+const { channel, addHook } = require('../helpers/instrument')
+const shimmer = require('../../../datadog-shimmer')
+
+const log = require('../../../dd-trace/src/log')
+
+const startChannel = channel('apm:http:client:request:start')
+const finishChannel = channel('apm:http:client:request:finish')
+const endChannel = channel('apm:http:client:request:end')
+const asyncStartChannel = channel('apm:http:client:request:asyncStart')
+const errorChannel = channel('apm:http:client:request:error')
+const responseFinishChannel = channel('apm:http:client:response:finish')
+
+const names = ['http', 'https', 'node:http', 'node:https']
+
+addHook({ name: names }, hookFn)
+
+function hookFn (http) {
+  patch(http, 'request')
+  patch(http, 'get')
+
+  return http
+}
+
+function combineOptions (inputURL, inputOptions) {
+  return inputOptions !== null && typeof inputOptions === 'object'
+    ? Object.assign(inputURL || {}, inputOptions)
+    : inputURL
+}
+function normalizeHeaders (options) {
+  options.headers ??= {}
+}
+
+function normalizeCallback (inputOptions, callback, inputURL) {
+  return typeof inputOptions === 'function' ? [inputOptions, inputURL || {}] : [callback, inputOptions]
+}
+
+/**
+ * Wires the downstream response so we can observe when the customer consumes
+ * the body and when the stream finishes
+ *
+ * @param {object} ctx - Instrumentation context
+ * @param {import('http').IncomingMessage} res - The downstream response object.
+ * @returns {{ finalizeIfNeeded: () => void }|null} Cleanup helper used for drain.
+ */
+function setupResponseInstrumentation (ctx, res) {
+  const shouldInstrumentFinish = responseFinishChannel.hasSubscribers
+
+  if (!shouldInstrumentFinish) {
+    return null
+  }
+
+  let bodyConsumed = false
+  let finishCalled = false
+  let originalRead = null
+  let dataListenerAdded = false
+  let dataReadStarted = false
+
+  const { shouldCollectBody } = ctx
+  const bodyChunks = shouldCollectBody ? [] : null
+
+  const collectChunk = chunk => {
+    if (!shouldCollectBody || !chunk) return
+
+    if (typeof chunk === 'string') {
+      bodyChunks.push(chunk)
+    } else if (Buffer.isBuffer(chunk)) {
+      bodyChunks.push(chunk)
+    } else {
+      // Handle Uint8Array or other array-like types
+      bodyChunks.push(Buffer.from(chunk))
+    }
+  }
+
+  // Listen for body consumption
+  const onNewListener = (eventName) => {
+    if (eventName === 'data' || eventName === 'readable') {
+      bodyConsumed = true
+
+      // For 'data' events, add our own listener to collect chunks
+      if (eventName === 'data' && !dataListenerAdded && !dataReadStarted) {
+        dataListenerAdded = true
+        res.on('data', collectChunk)
+      }
+
+      // For 'readable' events, wrap the read() method
+      if (eventName === 'readable' && !originalRead && !dataListenerAdded && typeof res.read === 'function') {
+        originalRead = res.read
+        res.read = function () {
+          const chunk = originalRead.apply(this, arguments)
+          if (!dataListenerAdded) {
+            dataReadStarted = true
+            collectChunk(chunk)
+          }
+          return chunk
+        }
+      }
+    }
+  }
+
+  res.on('newListener', onNewListener)
+
+  // Cleanup function to restore original behavior
+  const cleanup = () => {
+    res.off('newListener', onNewListener)
+    res.off('data', collectChunk)
+
+    if (originalRead) {
+      res.read = originalRead
+      originalRead = null
+    }
+  }
+
+  const notifyFinish = () => {
+    if (finishCalled) return
+    finishCalled = true
+
+    // Combine collected chunks into a single body
+    let body = null
+    if (bodyChunks?.length) {
+      const firstChunk = bodyChunks[0]
+      body = typeof firstChunk === 'string'
+        ? bodyChunks.join('')
+        : Buffer.concat(bodyChunks)
+    }
+
+    responseFinishChannel.publish({ ctx, res, body })
+    cleanup()
+  }
+
+  res.once('end', notifyFinish)
+  res.once('close', notifyFinish)
+
+  return {
+    finalizeIfNeeded () {
+      if (!bodyConsumed) {
+        // Body not consumed, resume to complete the response
+        notifyFinish()
+      }
+    },
+  }
+}
+
+function patch (http, methodName) {
+  shimmer.wrap(http, methodName, instrumentRequest)
+
+  function instrumentRequest (request) {
+    return function () {
+      if (!startChannel.hasSubscribers) {
+        return request.apply(this, arguments)
+      }
+
+      let args
+
+      try {
+        args = normalizeArgs.apply(null, arguments)
+      } catch (e) {
+        log.error('Error normalising http req arguments', e)
+        return request.apply(this, arguments)
+      }
+
+      const abortController = new AbortController()
+
+      const ctx = { args, http, abortController }
+
+      return startChannel.runStores(ctx, () => {
+        let finished = false
+        let callback = args.callback
+
+        if (callback) {
+          callback = shimmer.wrapFunction(args.callback, cb => function () {
+            return asyncStartChannel.runStores(ctx, () => {
+              return cb.apply(this, arguments)
+            })
+          })
+        }
+
+        const options = args.options
+
+        const finish = () => {
+          if (!finished) {
+            finished = true
+            finishChannel.publish(ctx)
+          }
+        }
+
+        try {
+          const req = request.call(this, options, callback)
+          const emit = req.emit
+          const setTimeout = req.setTimeout
+
+          ctx.req = req
+
+          // tracked to accurately discern custom request socket timeout
+          let customRequestTimeout = false
+          req.setTimeout = function () {
+            customRequestTimeout = true
+            return setTimeout.apply(this, arguments)
+          }
+
+          req.emit = function (eventName, arg) {
+            switch (eventName) {
+              case 'response': {
+                const res = arg
+                ctx.res = res
+                res.once('end', finish)
+                res.once(errorMonitor, finish)
+
+                const instrumentation = setupResponseInstrumentation(ctx, res)
+
+                if (!instrumentation) {
+                  break
+                }
+
+                const result = emit.apply(this, arguments)
+
+                instrumentation.finalizeIfNeeded()
+
+                return result
+              }
+              case 'connect':
+              case 'upgrade':
+                ctx.res = arg
+                finish()
+                break
+              case 'error':
+              case 'timeout':
+                ctx.error = arg
+                ctx.customRequestTimeout = customRequestTimeout
+                errorChannel.publish(ctx)
+              case 'abort': // deprecated and replaced by `close` in node 17
+              case 'close':
+                finish()
+            }
+
+            return emit.apply(this, arguments)
+          }
+
+          if (abortController.signal.aborted) {
+            req.destroy(abortController.signal.reason || new Error('Aborted'))
+          }
+
+          return req
+        } catch (e) {
+          ctx.error = e
+          errorChannel.publish(ctx)
+          // if the initial request failed, ctx.req will be unset, we must close the span here
+          // fix for: https://github.com/DataDog/dd-trace-js/issues/5016
+          if (!ctx.req) {
+            finish()
+          }
+          throw e
+        } finally {
+          endChannel.publish(ctx)
+        }
+      })
+    }
+  }
+
+  function normalizeArgs (inputURL, inputOptions, cb) {
+    const originalUrl = inputURL
+    inputURL = normalizeOptions(inputURL)
+
+    const [callback, inputOptionsNormalized] = normalizeCallback(inputOptions, cb, inputURL)
+    const options = combineOptions(inputURL, inputOptionsNormalized)
+    normalizeHeaders(options)
+    const uri = url.format(options)
+
+    return { uri, options, callback, originalUrl }
+  }
+
+  function normalizeOptions (inputURL) {
+    if (typeof inputURL === 'string') {
+      try {
+        return urlToOptions(new url.URL(inputURL))
+      } catch {
+        // eslint-disable-next-line n/no-deprecated-api
+        return url.parse(inputURL)
+      }
+    } else if (inputURL instanceof url.URL) {
+      return urlToOptions(inputURL)
+    } else {
+      return inputURL
+    }
+  }
+
+  function urlToOptions (url) {
+    const agent = url.agent || http.globalAgent
+    const options = {
+      protocol: url.protocol || agent.protocol,
+      hostname: typeof url.hostname === 'string' && url.hostname.startsWith('[')
+        ? url.hostname.slice(1, -1)
+        : url.hostname ||
+          url.host ||
+          'localhost',
+      hash: url.hash,
+      search: url.search,
+      pathname: url.pathname,
+      path: `${url.pathname || ''}${url.search || ''}`,
+      href: url.href,
+    }
+    if (url.port !== '') {
+      options.port = Number(url.port)
+    }
+    if (url.username || url.password) {
+      options.auth = `${url.username}:${url.password}`
+    }
+    return options
+  }
+}

package/packages/datadog-instrumentations/src/http/server.js

@@ -0,0 +1,223 @@
+'use strict'
+
+const {
+  channel,
+  addHook,
+} = require('../helpers/instrument')
+const shimmer = require('../../../datadog-shimmer')
+
+const startServerCh = channel('apm:http:server:request:start')
+const exitServerCh = channel('apm:http:server:request:exit')
+const errorServerCh = channel('apm:http:server:request:error')
+const finishServerCh = channel('apm:http:server:request:finish')
+const startWriteHeadCh = channel('apm:http:server:response:writeHead:start')
+const finishSetHeaderCh = channel('datadog:http:server:response:set-header:finish')
+const startSetHeaderCh = channel('datadog:http:server:response:set-header:start')
+
+const requestFinishedSet = new WeakSet()
+
+const httpNames = ['http', 'node:http']
+const httpsNames = ['https', 'node:https']
+
+addHook({ name: httpNames }, http => {
+  shimmer.wrap(http.ServerResponse.prototype, 'emit', wrapResponseEmit)
+  shimmer.wrap(http.Server.prototype, 'emit', wrapEmit)
+  shimmer.wrap(http.ServerResponse.prototype, 'writeHead', wrapWriteHead)
+  shimmer.wrap(http.ServerResponse.prototype, 'write', wrapWrite)
+  shimmer.wrap(http.ServerResponse.prototype, 'end', wrapEnd)
+  shimmer.wrap(http.ServerResponse.prototype, 'setHeader', wrapSetHeader)
+  shimmer.wrap(http.ServerResponse.prototype, 'removeHeader', wrapAppendOrRemoveHeader)
+  // Added in node v16.17.0
+  if (http.ServerResponse.prototype.appendHeader) {
+    shimmer.wrap(http.ServerResponse.prototype, 'appendHeader', wrapAppendOrRemoveHeader)
+  }
+  return http
+})
+
+addHook({ name: httpsNames }, http => {
+  // http.ServerResponse not present on https
+  shimmer.wrap(http.Server.prototype, 'emit', wrapEmit)
+  return http
+})
+
+function wrapResponseEmit (emit) {
+  return function (eventName, event) {
+    if (!finishServerCh.hasSubscribers) {
+      return emit.apply(this, arguments)
+    }
+
+    if (['finish', 'close'].includes(eventName) && !requestFinishedSet.has(this)) {
+      finishServerCh.publish({ req: this.req })
+      requestFinishedSet.add(this)
+    }
+
+    return emit.apply(this, arguments)
+  }
+}
+function wrapEmit (emit) {
+  return function (eventName, req, res) {
+    if (!startServerCh.hasSubscribers) {
+      return emit.apply(this, arguments)
+    }
+
+    if (eventName === 'request') {
+      res.req = req
+
+      const abortController = new AbortController()
+
+      startServerCh.publish({ req, res, abortController })
+
+      try {
+        if (abortController.signal.aborted) {
+          // TODO: should this always return true ?
+          return this.listenerCount(eventName) > 0
+        }
+
+        return emit.apply(this, arguments)
+      } catch (err) {
+        errorServerCh.publish(err)
+
+        throw err
+      } finally {
+        exitServerCh.publish({ req })
+      }
+    }
+    return emit.apply(this, arguments)
+  }
+}
+
+function wrapWriteHead (writeHead) {
+  return function wrappedWriteHead (statusCode, reason, obj) {
+    if (!startWriteHeadCh.hasSubscribers) {
+      return writeHead.apply(this, arguments)
+    }
+
+    const abortController = new AbortController()
+
+    if (typeof reason !== 'string') {
+      obj ??= reason
+    }
+
+    // support writeHead(200, ['key1', 'val1', 'key2', 'val2'])
+    if (Array.isArray(obj)) {
+      const headers = {}
+
+      for (let i = 0; i < obj.length; i += 2) {
+        headers[obj[i]] = obj[i + 1]
+      }
+
+      obj = headers
+    }
+
+    // this doesn't support explicit duplicate headers, but it's an edge case
+    const responseHeaders = Object.assign(this.getHeaders(), obj)
+
+    startWriteHeadCh.publish({
+      req: this.req,
+      res: this,
+      abortController,
+      statusCode,
+      responseHeaders,
+    })
+
+    if (abortController.signal.aborted) {
+      return this
+    }
+
+    return writeHead.apply(this, arguments)
+  }
+}
+
+function wrapWrite (write) {
+  return function wrappedWrite () {
+    if (!startWriteHeadCh.hasSubscribers) {
+      return write.apply(this, arguments)
+    }
+
+    const abortController = new AbortController()
+
+    const responseHeaders = this.getHeaders()
+
+    startWriteHeadCh.publish({
+      req: this.req,
+      res: this,
+      abortController,
+      statusCode: this.statusCode,
+      responseHeaders,
+    })
+
+    if (abortController.signal.aborted) {
+      return true
+    }
+
+    return write.apply(this, arguments)
+  }
+}
+
+function wrapSetHeader (setHeader) {
+  return function wrappedSetHeader (name, value) {
+    if (!startSetHeaderCh.hasSubscribers && !finishSetHeaderCh.hasSubscribers) {
+      return setHeader.apply(this, arguments)
+    }
+
+    if (startSetHeaderCh.hasSubscribers) {
+      const abortController = new AbortController()
+      startSetHeaderCh.publish({ res: this, abortController })
+
+      if (abortController.signal.aborted) {
+        return
+      }
+    }
+
+    const setHeaderResult = setHeader.apply(this, arguments)
+
+    if (finishSetHeaderCh.hasSubscribers) {
+      finishSetHeaderCh.publish({ name, value, res: this })
+    }
+
+    return setHeaderResult
+  }
+}
+
+function wrapAppendOrRemoveHeader (originalMethod) {
+  return function wrappedAppendOrRemoveHeader () {
+    if (!startSetHeaderCh.hasSubscribers) {
+      return originalMethod.apply(this, arguments)
+    }
+
+    const abortController = new AbortController()
+    startSetHeaderCh.publish({ res: this, abortController })
+
+    if (abortController.signal.aborted) {
+      return this
+    }
+
+    return originalMethod.apply(this, arguments)
+  }
+}
+
+function wrapEnd (end) {
+  return function wrappedEnd () {
+    if (!startWriteHeadCh.hasSubscribers) {
+      return end.apply(this, arguments)
+    }
+
+    const abortController = new AbortController()
+
+    const responseHeaders = this.getHeaders()
+
+    startWriteHeadCh.publish({
+      req: this.req,
+      res: this,
+      abortController,
+      statusCode: this.statusCode,
+      responseHeaders,
+    })
+
+    if (abortController.signal.aborted) {
+      return this
+    }
+
+    return end.apply(this, arguments)
+  }
+}

package/packages/datadog-instrumentations/src/http.js

@@ -0,0 +1,4 @@
+'use strict'
+
+require('./http/client')
+require('./http/server')