dd-trace 5.63.2 → 5.64.0

package/index.d.ts

@@ -712,6 +712,16 @@ declare namespace tracer {
          * @default true
          */
         enabled?: boolean,
+
+        /** Whether to enable endpoint collection for API Security.
+         * @default true
+         */
+        endpointCollectionEnabled?: boolean,
+
+        /** Maximum number of endpoints that can be serialized per message.
+         * @default 300
+         */
+        endpointCollectionMessageLimit?: number,
       },
       /**
        * Configuration for RASP

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.63.2",
+  "version": "5.64.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -174,7 +174,7 @@
     "jszip": "^3.10.1",
     "mocha": "^11.6.0",
     "multer": "^2.0.2",
-    "nock": "^11.9.1",
+    "nock": "^13.5.6",
     "nyc": "^15.1.0",
     "octokit": "^5.0.3",
     "proxyquire": "^1.8.0",

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

@@ -98,7 +98,18 @@ function wrapWithTracer (fn) {
   return function () {
     const options = arguments[0]
 
-    options.experimental_telemetry ??= { isEnabled: true, tracer: noopTracer }
+    const experimentalTelemetry = options.experimental_telemetry
+    if (experimentalTelemetry?.isEnabled === false) {
+      return fn.apply(this, arguments)
+    }
+
+    if (experimentalTelemetry == null) {
+      options.experimental_telemetry = { isEnabled: true, tracer: noopTracer }
+    } else {
+      experimentalTelemetry.isEnabled = true
+      experimentalTelemetry.tracer ??= noopTracer
+    }
+
     wrapTracer(options.experimental_telemetry.tracer)
 
     return fn.apply(this, arguments)

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

@@ -166,6 +166,9 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           this.knownTestsForThisSuite = hasKnownTests
             ? (knownTests?.jest?.[this.testSuite] || [])
             : this.getKnownTestsForSuite(this.testEnvironmentOptions._ddKnownTests)
+          log.debug(`this.knownTestsForThisSuite is an array: ${Array.isArray(this.knownTestsForThisSuite)}`)
+          log.debug(`this.knownTestsForThisSuite is null: ${this.knownTestsForThisSuite === null}`)
+          log.debug(`this.knownTestsForThisSuite is undefined: ${this.knownTestsForThisSuite === undefined}`)
         } catch {
           // If there has been an error parsing the tests, we'll disable Early Flake Deteciton
           this.isEarlyFlakeDetectionEnabled = false
@@ -469,7 +472,10 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           }
         }
         if (this.isKnownTestsEnabled) {
-          const isNew = !this.knownTestsForThisSuite?.includes(originalTestName)
+          // Check if knownTestsForThisSuite is an array, since the worker may not have provided this information.
+          // If it's null or undefined, we can't determine if the test is new.
+          const isNew = Array.isArray(this.knownTestsForThisSuite) &&
+            !this.knownTestsForThisSuite.includes(originalTestName)
           if (isNew && !isSkipped && !retriedTestsToNumAttempts.has(originalTestName)) {
             retriedTestsToNumAttempts.set(originalTestName, 0)
             if (this.isEarlyFlakeDetectionEnabled) {

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

@@ -148,8 +148,8 @@ function getPlaywrightConfig (playwrightRunner) {
   }
 }
 
-function getRootDir (playwrightRunner) {
-  const config = getPlaywrightConfig(playwrightRunner)
+function getRootDir (playwrightRunner, configArg) {
+  const config = configArg?.config || getPlaywrightConfig(playwrightRunner)
   if (config.rootDir) {
     return config.rootDir
   }
@@ -162,8 +162,8 @@ function getRootDir (playwrightRunner) {
   return process.cwd()
 }
 
-function getProjectsFromRunner (runner) {
-  const config = getPlaywrightConfig(runner)
+function getProjectsFromRunner (runner, configArg) {
+  const config = configArg?.projects ? configArg : getPlaywrightConfig(runner)
   return config.projects?.map((project) => {
     if (project.project) {
       return project.project
@@ -509,11 +509,12 @@ function dispatcherHookNew (dispatcherExport, runWrapper) {
   return dispatcherExport
 }
 
-function runnerHook (runnerExport, playwrightVersion) {
-  shimmer.wrap(runnerExport.Runner.prototype, 'runAllTests', runAllTests => async function () {
+function runAllTestsWrapper (runAllTests, playwrightVersion) {
+  // Config parameter is only available from >=1.55.0
+  return async function (config) {
     let onDone
 
-    rootDir = getRootDir(this)
+    rootDir = getRootDir(this, config)
 
     const processArgv = process.argv.slice(2).join(' ')
     const command = `playwright ${processArgv}`
@@ -586,7 +587,7 @@ function runnerHook (runnerExport, playwrightVersion) {
       }
     }
 
-    const projects = getProjectsFromRunner(this)
+    const projects = getProjectsFromRunner(this, config)
 
     const shouldSetRetries = isFlakyTestRetriesEnabled &&
       flakyTestRetriesCount > 0 &&
@@ -651,6 +652,23 @@ function runnerHook (runnerExport, playwrightVersion) {
     // TODO: we can trick playwright into thinking the session passed by returning
     // 'passed' here. We might be able to use this for both EFD and Test Management tests.
     return runAllTestsReturn
+  }
+}
+
+function runnerHook (runnerExport, playwrightVersion) {
+  shimmer.wrap(
+    runnerExport.Runner.prototype,
+    'runAllTests',
+    runAllTests => runAllTestsWrapper(runAllTests, playwrightVersion)
+  )
+}
+
+function runnerHookNew (runnerExport, playwrightVersion) {
+  runnerExport = shimmer.wrap(runnerExport, 'runAllTestsWithConfig', function (originalGetter) {
+    const originalFunction = originalGetter.call(this)
+    return function () {
+      return runAllTestsWrapper(originalFunction, playwrightVersion)
+    }
   })
 
   return runnerExport
@@ -694,6 +712,12 @@ addHook({
   versions: ['>=1.38.0']
 }, runnerHook)
 
+addHook({
+  name: 'playwright',
+  file: 'lib/runner/testRunner.js',
+  versions: ['>=1.55.0']
+}, runnerHookNew)
+
 addHook({
   name: 'playwright',
   file: 'lib/runner/dispatcher.js',

package/packages/datadog-plugin-prisma/src/engine.js

@@ -53,8 +53,8 @@ class PrismaEngine extends DatabasePlugin {
       options.resource = originalStatement
       options.type = type || engineSpan.attributes['db.system']
       options.meta['db.type'] = dbType || engineSpan.attributes['db.system']
-      options.meta['db.instance'] = dbConfig?.database
-      options.meta['db.name'] = dbConfig?.user
+      options.meta['db.name'] = dbConfig?.database
+      options.meta['db.user'] = dbConfig?.user
       options.meta['out.host'] = dbConfig?.host
       options.meta[CLIENT_PORT_KEY] = dbConfig?.port
     }

package/packages/dd-trace/src/config.js

@@ -323,12 +323,6 @@ class Config {
       }
     }
 
-    if (typeof options.runtimeMetrics?.gc === 'boolean') {
-      options.runtimeMetrics.gc = {
-        enabled: options.runtimeMetrics.gc
-      }
-    }
-
     const DD_INSTRUMENTATION_INSTALL_ID = coalesce(
       getEnvironmentVariable('DD_INSTRUMENTATION_INSTALL_ID'),
       null
@@ -493,6 +487,8 @@ class Config {
     defaults.apmTracingEnabled = true
     defaults['appsec.apiSecurity.enabled'] = true
     defaults['appsec.apiSecurity.sampleDelay'] = 30
+    defaults['appsec.apiSecurity.endpointCollectionEnabled'] = true
+    defaults['appsec.apiSecurity.endpointCollectionMessageLimit'] = 300
     defaults['appsec.blockedTemplateGraphql'] = undefined
     defaults['appsec.blockedTemplateHtml'] = undefined
     defaults['appsec.blockedTemplateJson'] = undefined
@@ -690,6 +686,8 @@ class Config {
       DD_AGENT_HOST,
       DD_API_SECURITY_ENABLED,
       DD_API_SECURITY_SAMPLE_DELAY,
+      DD_API_SECURITY_ENDPOINT_COLLECTION_ENABLED,
+      DD_API_SECURITY_ENDPOINT_COLLECTION_MESSAGE_LIMIT,
       DD_APM_TRACING_ENABLED,
       DD_APPSEC_AUTO_USER_INSTRUMENTATION_MODE,
       DD_APPSEC_COLLECT_ALL_HEADERS,
@@ -846,6 +844,10 @@ class Config {
     ))
     this._setBoolean(env, 'appsec.apiSecurity.enabled', DD_API_SECURITY_ENABLED && isTrue(DD_API_SECURITY_ENABLED))
     env['appsec.apiSecurity.sampleDelay'] = maybeFloat(DD_API_SECURITY_SAMPLE_DELAY)
+    this._setBoolean(env, 'appsec.apiSecurity.endpointCollectionEnabled',
+      DD_API_SECURITY_ENDPOINT_COLLECTION_ENABLED)
+    env['appsec.apiSecurity.endpointCollectionMessageLimit'] =
+      maybeInt(DD_API_SECURITY_ENDPOINT_COLLECTION_MESSAGE_LIMIT)
     env['appsec.blockedTemplateGraphql'] = maybeFile(DD_APPSEC_GRAPHQL_BLOCKED_TEMPLATE_JSON)
     env['appsec.blockedTemplateHtml'] = maybeFile(DD_APPSEC_HTTP_BLOCKED_TEMPLATE_HTML)
     this._envUnprocessed['appsec.blockedTemplateHtml'] = DD_APPSEC_HTTP_BLOCKED_TEMPLATE_HTML
@@ -1073,6 +1075,10 @@ class Config {
       options.experimental?.appsec?.standalone && !options.experimental.appsec.standalone.enabled
     ))
     this._setBoolean(opts, 'appsec.apiSecurity.enabled', options.appsec?.apiSecurity?.enabled)
+    this._setBoolean(opts, 'appsec.apiSecurity.endpointCollectionEnabled',
+      options.appsec?.apiSecurity?.endpointCollectionEnabled)
+    opts['appsec.apiSecurity.endpointCollectionMessageLimit'] =
+      maybeInt(options.appsec?.apiSecurity?.endpointCollectionMessageLimit)
     opts['appsec.blockedTemplateGraphql'] = maybeFile(options.appsec?.blockedTemplateGraphql)
     opts['appsec.blockedTemplateHtml'] = maybeFile(options.appsec?.blockedTemplateHtml)
     this._optsUnprocessed['appsec.blockedTemplateHtml'] = options.appsec?.blockedTemplateHtml
@@ -1190,7 +1196,7 @@ class Config {
     this._setBoolean(opts, 'reportHostname', options.reportHostname)
     this._setBoolean(opts, 'runtimeMetrics.enabled', options.runtimeMetrics?.enabled)
     this._setBoolean(opts, 'runtimeMetrics.eventLoop', options.runtimeMetrics?.eventLoop)
-    this._setBoolean(opts, 'runtimeMetrics.gc', options.runtimeMetrics?.gc?.enabled)
+    this._setBoolean(opts, 'runtimeMetrics.gc', options.runtimeMetrics?.gc)
     this._setBoolean(opts, 'runtimeMetricsRuntimeId', options.runtimeMetricsRuntimeId)
     this._setArray(opts, 'sampler.spanSamplingRules', reformatSpanSamplingRules(options.spanSamplingRules))
     this._setUnit(opts, 'sampleRate', coalesce(options.sampleRate, options.ingestion.sampleRate))

package/packages/dd-trace/src/opentracing/tracer.js

@@ -86,7 +86,7 @@ class DatadogTracer {
     }
 
     try {
-      if (format !== 'text_map_dsm') {
+      if (format !== 'text_map_dsm' && format !== formats.LOG) {
         this._prioritySampler.sample(context)
       }
       this._propagators[format].inject(context, carrier)

package/packages/dd-trace/src/runtime_metrics/runtime_metrics.js

@@ -274,9 +274,10 @@ function startGCObserver () {
   gcObserver = new PerformanceObserver(list => {
     for (const entry of list.getEntries()) {
       const type = gcType(entry.detail?.kind || entry.kind)
+      const duration = entry.duration * 1_000_000
 
-      runtimeMetrics.histogram('runtime.node.gc.pause.by.type', entry.duration, `gc_type:${type}`)
-      runtimeMetrics.histogram('runtime.node.gc.pause', entry.duration)
+      runtimeMetrics.histogram('runtime.node.gc.pause.by.type', duration, `gc_type:${type}`)
+      runtimeMetrics.histogram('runtime.node.gc.pause', duration)
     }
   })
 

package/packages/dd-trace/src/supported-configurations.json

@@ -8,6 +8,8 @@
     "DD_API_KEY": ["A"],
     "DD_API_SECURITY_ENABLED": ["A"],
     "DD_API_SECURITY_SAMPLE_DELAY": ["A"],
+    "DD_API_SECURITY_ENDPOINT_COLLECTION_ENABLED": ["A"],
+    "DD_API_SECURITY_ENDPOINT_COLLECTION_MESSAGE_LIMIT": ["A"],
     "DD_APM_FLUSH_DEADLINE_MILLISECONDS": ["A"],
     "DD_APM_TRACING_ENABLED": ["A"],
     "DD_APPSEC_AUTO_USER_INSTRUMENTATION_MODE": ["A"],

package/packages/dd-trace/src/telemetry/endpoints.js

@@ -0,0 +1,124 @@
+'use strict'
+
+const dc = require('dc-polyfill')
+const { sendData } = require('./send-data')
+
+const fastifyRouteCh = dc.channel('apm:fastify:route:added')
+
+let config
+let application
+let host
+let getRetryData
+let updateRetryData
+
+/**
+ * Keep track of endpoints that still need to be sent.
+ * Map key is `${METHOD} ${PATH}`, value is { method, path }
+ */
+const pendingEndpoints = new Map()
+let flushScheduled = false
+let isFirstPayload = true
+
+function endpointKey (method, path) {
+  return `${method.toUpperCase()} ${path}`
+}
+
+function scheduleFlush () {
+  if (flushScheduled) return
+  flushScheduled = true
+  setImmediate(flushAndSend).unref()
+}
+
+function recordEndpoint (method, path) {
+  const key = endpointKey(method, path)
+  if (pendingEndpoints.has(key)) return
+
+  pendingEndpoints.set(key, { method: method.toUpperCase(), path })
+  scheduleFlush()
+}
+
+function onFastifyRoute (routeData) {
+  const routeOptions = routeData?.routeOptions
+  if (!routeOptions?.path) return
+
+  const methods = Array.isArray(routeOptions.method) ? routeOptions.method : [routeOptions.method]
+
+  for (const method of methods) {
+    recordEndpoint(method, routeOptions.path)
+  }
+}
+
+function buildEndpointObjects (endpoints) {
+  return endpoints.map(({ method, path }) => {
+    return {
+      type: 'REST',
+      method,
+      path,
+      operation_name: 'http.request',
+      resource_name: endpointKey(method, path)
+    }
+  })
+}
+
+function flushAndSend () {
+  flushScheduled = false
+  if (pendingEndpoints.size === 0) return
+
+  const batchEndpoints = []
+  for (const [key, endpoint] of pendingEndpoints) {
+    batchEndpoints.push(endpoint)
+    pendingEndpoints.delete(key)
+    if (batchEndpoints.length >= config.appsec?.apiSecurity?.endpointCollectionMessageLimit) break
+  }
+
+  const payloadObj = {
+    is_first: isFirstPayload,
+    endpoints: buildEndpointObjects(batchEndpoints)
+  }
+
+  let reqType = 'app-endpoints'
+  let payload = payloadObj
+
+  const retryData = getRetryData()
+  if (retryData) {
+    payload = [
+      { request_type: 'app-endpoints', payload: payloadObj },
+      { request_type: retryData.reqType, payload: retryData.payload }
+    ]
+    reqType = 'message-batch'
+  }
+
+  sendData(config, application, host, reqType, payload, updateRetryData)
+
+  if (isFirstPayload) {
+    isFirstPayload = false
+  }
+
+  // If more endpoints accumulated while sending, schedule another flush.
+  if (pendingEndpoints.size) scheduleFlush()
+}
+
+function start (_config = {}, _application, _host, getRetryDataFunction, updateRetryDataFunction) {
+  if (!_config?.appsec?.apiSecurity?.endpointCollectionEnabled) return
+
+  config = _config
+  application = _application
+  host = _host
+  getRetryData = getRetryDataFunction
+  updateRetryData = updateRetryDataFunction
+
+  fastifyRouteCh.subscribe(onFastifyRoute)
+}
+
+function stop () {
+  fastifyRouteCh.unsubscribe(onFastifyRoute)
+
+  pendingEndpoints.clear()
+  flushScheduled = false
+  config = application = host = getRetryData = updateRetryData = null
+}
+
+module.exports = {
+  start,
+  stop
+}

package/packages/dd-trace/src/telemetry/telemetry.js

@@ -3,6 +3,7 @@ const tracerVersion = require('../../../../package.json').version
 const dc = require('dc-polyfill')
 const os = require('os')
 const dependencies = require('./dependencies')
+const endpoints = require('./endpoints')
 const { sendData } = require('./send-data')
 const { errors } = require('../startup-log')
 const { manager: metricsManager } = require('./metrics')
@@ -254,6 +255,7 @@ function start (aConfig, thePluginManager) {
 
   dependencies.start(config, application, host, getRetryData, updateRetryData)
   telemetryLogger.start(config)
+  endpoints.start(config, application, host, getRetryData, updateRetryData)
 
   sendData(config, application, host, 'app-started', appStarted(config))
 
@@ -280,6 +282,7 @@ function stop () {
 
   telemetryStopChannel.publish(getTelemetryData())
 
+  endpoints.stop()
   config = undefined
 }