dd-trace 3.12.1 → 3.13.1

package/ci/init.js

@@ -34,6 +34,7 @@ so dd-trace will not be initialized.`)
 
 if (shouldInit) {
   tracer.init(options)
+  tracer.use('fs', false)
 }
 
 module.exports = tracer

package/index.d.ts

@@ -115,6 +115,8 @@ export declare interface Tracer extends opentracing.Tracer {
    * @returns {Tracer} The Tracer instance for chaining.
    */
   setUser (user: User): Tracer;
+
+  appsec: Appsec;
 }
 
 export declare interface TraceOptions extends Analyzable {
@@ -537,6 +539,17 @@ export declare interface TracerOptions {
      */
     pollInterval?: number,
   }
+
+  /**
+   * Whether to enable client IP collection from relevant IP headers
+   * @default false
+   */
+  clientIpEnabled?: boolean
+
+  /**
+   * Custom header name to source the http.client_ip tag from.
+   */
+  clientIpHeader?: string,
 }
 
 /**
@@ -582,6 +595,36 @@ export declare interface User {
   [key: string]: string | undefined
 }
 
+export declare interface Appsec {
+  /**
+   * Links a successful login event to the current trace. Will link the passed user to the current trace with Appsec.setUser() internally.
+   * @param {User} user Properties of the authenticated user. Accepts custom fields.
+   * @param {[key: string]: string} metadata Custom fields to link to the login success event.
+   *
+   * @beta This method is in beta and could change in future versions.
+   */
+  trackUserLoginSuccessEvent(user: User, metadata?: { [key: string]: string }): void
+
+  /**
+   * Links a failed login event to the current trace.
+   * @param {string} userId The user id of the attemped login.
+   * @param {boolean} exists If the user id exists.
+   * @param {[key: string]: string} metadata Custom fields to link to the login failure event.
+   *
+   * @beta This method is in beta and could change in future versions.
+   */
+  trackUserLoginFailureEvent(userId: string, exists: boolean, metadata?: { [key: string]: string }): void
+
+  /**
+   * Links a custom event to the current trace.
+   * @param {string} eventName The name of the event.
+   * @param {[key: string]: string} metadata Custom fields to link to the event.
+   *
+   * @beta This method is in beta and could change in future versions.
+   */
+  trackCustomEvent(eventName: string, metadata?: { [key: string]: string }): void
+}
+
 /** @hidden */
 declare type anyObject = {
   [key: string]: any;
@@ -669,6 +712,7 @@ interface Plugins {
   "opensearch": plugins.opensearch;
   "oracledb": plugins.oracledb;
   "paperplane": plugins.paperplane;
+  "playwright": plugins.playwright;
   "pg": plugins.pg;
   "pino": plugins.pino;
   "redis": plugins.redis;
@@ -1358,6 +1402,12 @@ declare namespace plugins {
    */
   interface paperplane extends HttpServer {}
 
+  /**
+  * This plugin automatically instruments the
+  * [playwright](https://github.com/microsoft/playwright) module.
+  */
+  interface playwright extends Integration {}
+
   /**
    * This plugin automatically instruments the
    * [pg](https://node-postgres.com/) module.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "3.12.1",
+  "version": "3.13.1",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",

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

@@ -0,0 +1,358 @@
+
+'use strict'
+
+const {
+  channel,
+  addHook,
+  AsyncResource
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+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
+
+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']
+names.forEach(name => {
+  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 innerResource = new AsyncResource('bound-anonymous-fn')
+    const message = getMessage(name, ['path', 'options'], arguments)
+
+    return innerResource.runInAsyncScope(() => {
+      startChannel.publish(message)
+
+      try {
+        const stream = original.apply(this, arguments)
+        const onError = innerResource.bind(error => {
+          errorChannel.publish(error)
+          onFinish()
+        })
+        const onFinish = innerResource.bind(() => {
+          finishChannel.publish()
+          stream.off('close', onFinish)
+          stream.off('end', onFinish)
+          stream.off('finish', onFinish)
+          stream.off('error', onError)
+        })
+
+        stream.once('close', onFinish)
+        stream.once('end', onFinish)
+        stream.once('finish', onFinish)
+        stream.once('error', onError)
+
+        return stream
+      } catch (error) {
+        errorChannel.publish(error)
+        finishChannel.publish()
+      }
+    })
+  }
+}
+
+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 message = getMessage(method, watchMethods[operation], arguments, this)
+      const innerResource = new AsyncResource('bound-anonymous-fn')
+      return innerResource.runInAsyncScope(() => {
+        startChannel.publish(message)
+        try {
+          const result = original.apply(this, arguments)
+          finishChannel.publish()
+          return result
+        } catch (error) {
+          errorChannel.publish(error)
+          finishChannel.publish()
+          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 innerResource = new AsyncResource('bound-anonymous-fn')
+      const message = getMessage(method, getMethodParamsRelationByPrefix(prefix)[operation], arguments, this)
+
+      if (cb) {
+        const outerResource = new AsyncResource('bound-anonymous-fn')
+
+        arguments[lastIndex] = innerResource.bind(function (e) {
+          if (typeof e === 'object') { // fs.exists receives a boolean
+            errorChannel.publish(e)
+          }
+
+          finishChannel.publish()
+
+          return outerResource.runInAsyncScope(() => cb.apply(this, arguments))
+        })
+      }
+
+      return innerResource.runInAsyncScope(() => {
+        startChannel.publish(message)
+        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.publish()
+                return value
+              },
+              error => {
+                errorChannel.publish(error)
+                finishChannel.publish()
+                throw error
+              }
+            )
+          }
+
+          finishChannel.publish()
+
+          return result
+        } catch (error) {
+          errorChannel.publish(error)
+          finishChannel.publish()
+          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 (e) {
+    // skip unavailable method
+  }
+}

package/packages/datadog-instrumentations/src/helpers/hooks.js

@@ -2,6 +2,7 @@
 
 module.exports = {
   '@cucumber/cucumber': () => require('../cucumber'),
+  '@playwright/test': () => require('../playwright'),
   '@elastic/elasticsearch': () => require('../elasticsearch'),
   '@elastic/transport': () => require('../elasticsearch'),
   '@google-cloud/pubsub': () => require('../google-cloud-pubsub'),
@@ -31,6 +32,8 @@ module.exports = {
   'express': () => require('../express'),
   'fastify': () => require('../fastify'),
   'find-my-way': () => require('../find-my-way'),
+  'fs': () => require('../fs'),
+  'node:fs': () => require('../fs'),
   'graphql': () => require('../graphql'),
   'grpc': () => require('../grpc'),
   'hapi': () => require('../hapi'),

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

@@ -218,9 +218,19 @@ function cliWrapper (cli) {
 
     const isSuitesSkipped = !!skippableSuites.length
 
+    let testFrameworkVersion
+    try {
+      testFrameworkVersion = this.getVersion()
+    } catch (e) {
+      try {
+        testFrameworkVersion = this.default.getVersion()
+      } catch (e) {
+        // ignore errors
+      }
+    }
     const processArgv = process.argv.slice(2).join(' ')
     sessionAsyncResource.runInAsyncScope(() => {
-      testSessionStartCh.publish(`jest ${processArgv}`)
+      testSessionStartCh.publish({ command: `jest ${processArgv}`, testFrameworkVersion })
     })
 
     const result = await runCLI.apply(this, arguments)

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

@@ -39,6 +39,7 @@ const testFileToSuiteAr = new Map()
 const originalCoverageMap = createCoverageMap()
 
 let suitesToSkip = []
+let mochaVersion
 
 function getSuitesByTestFile (root) {
   const suitesByTestFile = {}
@@ -128,7 +129,7 @@ function mochaHook (Runner) {
     this.once('start', testRunAsyncResource.bind(function () {
       const processArgv = process.argv.slice(2).join(' ')
       const command = `mocha ${processArgv}`
-      testSessionStartCh.publish(command)
+      testSessionStartCh.publish({ command, frameworkVersion: mochaVersion })
     }))
 
     this.on('suite', function (suite) {
@@ -315,12 +316,12 @@ addHook({
   file: 'lib/mocha.js'
 }, (Mocha) => {
   const mochaRunAsyncResource = new AsyncResource('bound-anonymous-fn')
-
   /**
    * Get ITR configuration and skippable suites
    * If ITR is disabled, `onDone` is called immediately on the subscriber
    */
   shimmer.wrap(Mocha.prototype, 'run', run => function () {
+    mochaVersion = this.version
     if (!itrConfigurationCh.hasSubscribers) {
       return run.apply(this, arguments)
     }

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

@@ -19,13 +19,19 @@ addHook({ name: 'mysql', file: 'lib/Connection.js', versions: ['>=2'] }, Connect
 
     const sql = arguments[0].sql ? arguments[0].sql : arguments[0]
     const conf = this.config
+    const payload = { sql, conf }
 
     const callbackResource = new AsyncResource('bound-anonymous-fn')
     const asyncResource = new AsyncResource('bound-anonymous-fn')
 
     return asyncResource.runInAsyncScope(() => {
-      startCh.publish({ sql, conf })
+      startCh.publish(payload)
 
+      if (arguments[0].sql) {
+        arguments[0].sql = payload.sql
+      } else {
+        arguments[0] = payload.sql
+      }
       try {
         const res = query.apply(this, arguments)
 

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

@@ -45,8 +45,14 @@ addHook({ name: 'mysql2', file: 'lib/connection.js', versions: ['>=1'] }, Connec
 
     return asyncResource.bind(function executeWithTrace (packet, connection) {
       const sql = cmd.statement ? cmd.statement.query : cmd.sql
+      const payload = { sql, conf: config }
+      startCh.publish(payload)
 
-      startCh.publish({ sql, conf: config })
+      if (cmd.statement) {
+        cmd.statement.query = payload.sql
+      } else {
+        cmd.sql = payload.sql
+      }
 
       if (this.onResult) {
         const onResult = callbackResource.bind(this.onResult)