dd-trace 4.45.0 → 4.47.0

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

@@ -89,7 +89,7 @@ function getProducts (config) {
     },
     profiler: {
       version: tracerVersion,
-      enabled: config.profiling.enabled
+      enabled: profilingEnabledToBoolean(config.profiling.enabled)
     }
   }
   if (errors.profilingError) {
@@ -329,13 +329,17 @@ function updateConfig (changes, config) {
     const { origin, value } = change
     const entry = { name, value, origin }
 
-    if (namesNeedFormatting.has(entry.name)) entry.value = formatMapForTelemetry(entry.value)
-    if (entry.name === 'url' && entry.value) entry.value = entry.value.toString()
-    if (entry.name === 'DD_TRACE_SAMPLING_RULES') {
+    if (namesNeedFormatting.has(entry.name)) {
+      entry.value = formatMapForTelemetry(entry.value)
+    } else if (entry.name === 'url') {
+      if (entry.value) {
+        entry.value = entry.value.toString()
+      }
+    } else if (entry.name === 'DD_TRACE_SAMPLING_RULES') {
       entry.value = JSON.stringify(entry.value)
+    } else if (Array.isArray(entry.value)) {
+      entry.value = value.join(',')
     }
-    if (Array.isArray(entry.value)) entry.value = value.join(',')
-
     configuration.push(entry)
   }
 
@@ -354,6 +358,19 @@ function updateConfig (changes, config) {
   }
 }
 
+function profilingEnabledToBoolean (profilingEnabled) {
+  if (typeof profilingEnabled === 'boolean') {
+    return profilingEnabled
+  }
+  if (['auto', 'true'].includes(profilingEnabled)) {
+    return true
+  }
+  if (profilingEnabled === 'false') {
+    return false
+  }
+  return undefined
+}
+
 module.exports = {
   start,
   stop,

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

@@ -5,6 +5,7 @@ const logCollector = require('./log-collector')
 const { sendData } = require('../send-data')
 
 const telemetryLog = dc.channel('datadog:telemetry:log')
+const errorLog = dc.channel('datadog:log:error')
 
 let enabled = false
 
@@ -33,12 +34,29 @@ function onLog (log) {
   }
 }
 
+function onErrorLog (msg) {
+  if (msg instanceof Error) {
+    onLog({
+      level: 'ERROR',
+      message: msg.message,
+      stack_trace: msg.stack
+    })
+  } else if (typeof msg === 'string') {
+    onLog({
+      level: 'ERROR',
+      message: msg
+    })
+  }
+}
+
 function start (config) {
   if (!config.telemetry.logCollection || enabled) return
 
   enabled = true
 
   telemetryLog.subscribe(onLog)
+
+  errorLog.subscribe(onErrorLog)
 }
 
 function stop () {
@@ -47,6 +65,8 @@ function stop () {
   if (telemetryLog.hasSubscribers) {
     telemetryLog.unsubscribe(onLog)
   }
+
+  errorLog.unsubscribe(onErrorLog)
 }
 
 function send (config, application, host) {

package/packages/dd-trace/src/appsec/rasp.js

@@ -1,176 +0,0 @@
-'use strict'
-
-const { storage } = require('../../../datadog-core')
-const web = require('./../plugins/util/web')
-const addresses = require('./addresses')
-const { httpClientRequestStart, setUncaughtExceptionCaptureCallbackStart } = require('./channels')
-const { reportStackTrace } = require('./stack_trace')
-const waf = require('./waf')
-const { getBlockingAction, block } = require('./blocking')
-const log = require('../log')
-
-const RULE_TYPES = {
-  SSRF: 'ssrf'
-}
-
-class DatadogRaspAbortError extends Error {
-  constructor (req, res, blockingAction) {
-    super('DatadogRaspAbortError')
-    this.name = 'DatadogRaspAbortError'
-    this.req = req
-    this.res = res
-    this.blockingAction = blockingAction
-  }
-}
-
-let config, abortOnUncaughtException
-
-function removeAllListeners (emitter, event) {
-  const listeners = emitter.listeners(event)
-  emitter.removeAllListeners(event)
-
-  let cleaned = false
-  return function () {
-    if (cleaned === true) {
-      return
-    }
-    cleaned = true
-
-    for (let i = 0; i < listeners.length; ++i) {
-      emitter.on(event, listeners[i])
-    }
-  }
-}
-
-function findDatadogRaspAbortError (err, deep = 10) {
-  if (err instanceof DatadogRaspAbortError) {
-    return err
-  }
-
-  if (err.cause && deep > 0) {
-    return findDatadogRaspAbortError(err.cause, deep - 1)
-  }
-}
-
-function handleUncaughtExceptionMonitor (err) {
-  const abortError = findDatadogRaspAbortError(err)
-  if (!abortError) return
-
-  const { req, res, blockingAction } = abortError
-  block(req, res, web.root(req), null, blockingAction)
-
-  if (!process.hasUncaughtExceptionCaptureCallback()) {
-    const cleanUp = removeAllListeners(process, 'uncaughtException')
-    const handler = () => {
-      process.removeListener('uncaughtException', handler)
-    }
-
-    setTimeout(() => {
-      process.removeListener('uncaughtException', handler)
-      cleanUp()
-    })
-
-    process.on('uncaughtException', handler)
-  } else {
-    // uncaughtException event is not executed when hasUncaughtExceptionCaptureCallback is true
-    let previousCb
-    const cb = ({ currentCallback, abortController }) => {
-      setUncaughtExceptionCaptureCallbackStart.unsubscribe(cb)
-      if (!currentCallback) {
-        abortController.abort()
-        return
-      }
-
-      previousCb = currentCallback
-    }
-
-    setUncaughtExceptionCaptureCallbackStart.subscribe(cb)
-
-    process.setUncaughtExceptionCaptureCallback(null)
-
-    // For some reason, previous callback was defined before the instrumentation
-    // We can not restore it, so we let the app decide
-    if (previousCb) {
-      process.setUncaughtExceptionCaptureCallback(() => {
-        process.setUncaughtExceptionCaptureCallback(null)
-        process.setUncaughtExceptionCaptureCallback(previousCb)
-      })
-    }
-  }
-}
-
-function enable (_config) {
-  config = _config
-  httpClientRequestStart.subscribe(analyzeSsrf)
-
-  process.on('uncaughtExceptionMonitor', handleUncaughtExceptionMonitor)
-  abortOnUncaughtException = process.execArgv?.includes('--abort-on-uncaught-exception')
-
-  if (abortOnUncaughtException) {
-    log.warn('The --abort-on-uncaught-exception flag is enabled. The RASP module will not block operations.')
-  }
-}
-
-function disable () {
-  if (httpClientRequestStart.hasSubscribers) httpClientRequestStart.unsubscribe(analyzeSsrf)
-
-  process.off('uncaughtExceptionMonitor', handleUncaughtExceptionMonitor)
-}
-
-function analyzeSsrf (ctx) {
-  const store = storage.getStore()
-  const req = store?.req
-  const url = ctx.args.uri
-
-  if (!req || !url) return
-
-  const persistent = {
-    [addresses.HTTP_OUTGOING_URL]: url
-  }
-
-  const result = waf.run({ persistent }, req, RULE_TYPES.SSRF)
-
-  const res = store?.res
-  handleResult(result, req, res, ctx.abortController)
-}
-
-function getGenerateStackTraceAction (actions) {
-  return actions?.generate_stack
-}
-
-function handleResult (actions, req, res, abortController) {
-  const generateStackTraceAction = getGenerateStackTraceAction(actions)
-  if (generateStackTraceAction && config.appsec.stackTrace.enabled) {
-    const rootSpan = web.root(req)
-    reportStackTrace(
-      rootSpan,
-      generateStackTraceAction.stack_id,
-      config.appsec.stackTrace.maxDepth,
-      config.appsec.stackTrace.maxStackTraces
-    )
-  }
-
-  if (!abortController || abortOnUncaughtException) return
-
-  const blockingAction = getBlockingAction(actions)
-  if (blockingAction) {
-    const rootSpan = web.root(req)
-    // Should block only in express
-    if (rootSpan?.context()._name === 'express.request') {
-      const abortError = new DatadogRaspAbortError(req, res, blockingAction)
-      abortController.abort(abortError)
-
-      // TODO Delete this when support for node 16 is removed
-      if (!abortController.signal.reason) {
-        abortController.signal.reason = abortError
-      }
-    }
-  }
-}
-
-module.exports = {
-  enable,
-  disable,
-  handleResult,
-  handleUncaughtExceptionMonitor // exported only for testing purpose
-}