@depup/dd-trace 5.90.0-depup.0

package/packages/datadog-shimmer/src/shimmer.js

@@ -0,0 +1,279 @@
+'use strict'
+
+/**
+ * @type {Set<string | symbol>}
+ */
+const skipMethods = new Set([
+  'caller',
+  'arguments',
+  'name',
+  'length',
+])
+const skipMethodSize = skipMethods.size
+
+const nonConfigurableModuleExports = new WeakMap()
+
+/**
+ * Copies properties from the original function to the wrapped function.
+ *
+ * @param {Function} original - The original function.
+ * @param {Function} wrapped - The wrapped function.
+ */
+function copyProperties (original, wrapped) {
+  if (original.constructor !== wrapped.constructor) {
+    const proto = Object.getPrototypeOf(original)
+    Object.setPrototypeOf(wrapped, proto)
+  }
+
+  const ownKeys = Reflect.ownKeys(original)
+  if (original.length !== wrapped.length) {
+    Object.defineProperty(wrapped, 'length', { value: original.length, configurable: true })
+  }
+  if (original.name !== wrapped.name) {
+    Object.defineProperty(wrapped, 'name', { value: original.name, configurable: true })
+  }
+  if (ownKeys.length !== 2) {
+    for (const key of ownKeys) {
+      if (skipMethods.has(key)) continue
+      const descriptor = /** @type {PropertyDescriptor} */ (Object.getOwnPropertyDescriptor(original, key))
+      if (descriptor.writable && descriptor.enumerable && descriptor.configurable) {
+        wrapped[key] = original[key]
+      } else if (descriptor.writable || descriptor.configurable || !Object.hasOwn(wrapped, key)) {
+        Object.defineProperty(wrapped, key, descriptor)
+      }
+    }
+  }
+}
+
+/**
+ * Copies properties from the original object to the wrapped object, skipping a specific key.
+ *
+ * @param {Record<string | symbol, unknown>} original - The original object.
+ * @param {Record<string | symbol, unknown>} wrapped - The wrapped object.
+ * @param {string | symbol} skipKey - The key to skip during copying.
+ */
+function copyObjectProperties (original, wrapped, skipKey) {
+  const ownKeys = Reflect.ownKeys(original)
+  for (const key of ownKeys) {
+    if (key === skipKey) continue
+    const descriptor = /** @type {PropertyDescriptor} */ (Object.getOwnPropertyDescriptor(original, key))
+    if (descriptor.writable && descriptor.enumerable && descriptor.configurable) {
+      wrapped[key] = original[key]
+    } else if (descriptor.writable || descriptor.configurable || !Object.hasOwn(wrapped, key)) {
+      Object.defineProperty(wrapped, key, descriptor)
+    }
+  }
+}
+
+/**
+ * Wraps a function with a wrapper function.
+ *
+ * @param {Function} original - The original function to wrap.
+ * @param {(original: Function) => Function} wrapper - The wrapper function.
+ * @returns {Function} The wrapped function.
+ */
+function wrapFunction (original, wrapper) {
+  if (typeof original !== 'function') return original
+
+  const wrapped = wrapper(original)
+  assertNotClass(original)
+  copyProperties(original, wrapped)
+
+  return wrapped
+}
+
+/**
+ * Wraps a method of an object with a wrapper function.
+ *
+ * @param {Record<string | symbol, unknown> | Function | undefined} target - The target
+ * object.
+ * @param {string | symbol} name - The property key of the method to wrap.
+ * @param {(original: Function) => (...args: unknown[]) => unknown} wrapper - The wrapper function.
+ * @param {{ replaceGetter?: boolean }} [options] - If `replaceGetter` is set to
+ * true, the getter is accessed and the getter is replaced with one that just
+ * returns the earlier retrieved value. Use with care! This may only be done in
+ * case the getter absolutely has no side effect and no setter is defined for the
+ * property.
+ * @returns {Record<string | symbol, unknown> | Function | undefined} The target object with
+ * the wrapped method.
+ */
+function wrap (target, name, wrapper, options) {
+  if (typeof wrapper !== 'function') {
+    throw new TypeError(wrapper ? 'Target is not a function' : 'No function provided')
+  }
+
+  if (target == null) {
+    // TODO: Add logging. This is an indicator that the part of a module that we
+    // try to instrument changed.
+    // Accessing the properties directly is in itself also unsafe, so we could just
+    // pass through an array of properties that should be accessed and automatically
+    // handle the access in here.
+    return
+  }
+
+  // No descriptor means original was on the prototype. This is not totally
+  // safe, since we define the property on the target. That could have an impact
+  // in case e.g., the own keys are checks.
+  const descriptor = Object.getOwnPropertyDescriptor(target, name) ?? {
+    value: target[name],
+    writable: true,
+    configurable: true,
+    enumerable: false,
+  }
+
+  if (descriptor.set && (!descriptor.get || options?.replaceGetter)) {
+    // It is possible to support these cases by instrumenting both the getter
+    // and setter (or only the setter, in case that is a use case).
+    // For now, this is not supported due to the complexity and the fact that
+    // this is not a common use case.
+    throw new Error(options?.replaceGetter
+      ? 'Replacing a getter/setter pair is not supported. Implement if required.'
+      : 'Replacing setters is not supported. Implement if required.')
+  }
+
+  const original = descriptor.value ?? options?.replaceGetter ? target[name] : descriptor.get
+
+  assertMethod(target, name, original)
+
+  const wrapped = wrapper(original)
+
+  copyProperties(original, wrapped)
+
+  if (descriptor.writable) {
+    // Fast path for assigned properties.
+    if (descriptor.configurable && descriptor.enumerable) {
+      target[name] = wrapped
+      return target
+    }
+    descriptor.value = wrapped
+  } else {
+    if (descriptor.get) {
+      // `replaceGetter` may only be used when the getter has no side effect.
+      descriptor.get = options?.replaceGetter ? () => wrapped : wrapped
+    } else {
+      descriptor.value = wrapped
+    }
+
+    if (descriptor.configurable === false) {
+      // TODO(BridgeAR): This currently only works on the most outer part. The
+      // moduleExports object.
+      //
+      // It would be possible to also implement it for non moduleExports objects
+      // by passing through the moduleExports object and the property names that
+      // are accessed. That way it would be possible to redefine the complete
+      // property chain. Example:
+      //
+      // shimmer.wrap(hapi.Server.prototype, 'start', wrapStart)
+      // shimmer.wrap(hapi.Server.prototype, 'ext', wrapExt)
+      //
+      // shimmer.wrap(hapi, 'Server', 'prototype', 'start', wrapStart)
+      // shimmer.wrap(hapi, 'Server', 'prototype', 'ext', wrapExt)
+      //
+      // That would however still not resolve the issue about the user replacing
+      // the return value so that the hook picks up the new hapi moduleExports
+      // object. To safely fix that, we would have to couple the register helper
+      // with this code. That way it would be possible to directly pass through
+      // the entries.
+
+      // In case more than a single property is not configurable and writable,
+      // Just reuse the already created object.
+      let moduleExports = nonConfigurableModuleExports.get(target)
+      if (!moduleExports) {
+        if (typeof target === 'function') {
+          const original = target
+          moduleExports = function (...args) { return original.apply(original, args) }
+          // This is a rare case. Accept the slight performance hit.
+          skipMethods.add(name)
+          copyProperties(target, moduleExports)
+          if (skipMethods.size === skipMethodSize + 1) {
+            skipMethods.delete(name)
+          }
+        } else {
+          moduleExports = Object.create(target)
+          copyObjectProperties(target, moduleExports, name)
+        }
+        nonConfigurableModuleExports.set(target, moduleExports)
+      }
+      target = moduleExports
+    }
+  }
+
+  Object.defineProperty(target, name, descriptor)
+
+  return target
+}
+
+/**
+ * Wraps multiple methods and or multiple objects with a wrapper function.
+ * May also receive a single method or object or a single method name.
+ *
+ * @param {Array<Record<string | symbol, unknown> | Function> |
+ *         Record<string | symbol, unknown> |
+ *         Function} targets - The target objects.
+ * @param {Array<string | symbol> | string | symbol} names - The property keys of the methods to wrap.
+ * @param {(original: Function) => (...args: unknown[]) => unknown} wrapper - The wrapper function.
+ */
+function massWrap (targets, names, wrapper) {
+  targets = toArray(targets)
+  names = toArray(names)
+
+  for (const target of targets) {
+    for (const name of names) {
+      wrap(target, name, wrapper)
+    }
+  }
+}
+
+/**
+ * Converts a value to an array if it is not already an array.
+ *
+ * @template T
+ * @param {T | T[]} maybeArray - The value to convert.
+ * @returns {T[]} The value as an array.
+ */
+function toArray (maybeArray) {
+  return Array.isArray(maybeArray) ? maybeArray : [maybeArray]
+}
+
+/**
+ * Asserts that a method is a function.
+ *
+ * @param {Record<string | symbol, unknown> | Function} target - The target object.
+ * @param {string | symbol} name - The property key of the method.
+ * @param {unknown} method - The method to assert.
+ * @throws {Error} If the method is not a function.
+ */
+function assertMethod (target, name, method) {
+  if (typeof method !== 'function') {
+    let message = 'No target object provided'
+
+    if (target) {
+      if (typeof target !== 'object' && typeof target !== 'function') {
+        message = 'Invalid target'
+      } else {
+        name = String(name)
+        message = method ? `Original method ${name} is not a function` : `No original method ${name}`
+      }
+    }
+
+    throw new TypeError(message)
+  }
+}
+
+/**
+ * Asserts that a target is not a class constructor.
+ *
+ * @param {Function} target - The target function.
+ * @throws {Error} If the target is a class constructor.
+ */
+function assertNotClass (target) {
+  if (Function.prototype.toString.call(target).startsWith('class')) {
+    throw new TypeError('Target is a native class constructor and cannot be wrapped.')
+  }
+}
+
+module.exports = {
+  wrap,
+  wrapFunction,
+  massWrap,
+}

package/packages/dd-trace/index.js

@@ -0,0 +1,36 @@
+'use strict'
+
+if (!global._ddtrace) {
+  const TracerProxy = require('./src')
+
+  Object.defineProperty(global, '_ddtrace', {
+    value: new TracerProxy(),
+    enumerable: false,
+    configurable: true,
+    writable: true,
+  })
+
+  const ddTraceSymbol = Symbol.for('dd-trace')
+
+  Object.defineProperty(globalThis, ddTraceSymbol, {
+    value: {
+      beforeExitHandlers: new Set(),
+    },
+    enumerable: false,
+    configurable: true, // Allow this to be overridden by loading the tracer
+    writable: false,
+  })
+
+  process.once('beforeExit', function mainBeforeExit () {
+    if (globalThis[ddTraceSymbol]?.beforeExitHandlers) {
+      for (const handler of globalThis[ddTraceSymbol].beforeExitHandlers) {
+        handler()
+      }
+    }
+  })
+
+  global._ddtrace.default = global._ddtrace
+  global._ddtrace.tracer = global._ddtrace
+}
+
+module.exports = global._ddtrace

package/packages/dd-trace/src/agent/info.js

@@ -0,0 +1,57 @@
+'use strict'
+
+const request = require('../exporters/common/request')
+
+const CACHE_TTL_MS = 60_000 // 1 minute
+
+let cachedUrl = null
+let cachedData = null
+let cachedTimestamp = 0
+
+module.exports = {
+  fetchAgentInfo,
+  clearCache, // For testing purposes only
+}
+
+/**
+ * Fetches agent information from the /info endpoint
+ * @param {URL} url - The agent URL
+ * @param {Function} callback - Callback function with signature (err, agentInfo)
+ */
+function fetchAgentInfo (url, callback) {
+  const urlKey = url.href
+
+  if (cachedUrl !== null && cachedUrl !== urlKey) {
+    // Clear cache if URL changes
+    clearCache()
+  } else if (cachedData !== null && (Date.now() - cachedTimestamp) < CACHE_TTL_MS) {
+    // Return cached result if still valid
+    return process.nextTick(callback, null, cachedData)
+  }
+
+  request('', {
+    path: '/info',
+    url,
+  }, (err, res) => {
+    if (err) {
+      return callback(err)
+    }
+
+    try {
+      cachedData = JSON.parse(res)
+    } catch (e) {
+      return callback(e)
+    }
+
+    cachedUrl = urlKey
+    cachedTimestamp = Date.now()
+
+    callback(null, cachedData)
+  })
+}
+
+function clearCache () {
+  cachedUrl = null
+  cachedData = null
+  cachedTimestamp = 0
+}

package/packages/dd-trace/src/agent/url.js

@@ -0,0 +1,28 @@
+'use strict'
+
+const { URL, format } = require('url')
+const defaults = require('../config/defaults')
+
+module.exports = { getAgentUrl }
+
+// TODO: Investigate merging with the getAgentUrl function in config/index.js which has
+// additional logic for unix socket auto-detection on Linux. The config version is only used
+// during config initialization, while this one is used throughout the codebase. Consider if
+// the unix socket detection should be part of this general helper or remain config-specific.
+
+/**
+ * Gets the agent URL from config, constructing it from hostname/port if needed
+ * @param {ReturnType<import('../config')>} config - Tracer configuration object
+ * @returns {URL} The agent URL
+ */
+function getAgentUrl (config) {
+  const { url, hostname, port } = config
+  if (url) {
+    return url instanceof URL ? url : new URL(url)
+  }
+  return new URL(format({
+    protocol: 'http:',
+    hostname: hostname || defaults.hostname,
+    port: port || defaults.port,
+  }))
+}

package/packages/dd-trace/src/aiguard/client.js

@@ -0,0 +1,25 @@
+'use strict'
+
+async function executeRequest (body, opts) {
+  const postData = JSON.stringify(body)
+  const headers = {
+    'Content-Type': 'application/json',
+    'Content-Length': Buffer.byteLength(postData),
+    ...opts.headers,
+  }
+
+  const response = await fetch(opts.url, {
+    method: 'POST',
+    headers,
+    body: postData,
+    signal: AbortSignal.timeout(opts.timeout),
+  })
+
+  const responseBody = await response.json()
+  return {
+    status: response.status,
+    body: responseBody,
+  }
+}
+
+module.exports = executeRequest

package/packages/dd-trace/src/aiguard/noop.js

@@ -0,0 +1,9 @@
+'use strict'
+
+class NoopAIGuard {
+  evaluate (messages, opts) {
+    return Promise.resolve({ action: 'ALLOW', reason: 'AI Guard is not enabled', tags: [], sds: [] })
+  }
+}
+
+module.exports = NoopAIGuard

package/packages/dd-trace/src/aiguard/sdk.js

@@ -0,0 +1,223 @@
+'use strict'
+
+const rfdc = require('../../../../vendor/dist/rfdc')({ proto: false, circles: false })
+const log = require('../log')
+const telemetryMetrics = require('../telemetry/metrics')
+const tracerVersion = require('../../../../package.json').version
+const { keepTrace } = require('../priority_sampler')
+const { AI_GUARD } = require('../standalone/product')
+const NoopAIGuard = require('./noop')
+const executeRequest = require('./client')
+const {
+  AI_GUARD_RESOURCE,
+  AI_GUARD_TARGET_TAG_KEY,
+  AI_GUARD_REASON_TAG_KEY,
+  AI_GUARD_ACTION_TAG_KEY,
+  AI_GUARD_BLOCKED_TAG_KEY,
+  AI_GUARD_META_STRUCT_KEY,
+  AI_GUARD_TOOL_NAME_TAG_KEY,
+  AI_GUARD_TELEMETRY_REQUESTS,
+  AI_GUARD_TELEMETRY_TRUNCATED,
+} = require('./tags')
+
+const appsecMetrics = telemetryMetrics.manager.namespace('appsec')
+
+const ALLOW = 'ALLOW'
+
+class AIGuardAbortError extends Error {
+  constructor (reason, tags, sds) {
+    super(reason)
+    this.name = 'AIGuardAbortError'
+    this.reason = reason
+    this.tags = tags
+    this.sds = sds || []
+  }
+}
+
+class AIGuardClientError extends Error {
+  constructor (message, opts = {}) {
+    super(message)
+    this.name = 'AIGuardClientError'
+    if (opts.errors) {
+      this.errors = opts.errors
+    }
+    if (opts.cause) {
+      this.cause = opts.cause
+    }
+  }
+}
+
+class AIGuard extends NoopAIGuard {
+  #initialized
+  #tracer
+  #headers
+  #evaluateUrl
+  #timeout
+  #maxMessagesLength
+  #maxContentSize
+  #meta
+
+  constructor (tracer, config) {
+    super()
+
+    if (!config.apiKey || !config.appKey) {
+      log.error('AIGuard: missing api and/or app keys, use env DD_API_KEY and DD_APP_KEY')
+      this.#initialized = false
+      return
+    }
+    this.#tracer = tracer
+    this.#headers = {
+      'DD-API-KEY': config.apiKey,
+      'DD-APPLICATION-KEY': config.appKey,
+      'DD-AI-GUARD-VERSION': tracerVersion,
+      'DD-AI-GUARD-SOURCE': 'SDK',
+      'DD-AI-GUARD-LANGUAGE': 'nodejs',
+    }
+    const endpoint = config.experimental.aiguard.endpoint || `https://app.${config.site}/api/v2/ai-guard`
+    this.#evaluateUrl = `${endpoint}/evaluate`
+    this.#timeout = config.experimental.aiguard.timeout
+    this.#maxMessagesLength = config.experimental.aiguard.maxMessagesLength
+    this.#maxContentSize = config.experimental.aiguard.maxContentSize
+    this.#meta = { service: config.service, env: config.env }
+    this.#initialized = true
+  }
+
+  /**
+   * Returns a safe copy of the messages to be serialized into the meta struct.
+   *
+   * - Clones each message so callers cannot mutate the data set in the meta struct.
+   * - Truncates the list of messages and `content` fields emitting metrics accordingly.
+   */
+  #buildMessagesForMetaStruct (messages) {
+    const size = Math.min(messages.length, this.#maxMessagesLength)
+    if (messages.length > size) {
+      appsecMetrics.count(AI_GUARD_TELEMETRY_TRUNCATED, { type: 'messages' }).inc(1)
+    }
+    const result = []
+    let contentTruncated = false
+    for (let i = messages.length - size; i < messages.length; i++) {
+      const message = rfdc(messages[i])
+      if (message.content?.length > this.#maxContentSize) {
+        contentTruncated = true
+        message.content = message.content.slice(0, this.#maxContentSize)
+      }
+      result.push(message)
+    }
+    if (contentTruncated) {
+      appsecMetrics.count(AI_GUARD_TELEMETRY_TRUNCATED, { type: 'content' }).inc(1)
+    }
+    return result
+  }
+
+  #isToolCall (message) {
+    return message.tool_calls || message.tool_call_id
+  }
+
+  #getToolName (message, history) {
+    // 1. assistant message with tool calls
+    if (message.tool_calls) {
+      const names = message.tool_calls.map((tool) => tool.function.name)
+      return names.length === 0 ? null : names.join(',')
+    }
+    // 2. assistant message with tool output (search the linked tool call in reverse order)
+    const id = message.tool_call_id
+    for (let i = history.length - 2; i >= 0; i--) {
+      const item = history[i]
+      if (item.tool_calls) {
+        for (const toolCall of item.tool_calls) {
+          if (toolCall.id === id) {
+            return toolCall.function.name
+          }
+        }
+      }
+    }
+    return null
+  }
+
+  evaluate (messages, opts) {
+    if (!this.#initialized) {
+      return super.evaluate(messages, opts)
+    }
+    const { block = true } = opts ?? {}
+    return this.#tracer.trace(AI_GUARD_RESOURCE, {}, async (span) => {
+      const last = messages[messages.length - 1]
+      const target = this.#isToolCall(last) ? 'tool' : 'prompt'
+      span.setTag(AI_GUARD_TARGET_TAG_KEY, target)
+      if (target === 'tool') {
+        const name = this.#getToolName(last, messages)
+        if (name) {
+          span.setTag(AI_GUARD_TOOL_NAME_TAG_KEY, name)
+        }
+      }
+      const metaStruct = {
+        messages: this.#buildMessagesForMetaStruct(messages),
+      }
+      span.meta_struct = {
+        [AI_GUARD_META_STRUCT_KEY]: metaStruct,
+      }
+      const rootSpan = span.context()?._trace?.started?.[0]
+      if (rootSpan) {
+        // keepTrace must be called before executeRequest so the sampling decision
+        // is propagated correctly to outgoing HTTP client calls.
+        keepTrace(rootSpan, AI_GUARD)
+      }
+      let response
+      try {
+        const payload = {
+          data: {
+            attributes: {
+              messages,
+              meta: this.#meta,
+            },
+          },
+        }
+        response = await executeRequest(
+          payload,
+          { url: this.#evaluateUrl, headers: this.#headers, timeout: this.#timeout })
+      } catch (e) {
+        appsecMetrics.count(AI_GUARD_TELEMETRY_REQUESTS, { error: true }).inc(1)
+        throw new AIGuardClientError(`Unexpected error calling AI Guard service: ${e.message}`, { cause: e })
+      }
+      if (response.status !== 200) {
+        appsecMetrics.count(AI_GUARD_TELEMETRY_REQUESTS, { error: true }).inc(1)
+        throw new AIGuardClientError(
+          `AI Guard service call failed, status ${response.status}`,
+          { errors: response.body?.errors })
+      }
+      let action, reason, tags, sdsFindings, blockingEnabled
+      try {
+        const attr = response.body.data.attributes
+        if (!attr.action) {
+          throw new Error('Action missing from response')
+        }
+        action = attr.action
+        reason = attr.reason
+        tags = attr.tags
+        sdsFindings = attr.sds_findings || []
+        blockingEnabled = attr.is_blocking_enabled ?? false
+      } catch (e) {
+        appsecMetrics.count(AI_GUARD_TELEMETRY_REQUESTS, { error: true }).inc(1)
+        throw new AIGuardClientError(`AI Guard service returned unexpected response : ${response.body}`, { cause: e })
+      }
+      const shouldBlock = block && blockingEnabled && action !== ALLOW
+      appsecMetrics.count(AI_GUARD_TELEMETRY_REQUESTS, { action, error: false, block: shouldBlock }).inc(1)
+      span.setTag(AI_GUARD_ACTION_TAG_KEY, action)
+      if (reason) {
+        span.setTag(AI_GUARD_REASON_TAG_KEY, reason)
+      }
+      if (tags?.length > 0) {
+        metaStruct.attack_categories = tags
+      }
+      if (sdsFindings?.length > 0) {
+        metaStruct.sds = sdsFindings
+      }
+      if (shouldBlock) {
+        span.setTag(AI_GUARD_BLOCKED_TAG_KEY, 'true')
+        throw new AIGuardAbortError(reason, tags, sdsFindings)
+      }
+      return { action, reason, tags, sds: sdsFindings }
+    })
+  }
+}
+
+module.exports = AIGuard

package/packages/dd-trace/src/aiguard/tags.js

@@ -0,0 +1,14 @@
+'use strict'
+
+module.exports = {
+  AI_GUARD_RESOURCE: 'ai_guard',
+  AI_GUARD_TARGET_TAG_KEY: 'ai_guard.target',
+  AI_GUARD_TOOL_NAME_TAG_KEY: 'ai_guard.tool_name',
+  AI_GUARD_ACTION_TAG_KEY: 'ai_guard.action',
+  AI_GUARD_REASON_TAG_KEY: 'ai_guard.reason',
+  AI_GUARD_BLOCKED_TAG_KEY: 'ai_guard.blocked',
+  AI_GUARD_META_STRUCT_KEY: 'ai_guard',
+
+  AI_GUARD_TELEMETRY_REQUESTS: 'ai_guard.requests',
+  AI_GUARD_TELEMETRY_TRUNCATED: 'ai_guard.truncated',
+}

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

@@ -0,0 +1,15 @@
+'use strict'
+
+const { MEASURED } = require('../../../ext/tags')
+
+module.exports = {
+  sample (span, measured, measuredByDefault) {
+    if (measured !== null && typeof measured === 'object') {
+      this.sample(span, measured[span.context()._name], measuredByDefault)
+    } else if (measured !== undefined) {
+      span.setTag(MEASURED, !!measured)
+    } else if (measuredByDefault) {
+      span.setTag(MEASURED, true)
+    }
+  },
+}