@depup/dd-trace 5.90.0-depup.0

package/packages/datadog-plugin-mongodb-core/src/index.js

@@ -0,0 +1,215 @@
+'use strict'
+
+const { isTrue } = require('../../dd-trace/src/util')
+const DatabasePlugin = require('../../dd-trace/src/plugins/database')
+const { getValueFromEnvSources } = require('../../dd-trace/src/config/helper')
+
+class MongodbCorePlugin extends DatabasePlugin {
+  static id = 'mongodb-core'
+  static component = 'mongodb'
+  // avoid using db.name for peer.service since it includes the collection name
+  // should be removed if one day this will be fixed
+  /**
+   * @override
+   */
+  static peerServicePrecursors = []
+
+  /**
+   * @override
+   */
+  configure (config) {
+    super.configure(config)
+
+    const heartbeatFromEnv = getValueFromEnvSources('DD_TRACE_MONGODB_HEARTBEAT_ENABLED')
+
+    this.config.heartbeatEnabled = config.heartbeatEnabled ??
+      (heartbeatFromEnv && isTrue(heartbeatFromEnv)) ??
+      true
+  }
+
+  bindStart (ctx) {
+    const { ns, ops, options = {}, name } = ctx
+    // heartbeat commands can be disabled if this.config.heartbeatEnabled is false
+    if (!this.config.heartbeatEnabled && isHeartbeat(ops, this.config)) {
+      return
+    }
+    const query = getQuery(ops)
+    const resource = truncate(getResource(this, ns, query, name))
+    const service = this.serviceName({ pluginConfig: this.config })
+    const span = this.startSpan(this.operationName(), {
+      service,
+      resource,
+      type: 'mongodb',
+      kind: 'client',
+      meta: {
+        // this is not technically correct since it includes the collection but we changing will break customer stuff
+        'db.name': ns,
+        'mongodb.query': query,
+        'out.host': options.host,
+        'out.port': options.port,
+      },
+    }, ctx)
+    const comment = this.injectDbmComment(span, ops.comment, service)
+    if (comment) {
+      ops.comment = comment
+    }
+
+    return ctx.currentStore
+  }
+
+  /**
+   * @override
+   */
+  getPeerService (tags) {
+    let ns = tags['db.name']
+    if (ns && tags['peer.service'] === undefined) {
+      const dotIndex = ns.indexOf('.')
+      if (dotIndex !== -1) {
+        ns = ns.slice(0, dotIndex)
+      }
+      // the mongo ns is either dbName either dbName.collection. So we keep the first part
+      tags['peer.service'] = ns
+    }
+    return super.getPeerService(tags)
+  }
+
+  injectDbmComment (span, comment, serviceName) {
+    const dbmTraceComment = this.createDbmComment(span, serviceName)
+
+    if (!dbmTraceComment) {
+      return comment
+    }
+
+    if (comment) {
+      // if the command already has a comment, append the dbm trace comment
+      if (typeof comment === 'string') {
+        comment += `,${dbmTraceComment}`
+      } else if (Array.isArray(comment)) {
+        comment.push(dbmTraceComment)
+      } // do nothing if the comment is not a string or an array
+    } else {
+      comment = dbmTraceComment
+    }
+
+    return comment
+  }
+}
+
+function sanitizeBigInt (data) {
+  return JSON.stringify(data, (_key, value) => typeof value === 'bigint' ? value.toString() : value)
+}
+
+function extractQuery (statements) {
+  if (statements.length === 1 && statements[0].q) return statements[0].q
+
+  const extractedQueries = []
+  for (let i = 0; i < statements.length; i++) {
+    if (statements[i].q) {
+      extractedQueries.push(limitDepth(statements[i].q))
+    }
+  }
+
+  return extractedQueries
+}
+
+function getQuery (cmd) {
+  if (!cmd || (typeof cmd !== 'object' && !Array.isArray(cmd))) return
+
+  if (Array.isArray(cmd)) return sanitizeBigInt(extractQuery(cmd))
+  if (cmd.query) return sanitizeBigInt(limitDepth(cmd.query))
+  if (cmd.filter) return sanitizeBigInt(limitDepth(cmd.filter))
+  if (cmd.pipeline) return sanitizeBigInt(limitDepth(cmd.pipeline))
+  if (cmd.deletes) return sanitizeBigInt(extractQuery(cmd.deletes))
+  if (cmd.updates) return sanitizeBigInt(extractQuery(cmd.updates))
+}
+
+function getResource (plugin, ns, query, operationName) {
+  let resource = `${operationName} ${ns}`
+
+  if (plugin.config.queryInResourceName && query) {
+    resource += ` ${query}`
+  }
+
+  return resource
+}
+
+function truncate (input) {
+  return input.slice(0, Math.min(input.length, 10_000))
+}
+
+function shouldSimplify (input) {
+  return !isObject(input) || typeof input.toJSON === 'function'
+}
+
+function shouldHide (input) {
+  return Buffer.isBuffer(input) || typeof input === 'function' || isBinary(input)
+}
+
+function limitDepth (input) {
+  if (isBSON(input)) {
+    input = input.toJSON()
+  }
+
+  if (shouldHide(input)) return '?'
+  if (shouldSimplify(input)) return input
+
+  const output = {}
+  const queue = [{
+    input,
+    output,
+    depth: 0,
+  }]
+
+  while (queue.length) {
+    const {
+      input, output, depth,
+    } = queue.pop()
+    const nextDepth = depth + 1
+    for (const key in input) {
+      if (typeof input[key] === 'function') continue
+
+      let child = input[key]
+
+      if (isBSON(child)) {
+        child = typeof child.toJSON === 'function' ? child.toJSON() : '?'
+      }
+
+      if (depth >= 10 || shouldHide(child)) {
+        output[key] = '?'
+      } else if (shouldSimplify(child)) {
+        output[key] = child
+      } else {
+        queue.push({
+          input: child,
+          output: output[key] = {},
+          depth: nextDepth,
+        })
+      }
+    }
+  }
+
+  return output
+}
+
+function isObject (val) {
+  return val !== null && typeof val === 'object' && !Array.isArray(val)
+}
+
+function isBSON (val) {
+  return val && val._bsontype && !isBinary(val)
+}
+
+function isBinary (val) {
+  return val && val._bsontype === 'Binary'
+}
+
+function isHeartbeat (ops, config) {
+  // Check if it's a heartbeat command https://github.com/mongodb/specifications/blob/master/source/mongodb-handshake/handshake.md
+  return (
+    ops &&
+    typeof ops === 'object' &&
+    (ops.hello === 1 || ops.helloOk === true || ops.ismaster === 1 || ops.isMaster === 1)
+  )
+}
+
+module.exports = MongodbCorePlugin

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

@@ -0,0 +1,20 @@
+'use strict'
+
+const DatabasePlugin = require('../../dd-trace/src/plugins/database')
+const { storage } = require('../../datadog-core')
+
+class MongoosePlugin extends DatabasePlugin {
+  static id = 'mongoose'
+  static operation = 'exec'
+
+  bindStart (ctx) {
+    ctx.parentStore = storage('legacy').getStore()
+    return ctx.parentStore
+  }
+
+  bindFinish (ctx) {
+    return ctx.parentStore
+  }
+}
+
+module.exports = MongoosePlugin

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

@@ -0,0 +1,42 @@
+'use strict'
+
+const { storage } = require('../../datadog-core')
+const CLIENT_PORT_KEY = require('../../dd-trace/src/constants')
+const DatabasePlugin = require('../../dd-trace/src/plugins/database')
+
+class MySQLPlugin extends DatabasePlugin {
+  static id = 'mysql'
+  static system = 'mysql'
+
+  constructor () {
+    super(...arguments)
+
+    this.addSub(`apm:${this.component}:connection:start`, ctx => {
+      ctx.parentStore = storage('legacy').getStore()
+    })
+
+    this.addBind(`apm:${this.component}:connection:finish`, ctx => ctx.parentStore)
+  }
+
+  bindStart (ctx) {
+    const service = this.serviceName({ pluginConfig: this.config, dbConfig: ctx.conf, system: this.system })
+    const span = this.startSpan(this.operationName(), {
+      service,
+      resource: ctx.sql,
+      type: 'sql',
+      kind: 'client',
+      meta: {
+        'db.type': this.system,
+        'db.user': ctx.conf.user,
+        'db.name': ctx.conf.database,
+        'out.host': ctx.conf.host,
+        [CLIENT_PORT_KEY]: ctx.conf.port,
+      },
+    }, ctx)
+    ctx.sql = this.injectDbmQuery(span, ctx.sql, service)
+
+    return ctx.currentStore
+  }
+}
+
+module.exports = MySQLPlugin

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

@@ -0,0 +1,25 @@
+'use strict'
+
+const { storage } = require('../../datadog-core')
+const MySQLPlugin = require('../../datadog-plugin-mysql/src')
+
+class MySQL2Plugin extends MySQLPlugin {
+  static id = 'mysql2'
+
+  constructor () {
+    super(...arguments)
+
+    this.addSub(`apm:${this.component}:command:add`, ctx => {
+      ctx.parentStore = storage('legacy').getStore()
+    })
+
+    this.addBind(`apm:${this.component}:command:start`, ctx => ctx.parentStore)
+    this.addBind(`apm:${this.component}:command:finish`, ctx => ctx.parentStore)
+  }
+
+  bindStart (ctx) {
+    return storage('legacy').run(ctx.parentStore, () => super.bindStart(ctx))
+  }
+}
+
+module.exports = MySQL2Plugin

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

@@ -0,0 +1,23 @@
+'use strict'
+
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const NetIPCPlugin = require('./ipc')
+const NetTCPPlugin = require('./tcp')
+
+class NetPlugin extends Plugin {
+  static id = 'net'
+
+  constructor (...args) {
+    super(...args)
+
+    this._ipc = new NetIPCPlugin(...args)
+    this._tcp = new NetTCPPlugin(...args)
+  }
+
+  configure (config) {
+    this._ipc.configure(config)
+    this._tcp.configure(config)
+  }
+}
+
+module.exports = NetPlugin

package/packages/datadog-plugin-net/src/ipc.js

@@ -0,0 +1,23 @@
+'use strict'
+
+const ClientPlugin = require('../../dd-trace/src/plugins/client')
+
+class NetIPCPlugin extends ClientPlugin {
+  static id = 'net'
+  static operation = 'ipc'
+
+  bindStart (ctx) {
+    this.startSpan('ipc.connect', {
+      service: this.config.service,
+      resource: ctx.options.path,
+      kind: 'client',
+      meta: {
+        'ipc.path': ctx.options.path,
+      },
+    }, ctx)
+
+    return ctx.currentStore
+  }
+}
+
+module.exports = NetIPCPlugin

package/packages/datadog-plugin-net/src/tcp.js

@@ -0,0 +1,53 @@
+'use strict'
+
+const { CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
+const ClientPlugin = require('../../dd-trace/src/plugins/client')
+
+class NetTCPPlugin extends ClientPlugin {
+  static id = 'net'
+  static operation = 'tcp'
+
+  constructor (...args) {
+    super(...args)
+
+    this.addTraceBind('ready', (ctx) => {
+      return ctx.parentStore
+    })
+
+    this.addTraceSub('connection', (ctx) => {
+      const span = ctx.currentStore.span
+
+      span.addTags({
+        'tcp.local.address': ctx.socket.localAddress,
+        'tcp.local.port': ctx.socket.localPort,
+      })
+    })
+  }
+
+  bindStart (ctx) {
+    const host = ctx.options.host || 'localhost'
+    const port = ctx.options.port || 0
+    const family = ctx.options.family || 4
+
+    this.startSpan('tcp.connect', {
+      service: this.config.service,
+      resource: [host, port].filter(Boolean).join(':'),
+      kind: 'client',
+      meta: {
+        'tcp.remote.host': host,
+        'tcp.family': `IPv${family}`,
+        'tcp.local.address': '',
+        'out.host': host,
+      },
+      metrics: {
+        'tcp.remote.port': port,
+        'tcp.local.port': 0,
+        [CLIENT_PORT_KEY]: port,
+      },
+    }, ctx)
+
+    return ctx.currentStore
+  }
+}
+
+module.exports = NetTCPPlugin

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

@@ -0,0 +1,155 @@
+'use strict'
+
+const ServerPlugin = require('../../dd-trace/src/plugins/server')
+const { storage } = require('../../datadog-core')
+const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
+const { COMPONENT } = require('../../dd-trace/src/constants')
+const web = require('../../dd-trace/src/plugins/util/web')
+
+const errorPages = new Set(['/404', '/500', '/_error', '/_not-found', '/_not-found/page'])
+
+class NextPlugin extends ServerPlugin {
+  static id = 'next'
+  #requestsBySpanId = new WeakMap()
+
+  constructor (...args) {
+    super(...args)
+    this.addSub('apm:next:page:load', message => this.pageLoad(message))
+  }
+
+  bindStart ({ req, res }) {
+    const store = storage('legacy').getStore()
+    const childOf = store ? store.span : store
+    const span = this.tracer.startSpan(this.operationName(), {
+      childOf,
+      tags: {
+        [COMPONENT]: this.constructor.id,
+        'service.name': this.config.service || this.serviceName(),
+        'resource.name': req.method,
+        'span.type': 'web',
+        'span.kind': 'server',
+        'http.method': req.method,
+      },
+      integrationName: this.constructor.id,
+    })
+
+    analyticsSampler.sample(span, this.config.measured, true)
+
+    // Store request by span ID to handle cases where child spans are activated
+    const spanId = span.context()._spanId
+    this.#requestsBySpanId.set(spanId, req)
+
+    return { ...store, span }
+  }
+
+  error ({ span, error }) {
+    if (!span) {
+      const store = storage('legacy').getStore()
+      if (!store) return
+
+      span = store.span
+    }
+
+    this.addError(error, span)
+  }
+
+  finish ({ req, res, nextRequest = {} }) {
+    const store = storage('legacy').getStore()
+
+    if (!store) return
+
+    const span = store.span
+    const error = span.context()._tags.error
+    const requestError = req.error || nextRequest.error
+
+    if (requestError) {
+      // prioritize user-set errors from API routes
+      span.setTag('error', requestError)
+      web.addError(req, requestError)
+    } else if (error) {
+      // general error handling
+      span.setTag('error', error)
+      web.addError(req, requestError || error)
+    } else if (!this.config.validateStatus(res.statusCode)) {
+      // where there's no error, we still need to validate status
+      span.setTag('error', true)
+      web.addError(req, true)
+    }
+
+    span.addTags({
+      'http.status_code': res.statusCode,
+    })
+
+    this.config.hooks.request(span, req, res)
+
+    span.finish()
+  }
+
+  pageLoad ({ page, isAppPath = false, isStatic = false }) {
+    const store = storage('legacy').getStore()
+
+    if (!store) return
+
+    const span = store.span
+
+    const spanId = span.context()._spanId
+    const parentSpanId = span.context()._parentId
+
+    // Try current span first, then parent span.
+    // This handles cases where pageLoad runs in a child span context
+    const req = this.#requestsBySpanId.get(spanId) ?? this.#requestsBySpanId.get(parentSpanId)
+
+    // safeguard against missing req in complicated timeout scenarios
+    if (!req) return
+
+    // Only use error page names if there's not already a name
+    const current = span.context()._tags['next.page']
+    const isErrorPage = errorPages.has(page)
+
+    if (current && isErrorPage) {
+      return
+    }
+
+    // remove ending /route or /page for appDir projects
+    // need to check if not an error page too, as those are marked as app directory
+    // in newer versions
+    if (isAppPath && !isErrorPage) page = page.slice(0, Math.max(0, page.lastIndexOf('/')))
+
+    // handle static resource
+    if (isStatic) {
+      page = req.url.includes('_next/static')
+        ? '/_next/static/*'
+        : '/public/*'
+    }
+
+    span.addTags({
+      [COMPONENT]: this.constructor.id,
+      'resource.name': `${req.method} ${page}`.trim(),
+      'next.page': page,
+    })
+    web.setRoute(req, page)
+  }
+
+  configure (config) {
+    return super.configure(normalizeConfig(config))
+  }
+}
+
+function normalizeConfig (config) {
+  const hooks = getHooks(config)
+  const validateStatus = typeof config.validateStatus === 'function'
+    ? config.validateStatus
+    : code => code < 500
+
+  return { ...config, hooks, validateStatus }
+}
+
+const noop = () => {}
+
+function getHooks (config) {
+  const request = config.hooks?.request ?? noop
+
+  return { request }
+}
+
+module.exports = NextPlugin

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

@@ -0,0 +1,95 @@
+'use strict'
+
+const { readFileSync, existsSync } = require('node:fs')
+
+const CiPlugin = require('../../dd-trace/src/plugins/ci_plugin')
+const log = require('../../dd-trace/src/log')
+const { getSettingsCachePath } = require('../../dd-trace/src/ci-visibility/test-optimization-cache')
+
+class NycPlugin extends CiPlugin {
+  static id = 'nyc'
+
+  constructor (...args) {
+    super(...args)
+
+    this.addSub('ci:nyc:wrap', (nyc) => {
+      if (nyc?.config?.all) {
+        this.nyc = nyc
+      }
+    })
+
+    this.addSub('ci:nyc:get-coverage', ({ onDone }) => {
+      if (this.nyc?.getCoverageMapFromAllCoverageFiles) {
+        this.nyc.getCoverageMapFromAllCoverageFiles()
+          .then((untestedCoverageMap) => {
+            this.nyc = null
+            onDone(untestedCoverageMap)
+          }).catch((e) => {
+            this.nyc = null
+            onDone()
+          })
+      } else {
+        this.nyc = null
+        onDone()
+      }
+    })
+
+    this.addSub('ci:nyc:report', ({ rootDir, onDone }) => {
+      this.handleCoverageReport(rootDir, onDone)
+    })
+  }
+
+  /**
+   * Reads the library configuration from the settings cache file.
+   * @returns {object|undefined} The library configuration settings, or undefined if not available.
+   */
+  readLibraryConfiguration () {
+    const settingsCachePath = getSettingsCachePath()
+    if (!settingsCachePath) {
+      log.debug('Settings cache path not set (DD_EXPERIMENTAL_TEST_OPT_SETTINGS_CACHE)')
+      return
+    }
+
+    if (!existsSync(settingsCachePath)) {
+      log.debug('Settings cache file not found at %s', settingsCachePath)
+      return
+    }
+
+    try {
+      const content = readFileSync(settingsCachePath, 'utf8')
+      return JSON.parse(content)
+    } catch (err) {
+      log.debug('Failed to read settings cache: %s', err.message)
+    }
+  }
+
+  /**
+   * Handles the coverage report by discovering and uploading it if enabled.
+   * @param {string} rootDir - The root directory where coverage reports are located.
+   * @param {Function} [onDone] - Callback to signal completion.
+   */
+  handleCoverageReport (rootDir, onDone) {
+    const done = onDone || (() => {})
+
+    const libraryConfig = this.readLibraryConfiguration()
+    if (!libraryConfig) {
+      log.debug('Library configuration not found in settings cache')
+      done()
+      return
+    }
+
+    if (!libraryConfig.isCoverageReportUploadEnabled) {
+      log.debug('Coverage report upload is not enabled')
+      done()
+      return
+    }
+
+    this.uploadCoverageReports({
+      rootDir,
+      testEnvironmentMetadata: this.testEnvironmentMetadata,
+      onDone: done,
+    })
+  }
+}
+
+module.exports = NycPlugin

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

@@ -0,0 +1,17 @@
+'use strict'
+
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+const OpenAiLLMObsPlugin = require('../../dd-trace/src/llmobs/plugins/openai')
+const OpenAiTracingPlugin = require('./tracing')
+
+class OpenAiPlugin extends CompositePlugin {
+  static id = 'openai'
+  static get plugins () {
+    return {
+      llmobs: OpenAiLLMObsPlugin,
+      tracing: OpenAiTracingPlugin,
+    }
+  }
+}
+
+module.exports = OpenAiPlugin