@depup/dd-trace 5.90.0-depup.0

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

@@ -0,0 +1,372 @@
+'use strict'
+
+const { errorMonitor } = require('events')
+const shimmer = require('../../datadog-shimmer')
+const { channel, addHook } = require('./helpers/instrument')
+
+const startChannel = channel('apm:fs:operation:start')
+const finishChannel = channel('apm:fs:operation:finish')
+const errorChannel = channel('apm:fs:operation:error')
+const ddFhSym = Symbol('ddFileHandle')
+let kHandle, kDirReadPromisified, kDirClosePromisified
+
+// Update packages/dd-trace/src/profiling/profilers/event_plugins/fs.js if you make changes to param names in any of
+// the following objects.
+
+const paramsByMethod = {
+  access: ['path', 'mode'],
+  appendFile: ['path', 'data', 'options'],
+  chmod: ['path', 'mode'],
+  chown: ['path', 'uid', 'gid'],
+  close: ['fd'],
+  copyFile: ['src', 'dest', 'mode'],
+  cp: ['src', 'dest', 'options'],
+  exists: ['path'],
+  fchmod: ['fd', 'mode'],
+  fchown: ['fd', 'uid', 'gid'],
+  fdatasync: ['fd'],
+  fstat: ['fd', 'options'],
+  fsync: ['fd'],
+  ftruncate: ['fd', 'len'],
+  futimes: ['fd', 'atime', 'mtime'],
+  lchmod: ['path', 'mode'],
+  lchown: ['path', 'uid', 'gid'],
+  link: ['existingPath', 'newPath'],
+  lstat: ['path', 'options'],
+  lutimes: ['path', 'atime', 'mtime'],
+  mkdir: ['path', 'options'],
+  mkdtemp: ['prefix', 'options'],
+  open: ['path', 'flag', 'mode'],
+  opendir: ['path', 'options'],
+  read: ['fd'],
+  readdir: ['path', 'options'],
+  readFile: ['path', 'options'],
+  readlink: ['path', 'options'],
+  readv: ['fd'],
+  realpath: ['path', 'options'],
+  rename: ['oldPath', 'newPath'],
+  rmdir: ['path', 'options'],
+  rm: ['path', 'options'],
+  stat: ['path', 'options'],
+  symlink: ['target', 'path', 'type'],
+  truncate: ['path', 'len'],
+  unlink: ['path'],
+  utimes: ['path', 'atime', 'mtime'],
+  write: ['fd'],
+  writeFile: ['file', 'data', 'options'],
+  writev: ['fd'],
+}
+
+const watchMethods = {
+  unwatchFile: ['path', 'listener'],
+  watch: ['path', 'options', 'listener'],
+  watchFile: ['path', 'options', 'listener'],
+}
+
+const paramsByFileHandleMethods = {
+  appendFile: ['data', 'options'],
+  chmod: ['mode'],
+  chown: ['uid', 'gid'],
+  close: [],
+  createReadStream: ['options'],
+  createWriteStream: ['options'],
+  datasync: [],
+  read: ['buffer', 'offset', 'length', 'position'],
+  readableWebStream: [],
+  readFile: ['options'],
+  readLines: ['options'],
+  readv: ['buffers', 'position'],
+  stat: ['options'],
+  sync: [],
+  truncate: ['len'],
+  utimes: ['atime', 'mtime'],
+  write: ['buffer', 'offset', 'length', 'position'],
+  writeFile: ['data', 'options'],
+  writev: ['buffers', 'position'],
+}
+const names = ['fs', 'node:fs']
+for (const name of names) {
+  addHook({ name }, fs => {
+    const asyncMethods = Object.keys(paramsByMethod)
+    const syncMethods = asyncMethods.map(name => `${name}Sync`)
+
+    massWrap(fs, asyncMethods, createWrapFunction())
+    massWrap(fs, syncMethods, createWrapFunction())
+    massWrap(fs.promises, asyncMethods, createWrapFunction('promises.'))
+
+    wrap(fs.realpath, 'native', createWrapFunction('', 'realpath.native'))
+    wrap(fs.realpathSync, 'native', createWrapFunction('', 'realpath.native'))
+    wrap(fs.promises.realpath, 'native', createWrapFunction('', 'realpath.native'))
+
+    wrap(fs, 'createReadStream', wrapCreateStream)
+    wrap(fs, 'createWriteStream', wrapCreateStream)
+    if (fs.Dir) {
+      wrap(fs.Dir.prototype, 'close', createWrapFunction('dir.'))
+      wrap(fs.Dir.prototype, 'closeSync', createWrapFunction('dir.'))
+      wrap(fs.Dir.prototype, 'read', createWrapFunction('dir.'))
+      wrap(fs.Dir.prototype, 'readSync', createWrapFunction('dir.'))
+      wrap(fs.Dir.prototype, Symbol.asyncIterator, createWrapDirAsyncIterator())
+    }
+
+    wrap(fs, 'unwatchFile', createWatchWrapFunction())
+    wrap(fs, 'watch', createWatchWrapFunction())
+    wrap(fs, 'watchFile', createWatchWrapFunction())
+
+    return fs
+  })
+}
+function isFirstMethodReturningFileHandle (original) {
+  return !kHandle && original.name === 'open'
+}
+function wrapFileHandle (fh) {
+  const fileHandlePrototype = getFileHandlePrototype(fh)
+  const desc = Reflect.getOwnPropertyDescriptor(fileHandlePrototype, kHandle)
+  if (!desc || !desc.get) {
+    Reflect.defineProperty(fileHandlePrototype, kHandle, {
+      get () {
+        return this[ddFhSym]
+      },
+      set (h) {
+        this[ddFhSym] = h
+        wrap(this, 'close', createWrapFunction('filehandle.'))
+      },
+      configurable: true,
+    })
+  }
+  for (const name of Reflect.ownKeys(fileHandlePrototype)) {
+    if (typeof name !== 'string' || name === 'constructor' || name === 'fd' || name === 'getAsyncId') {
+      continue
+    }
+    wrap(fileHandlePrototype, name, createWrapFunction('filehandle.'))
+  }
+}
+
+function getFileHandlePrototype (fh) {
+  if (!kHandle) {
+    kHandle = Reflect.ownKeys(fh).find(key => typeof key === 'symbol' && key.toString().includes('kHandle'))
+  }
+  return Object.getPrototypeOf(fh)
+}
+
+function getSymbolName (sym) {
+  return sym.description || sym.toString()
+}
+function initDirAsyncIteratorProperties (iterator) {
+  const keys = Reflect.ownKeys(iterator)
+  for (const key of keys) {
+    if (kDirReadPromisified && kDirClosePromisified) break
+    if (typeof key !== 'symbol') continue
+    if (!kDirReadPromisified && getSymbolName(key).includes('kDirReadPromisified')) {
+      kDirReadPromisified = key
+    }
+    if (!kDirClosePromisified && getSymbolName(key).includes('kDirClosePromisified')) {
+      kDirClosePromisified = key
+    }
+  }
+}
+
+function createWrapDirAsyncIterator () {
+  return function wrapDirAsyncIterator (asyncIterator) {
+    return function wrappedAsyncIterator () {
+      if (!kDirReadPromisified || !kDirClosePromisified) {
+        initDirAsyncIteratorProperties(this)
+      }
+      wrap(this, kDirReadPromisified, createWrapFunction('dir.', 'read'))
+      wrap(this, kDirClosePromisified, createWrapFunction('dir.', 'close'))
+      return asyncIterator.apply(this, arguments)
+    }
+  }
+}
+
+function wrapCreateStream (original) {
+  const classes = {
+    createReadStream: 'ReadStream',
+    createWriteStream: 'WriteStream',
+  }
+  const name = classes[original.name]
+
+  return function (path, options) {
+    if (!startChannel.hasSubscribers) return original.apply(this, arguments)
+
+    const ctx = getMessage(name, ['path', 'options'], arguments)
+
+    return startChannel.runStores(ctx, () => {
+      try {
+        const stream = original.apply(this, arguments)
+        const onError = error => {
+          ctx.error = error
+          errorChannel.publish(ctx)
+          onFinish()
+        }
+        const onFinish = () => {
+          finishChannel.runStores(ctx, () => {})
+          stream.removeListener('close', onFinish)
+          stream.removeListener('end', onFinish)
+          stream.removeListener('finish', onFinish)
+          stream.removeListener(errorMonitor, onError)
+        }
+
+        stream.once('close', onFinish)
+        stream.once('end', onFinish)
+        stream.once('finish', onFinish)
+        stream.once(errorMonitor, onError)
+
+        return stream
+      } catch (error) {
+        ctx.error = error
+        errorChannel.publish(ctx)
+        finishChannel.runStores(ctx, () => {})
+      }
+    })
+  }
+}
+
+function getMethodParamsRelationByPrefix (prefix) {
+  if (prefix === 'filehandle.') {
+    return paramsByFileHandleMethods
+  }
+  return paramsByMethod
+}
+
+function createWatchWrapFunction (override = '') {
+  return function wrapFunction (original) {
+    const name = override || original.name
+    const method = name
+    const operation = name
+    return function () {
+      if (!startChannel.hasSubscribers) return original.apply(this, arguments)
+      const ctx = getMessage(method, watchMethods[operation], arguments, this)
+      return startChannel.runStores(ctx, () => {
+        try {
+          const result = original.apply(this, arguments)
+          finishChannel.runStores(ctx, () => {})
+          return result
+        } catch (error) {
+          ctx.error = error
+          errorChannel.publish(ctx)
+          finishChannel.runStores(ctx, () => {})
+          throw error
+        }
+      })
+    }
+  }
+}
+
+function createWrapFunction (prefix = '', override = '') {
+  return function wrapFunction (original) {
+    const name = override || original.name
+    const method = `${prefix}${name}`
+    const operation = name.match(/^(.+?)(Sync)?(\.native)?$/)[1]
+
+    return function () {
+      if (!startChannel.hasSubscribers) return original.apply(this, arguments)
+
+      const lastIndex = arguments.length - 1
+      const cb = typeof arguments[lastIndex] === 'function' && arguments[lastIndex]
+      const params = getMethodParamsRelationByPrefix(prefix)[operation]
+      const abortController = new AbortController()
+      const ctx = { ...getMessage(method, params, arguments, this), abortController }
+
+      const finish = function (error, cb = () => {}) {
+        if (error !== null && typeof error === 'object') { // fs.exists receives a boolean
+          ctx.error = error
+          errorChannel.publish(ctx)
+        }
+        return finishChannel.runStores(ctx, cb)
+      }
+
+      if (cb) {
+        arguments[lastIndex] = shimmer.wrapFunction(cb, cb => function (e) {
+          return finish(e, () => cb.apply(this, arguments))
+        })
+      }
+
+      return startChannel.runStores(ctx, () => {
+        if (abortController.signal.aborted) {
+          const error = abortController.signal.reason || new Error('Aborted')
+
+          if (prefix === 'promises.') {
+            finish(error)
+            return Promise.reject(error)
+          } else if (name.includes('Sync') || !cb) {
+            finish(error)
+            throw error
+          } else if (cb) {
+            arguments[lastIndex](error)
+            return
+          }
+        }
+
+        try {
+          const result = original.apply(this, arguments)
+          if (cb) return result
+          if (result && typeof result.then === 'function') {
+            // TODO method open returning promise and filehandle prototype not initialized, initialize it
+
+            return result.then(
+              value => {
+                if (isFirstMethodReturningFileHandle(original)) {
+                  wrapFileHandle(value)
+                }
+                finishChannel.runStores(ctx, () => {})
+                return value
+              },
+              error => {
+                ctx.error = error
+                errorChannel.publish(ctx)
+                finishChannel.runStores(ctx, () => {})
+                throw error
+              }
+            )
+          }
+
+          finishChannel.runStores(ctx, () => {})
+
+          return result
+        } catch (error) {
+          ctx.error = error
+          errorChannel.publish(ctx)
+          finishChannel.runStores(ctx, () => {})
+          throw error
+        }
+      })
+    }
+  }
+}
+
+function getMessage (operation, params, args, self) {
+  const metadata = {}
+  if (params) {
+    for (let i = 0; i < params.length; i++) {
+      if (!params[i] || typeof args[i] === 'function') continue
+      metadata[params[i]] = args[i]
+    }
+  }
+
+  if (self) {
+    // For `Dir` the path is available on `this.path`
+    if (self.path) {
+      metadata.path = self.path
+    }
+    // For FileHandle fs is available on `this.fd`
+    if (self.fd) {
+      metadata.fd = self.fd
+    }
+  }
+
+  return { operation, ...metadata }
+}
+
+function massWrap (target, methods, wrapper) {
+  for (const method of methods) {
+    wrap(target, method, wrapper)
+  }
+}
+
+function wrap (target, method, wrapper) {
+  try {
+    shimmer.wrap(target, method, wrapper)
+  } catch {
+    // skip unavailable method
+  }
+}

package/packages/datadog-instrumentations/src/generic-pool.js

@@ -0,0 +1,48 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { addHook, AsyncResource } = require('./helpers/instrument')
+
+function createWrapAcquire () {
+  return function wrapAcquire (acquire) {
+    return function acquireWithTrace (callback, priority) {
+      if (typeof callback === 'function') {
+        arguments[0] = AsyncResource.bind(callback)
+      }
+
+      return acquire.apply(this, arguments)
+    }
+  }
+}
+
+function createWrapPool () {
+  return function wrapPool (Pool) {
+    if (typeof Pool !== 'function') return Pool
+
+    return function PoolWithTrace (factory) {
+      const pool = Pool.apply(this, arguments)
+
+      if (pool && typeof pool.acquire === 'function') {
+        shimmer.wrap(pool, 'acquire', createWrapAcquire())
+      }
+
+      return pool
+    }
+  }
+}
+
+addHook({
+  name: 'generic-pool',
+  versions: ['^2.4'],
+}, genericPool => {
+  shimmer.wrap(genericPool.Pool.prototype, 'acquire', createWrapAcquire())
+  return genericPool
+})
+
+addHook({
+  name: 'generic-pool',
+  versions: ['2 - 2.3'],
+}, genericPool => {
+  shimmer.wrap(genericPool, 'Pool', createWrapPool())
+  return genericPool
+})

package/packages/datadog-instrumentations/src/google-cloud-pubsub.js

@@ -0,0 +1,287 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const {
+  channel,
+  addHook,
+} = require('./helpers/instrument')
+
+const requestStartCh = channel('apm:google-cloud-pubsub:request:start')
+const requestFinishCh = channel('apm:google-cloud-pubsub:request:finish')
+const requestErrorCh = channel('apm:google-cloud-pubsub:request:error')
+
+const receiveStartCh = channel('apm:google-cloud-pubsub:receive:start')
+const receiveFinishCh = channel('apm:google-cloud-pubsub:receive:finish')
+const receiveErrorCh = channel('apm:google-cloud-pubsub:receive:error')
+
+/**
+ * Message-level channels for trace context injection and async context propagation:
+ * - messagePublishCh: Inject trace context when Topic.publish() is called
+ * - messageAckStoreCh: Store async context when message.ack() is called (PULL)
+ * - messageAckRetrieveCh: Retrieve stored context when acknowledge() API is called (PULL)
+ * - messageStoreCh: Propagate context when Subscription emits 'message' event (PULL)
+ */
+const messagePublishCh = channel('apm:google-cloud-pubsub:message:publish')
+const messageAckStoreCh = channel('apm:google-cloud-pubsub:message:ack-store')
+const messageAckRetrieveCh = channel('apm:google-cloud-pubsub:message:ack-retrieve')
+const messageStoreCh = channel('apm:google-cloud-pubsub:message:store')
+
+// WeakMap for passing context between LeaseManager._dispense and LeaseManager.remove
+const messageContexts = new WeakMap()
+
+const publisherMethods = [
+  'createTopic',
+  'updateTopic',
+  'publish',
+  'getTopic',
+  'listTopics',
+  'listTopicSubscriptions',
+  'listTopicSnapshots',
+  'deleteTopic',
+  'detachSubscription',
+]
+
+const schemaServiceMethods = [
+  'createSchema',
+  'getSchema',
+  'listSchemas',
+  'listSchemaRevisions',
+  'commitSchema',
+  'rollbackSchema',
+  'deleteSchemaRevision',
+  'deleteSchema',
+  'validateSchema',
+  'validateMessage',
+]
+
+const subscriberMethods = [
+  'createSubscription',
+  'getSubscription',
+  'updateSubscription',
+  'listSubscriptions',
+  'deleteSubscription',
+  'modifyAckDeadline',
+  'acknowledge',
+  'pull',
+  'streamingPull',
+  'modifyPushConfig',
+  'getSnapshot',
+  'listSnapshots',
+  'createSnapshot',
+  'updateSnapshot',
+  'deleteSnapshot',
+  'seek',
+]
+
+function wrapMethod (method) {
+  const api = method.name
+
+  return function (request) {
+    if (!requestStartCh.hasSubscribers) return method.apply(this, arguments)
+
+    const ctx = { request, api, projectId: this.auth._cachedProjectId }
+
+    /**
+     * For acknowledge/modifyAckDeadline: retrieve stored context from consumer plugin.
+     * These APIs only have ackIds (no Message objects), so async context is lost.
+     * Plugin sets ctx.storedContext, which client.js uses to link the acknowledge span.
+     */
+    const isAckOperation = api === 'acknowledge' || api === 'modifyAckDeadline'
+    if (isAckOperation && request?.ackIds?.length > 0) {
+      messageAckRetrieveCh.publish({
+        ackIds: request.ackIds,
+        api,
+        ctx,
+      })
+    }
+
+    return requestStartCh.runStores(ctx, () => {
+      const cb = arguments[arguments.length - 1]
+
+      if (typeof cb === 'function') {
+        arguments[arguments.length - 1] = shimmer.wrapFunction(cb, cb => function (error) {
+          if (error) {
+            ctx.error = error
+            requestErrorCh.publish(ctx)
+          }
+          return requestFinishCh.runStores(ctx, cb, this, ...arguments)
+        })
+        return method.apply(this, arguments)
+      }
+
+      return method.apply(this, arguments)
+        .then(
+          response => {
+            requestFinishCh.publish(ctx)
+            return response
+          },
+          error => {
+            ctx.error = error
+            requestErrorCh.publish(ctx)
+            requestFinishCh.publish(ctx)
+            throw error
+          }
+        )
+    })
+  }
+}
+
+function massWrap (obj, methods, wrapper) {
+  for (const method of methods) {
+    if (typeof obj[method] === 'function') {
+      shimmer.wrap(obj, method, wrapper)
+    }
+  }
+}
+
+addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'] }, (obj) => {
+  const Subscription = obj.Subscription
+
+  /**
+   * PULL: Intercept 'message' events and propagate async context via runStores.
+   * This ensures the consumer plugin creates spans in the correct context.
+   */
+  shimmer.wrap(Subscription.prototype, 'emit', emit => function (eventName, message) {
+    if (eventName !== 'message' || !message) return emit.apply(this, arguments)
+
+    const ctx = { message }
+    try {
+      return messageStoreCh.runStores(ctx, emit, this, ...arguments)
+    } catch (err) {
+      ctx.error = err
+      receiveErrorCh.publish(ctx)
+      throw err
+    }
+  })
+
+  return obj
+})
+
+addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'], file: 'build/src/subscriber.js' }, (obj) => {
+  const Message = obj.Message
+
+  /**
+   * PULL: Capture async context when message.ack() is called.
+   * This is our last chance before context is lost. The acknowledge() API call happens
+   * later (often batched), and we'll retrieve this stored context to link spans.
+   * Flow: message.ack() -> store context -> acknowledge() API -> retrieve context
+   */
+  if (Message?.prototype?.ack) {
+    shimmer.wrap(Message.prototype, 'ack', originalAck => function () {
+      if (this.ackId) {
+        const ctx = {
+          message: this,
+          ackId: this.ackId,
+        }
+
+        return messageAckStoreCh.runStores(ctx, originalAck, this, ...arguments)
+      }
+
+      return originalAck.apply(this, arguments)
+    })
+  }
+
+  return obj
+})
+
+/**
+ * PULL: Hook LeaseManager to track message lifecycle (dispense/remove/clear).
+ * _dispense: Message given to handler -> create span
+ * remove: Message removed from lease (ack/nack/timeout) -> finish span
+ * clear: Subscription closed -> finish all remaining spans
+ */
+addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'], file: 'build/src/lease-manager.js' }, (obj) => {
+  const LeaseManager = obj.LeaseManager
+  if (!LeaseManager) {
+    return obj
+  }
+
+  shimmer.wrap(LeaseManager.prototype, '_dispense', dispense => function (message) {
+    const ctx = { message }
+    messageContexts.set(message, ctx)
+
+    return receiveStartCh.runStores(ctx, dispense, this, ...arguments)
+  })
+
+  shimmer.wrap(LeaseManager.prototype, 'remove', remove => function (message) {
+    const ctx = messageContexts.get(message)
+    if (ctx) {
+      messageContexts.delete(message)
+    }
+
+    return receiveFinishCh.runStores(ctx || { message }, remove, this, ...arguments)
+  })
+
+  shimmer.wrap(LeaseManager.prototype, 'clear', clear => function () {
+    if (this._messages) {
+      for (const message of this._messages.values()) {
+        const ctx = messageContexts.get(message)
+        if (ctx) {
+          receiveFinishCh.publish(ctx)
+          messageContexts.delete(message)
+        }
+      }
+    }
+    return clear.apply(this, arguments)
+  })
+
+  return obj
+})
+
+/**
+ * Inject trace context into individual messages via Topic.publish()/publishMessage().
+ * Flow: User calls topic.publish() -> inject context (here) -> SDK batches messages ->
+ * publish() API called -> producer plugin creates batch span + metadata
+ */
+addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'] }, (obj) => {
+  if (!obj.Topic?.prototype) return obj
+
+  if (typeof obj.Topic.prototype.publishMessage === 'function') {
+    shimmer.wrap(obj.Topic.prototype, 'publishMessage', publishMessage => {
+      return function (data, attributesOrCallback, callback) {
+        if (data && typeof data === 'object') {
+          if (!data.attributes) data.attributes = {}
+          messagePublishCh.publish({
+            attributes: data.attributes,
+            pubsub: this.pubsub,
+            topicName: this.name,
+          })
+        }
+        return publishMessage.apply(this, arguments)
+      }
+    })
+  }
+
+  if (typeof obj.Topic.prototype.publish === 'function') {
+    shimmer.wrap(obj.Topic.prototype, 'publish', publish => function (buffer, attributesOrCallback, callback) {
+      if (typeof attributesOrCallback === 'function' || !attributesOrCallback) {
+        arguments[1] = {}
+        arguments[2] = attributesOrCallback
+      }
+
+      messagePublishCh.publish({
+        attributes: arguments[1],
+        pubsub: this.pubsub,
+        topicName: this.name,
+        buffer,
+      })
+
+      return publish.apply(this, arguments)
+    })
+  }
+
+  return obj
+})
+
+addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'] }, (obj) => {
+  const { PublisherClient, SchemaServiceClient, SubscriberClient } = obj.v1
+
+  massWrap(PublisherClient.prototype, publisherMethods, wrapMethod)
+  massWrap(SubscriberClient.prototype, subscriberMethods, wrapMethod)
+
+  if (SchemaServiceClient) {
+    massWrap(SchemaServiceClient.prototype, schemaServiceMethods, wrapMethod)
+  }
+
+  return obj
+})