dd-trace 5.24.0 → 5.26.0

package/packages/dd-trace/src/llmobs/writers/base.js

@@ -0,0 +1,111 @@
+'use strict'
+
+const request = require('../../exporters/common/request')
+const { URL, format } = require('url')
+
+const logger = require('../../log')
+
+const { encodeUnicode } = require('../util')
+const log = require('../../log')
+
+class BaseLLMObsWriter {
+  constructor ({ interval, timeout, endpoint, intake, eventType, protocol, port }) {
+    this._interval = interval || 1000 // 1s
+    this._timeout = timeout || 5000 // 5s
+    this._eventType = eventType
+
+    this._buffer = []
+    this._bufferLimit = 1000
+    this._bufferSize = 0
+
+    this._url = new URL(format({
+      protocol: protocol || 'https:',
+      hostname: intake,
+      port: port || 443,
+      pathname: endpoint
+    }))
+
+    this._headers = {
+      'Content-Type': 'application/json'
+    }
+
+    this._periodic = setInterval(() => {
+      this.flush()
+    }, this._interval).unref()
+
+    process.once('beforeExit', () => {
+      this.destroy()
+    })
+
+    this._destroyed = false
+
+    logger.debug(`Started ${this.constructor.name} to ${this._url}`)
+  }
+
+  append (event, byteLength) {
+    if (this._buffer.length >= this._bufferLimit) {
+      logger.warn(`${this.constructor.name} event buffer full (limit is ${this._bufferLimit}), dropping event`)
+      return
+    }
+
+    this._bufferSize += byteLength || Buffer.from(JSON.stringify(event)).byteLength
+    this._buffer.push(event)
+  }
+
+  flush () {
+    if (this._buffer.length === 0) {
+      return
+    }
+
+    const events = this._buffer
+    this._buffer = []
+    this._bufferSize = 0
+    const payload = this._encode(this.makePayload(events))
+
+    const options = {
+      headers: this._headers,
+      method: 'POST',
+      url: this._url,
+      timeout: this._timeout
+    }
+
+    log.debug(`Encoded LLMObs payload: ${payload}`)
+
+    request(payload, options, (err, resp, code) => {
+      if (err) {
+        logger.error(
+          `Error sending ${events.length} LLMObs ${this._eventType} events to ${this._url}: ${err.message}`
+        )
+      } else if (code >= 300) {
+        logger.error(
+          `Error sending ${events.length} LLMObs ${this._eventType} events to ${this._url}: ${code}`
+        )
+      } else {
+        logger.debug(`Sent ${events.length} LLMObs ${this._eventType} events to ${this._url}`)
+      }
+    })
+  }
+
+  makePayload (events) {}
+
+  destroy () {
+    if (!this._destroyed) {
+      logger.debug(`Stopping ${this.constructor.name}`)
+      clearInterval(this._periodic)
+      process.removeListener('beforeExit', this.destroy)
+      this.flush()
+      this._destroyed = true
+    }
+  }
+
+  _encode (payload) {
+    return JSON.stringify(payload, (key, value) => {
+      if (typeof value === 'string') {
+        return encodeUnicode(value) // serialize unicode characters
+      }
+      return value
+    }).replace(/\\\\u/g, '\\u') // remove double escaping
+  }
+}
+
+module.exports = BaseLLMObsWriter

package/packages/dd-trace/src/llmobs/writers/evaluations.js

@@ -0,0 +1,29 @@
+'use strict'
+
+const { AGENTLESS_EVALULATIONS_ENDPOINT } = require('../constants/writers')
+const BaseWriter = require('./base')
+
+class LLMObsEvalMetricsWriter extends BaseWriter {
+  constructor (config) {
+    super({
+      endpoint: AGENTLESS_EVALULATIONS_ENDPOINT,
+      intake: `api.${config.site}`,
+      eventType: 'evaluation_metric'
+    })
+
+    this._headers['DD-API-KEY'] = config.apiKey
+  }
+
+  makePayload (events) {
+    return {
+      data: {
+        type: this._eventType,
+        attributes: {
+          metrics: events
+        }
+      }
+    }
+  }
+}
+
+module.exports = LLMObsEvalMetricsWriter

package/packages/dd-trace/src/llmobs/writers/spans/agentProxy.js

@@ -0,0 +1,23 @@
+'use strict'
+
+const {
+  EVP_SUBDOMAIN_HEADER_NAME,
+  EVP_SUBDOMAIN_HEADER_VALUE,
+  EVP_PROXY_AGENT_ENDPOINT
+} = require('../../constants/writers')
+const LLMObsBaseSpanWriter = require('./base')
+
+class LLMObsAgentProxySpanWriter extends LLMObsBaseSpanWriter {
+  constructor (config) {
+    super({
+      intake: config.hostname || 'localhost',
+      protocol: 'http:',
+      endpoint: EVP_PROXY_AGENT_ENDPOINT,
+      port: config.port
+    })
+
+    this._headers[EVP_SUBDOMAIN_HEADER_NAME] = EVP_SUBDOMAIN_HEADER_VALUE
+  }
+}
+
+module.exports = LLMObsAgentProxySpanWriter

package/packages/dd-trace/src/llmobs/writers/spans/agentless.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const { AGENTLESS_SPANS_ENDPOINT } = require('../../constants/writers')
+const LLMObsBaseSpanWriter = require('./base')
+
+class LLMObsAgentlessSpanWriter extends LLMObsBaseSpanWriter {
+  constructor (config) {
+    super({
+      intake: `llmobs-intake.${config.site}`,
+      endpoint: AGENTLESS_SPANS_ENDPOINT
+    })
+
+    this._headers['DD-API-KEY'] = config.apiKey
+  }
+}
+
+module.exports = LLMObsAgentlessSpanWriter

package/packages/dd-trace/src/llmobs/writers/spans/base.js

@@ -0,0 +1,52 @@
+'use strict'
+
+const { EVP_EVENT_SIZE_LIMIT, EVP_PAYLOAD_SIZE_LIMIT } = require('../../constants/writers')
+const { DROPPED_VALUE_TEXT } = require('../../constants/text')
+const { DROPPED_IO_COLLECTION_ERROR } = require('../../constants/tags')
+const BaseWriter = require('../base')
+const logger = require('../../../log')
+
+const tracerVersion = require('../../../../../../package.json').version
+
+class LLMObsSpanWriter extends BaseWriter {
+  constructor (options) {
+    super({
+      ...options,
+      eventType: 'span'
+    })
+  }
+
+  append (event) {
+    const eventSizeBytes = Buffer.from(JSON.stringify(event)).byteLength
+    if (eventSizeBytes > EVP_EVENT_SIZE_LIMIT) {
+      logger.warn(`Dropping event input/output because its size (${eventSizeBytes}) exceeds the 1MB event size limit`)
+      event = this._truncateSpanEvent(event)
+    }
+
+    if (this._bufferSize + eventSizeBytes > EVP_PAYLOAD_SIZE_LIMIT) {
+      logger.debug('Flusing queue because queing next event will exceed EvP payload limit')
+      this.flush()
+    }
+
+    super.append(event, eventSizeBytes)
+  }
+
+  makePayload (events) {
+    return {
+      '_dd.stage': 'raw',
+      '_dd.tracer_version': tracerVersion,
+      event_type: this._eventType,
+      spans: events
+    }
+  }
+
+  _truncateSpanEvent (event) {
+    event.meta.input = { value: DROPPED_VALUE_TEXT }
+    event.meta.output = { value: DROPPED_VALUE_TEXT }
+
+    event.collection_errors = [DROPPED_IO_COLLECTION_ERROR]
+    return event
+  }
+}
+
+module.exports = LLMObsSpanWriter

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

@@ -4,6 +4,7 @@ const coalesce = require('koalas')
 const { isTrue } = require('../util')
 const { debugChannel, infoChannel, warnChannel, errorChannel } = require('./channels')
 const logWriter = require('./writer')
+const { Log } = require('./log')
 
 const memoize = func => {
   const cache = {}
@@ -18,10 +19,6 @@ const memoize = func => {
   return memoized
 }
 
-function processMsg (msg) {
-  return typeof msg === 'function' ? msg() : msg
-}
-
 const config = {
   enabled: false,
   logger: undefined,
@@ -52,37 +49,37 @@ const log = {
   reset () {
     logWriter.reset()
     this._deprecate = memoize((code, message) => {
-      errorChannel.publish(message)
+      errorChannel.publish(Log.parse(message))
       return true
     })
 
     return this
   },
 
-  debug (message) {
+  debug (...args) {
     if (debugChannel.hasSubscribers) {
-      debugChannel.publish(processMsg(message))
+      debugChannel.publish(Log.parse(...args))
     }
     return this
   },
 
-  info (message) {
+  info (...args) {
     if (infoChannel.hasSubscribers) {
-      infoChannel.publish(processMsg(message))
+      infoChannel.publish(Log.parse(...args))
     }
     return this
   },
 
-  warn (message) {
+  warn (...args) {
     if (warnChannel.hasSubscribers) {
-      warnChannel.publish(processMsg(message))
+      warnChannel.publish(Log.parse(...args))
     }
     return this
   },
 
-  error (err) {
+  error (...args) {
     if (errorChannel.hasSubscribers) {
-      errorChannel.publish(processMsg(err))
+      errorChannel.publish(Log.parse(...args))
     }
     return this
   },

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

@@ -0,0 +1,52 @@
+'use strict'
+
+const { format } = require('util')
+
+class Log {
+  constructor (message, args, cause, delegate) {
+    this.message = message
+    this.args = args
+    this.cause = cause
+    this.delegate = delegate
+  }
+
+  get formatted () {
+    const { message, args } = this
+
+    let formatted = message
+    if (message && args && args.length) {
+      formatted = format(message, ...args)
+    }
+    return formatted
+  }
+
+  static parse (...args) {
+    let message, cause, delegate
+
+    const lastArg = args[args.length - 1]
+    if (lastArg && typeof lastArg === 'object' && lastArg.stack) { // lastArg instanceof Error?
+      cause = args.pop()
+    }
+
+    const firstArg = args.shift()
+    if (firstArg) {
+      if (typeof firstArg === 'string') {
+        message = firstArg
+      } else if (typeof firstArg === 'object') {
+        message = String(firstArg.message || firstArg)
+      } else if (typeof firstArg === 'function') {
+        delegate = firstArg
+      } else {
+        message = String(firstArg)
+      }
+    } else if (!cause) {
+      message = String(firstArg)
+    }
+
+    return new Log(message, args, cause, delegate)
+  }
+}
+
+module.exports = {
+  Log
+}

package/packages/dd-trace/src/log/writer.js

@@ -2,6 +2,7 @@
 
 const { storage } = require('../../../datadog-core')
 const { LogChannel } = require('./channels')
+const { Log } = require('./log')
 const defaultLogger = {
   debug: msg => console.debug(msg), /* eslint-disable-line no-console */
   info: msg => console.info(msg), /* eslint-disable-line no-console */
@@ -22,7 +23,7 @@ function withNoop (fn) {
 }
 
 function unsubscribeAll () {
-  logChannel.unsubscribe({ debug, info, warn, error })
+  logChannel.unsubscribe({ debug: onDebug, info: onInfo, warn: onWarn, error: onError })
 }
 
 function toggleSubscription (enable, level) {
@@ -30,7 +31,7 @@ function toggleSubscription (enable, level) {
 
   if (enable) {
     logChannel = new LogChannel(level)
-    logChannel.subscribe({ debug, info, warn, error })
+    logChannel.subscribe({ debug: onDebug, info: onInfo, warn: onWarn, error: onError })
   }
 }
 
@@ -51,32 +52,62 @@ function reset () {
   toggleSubscription(false)
 }
 
-function error (err) {
-  if (typeof err !== 'object' || !err) {
-    err = String(err)
-  } else if (!err.stack) {
-    err = String(err.message || err)
+function getErrorLog (err) {
+  if (err && typeof err.delegate === 'function') {
+    const result = err.delegate()
+    return Array.isArray(result) ? Log.parse(...result) : Log.parse(result)
+  } else {
+    return err
   }
+}
 
-  if (typeof err === 'string') {
-    err = new Error(err)
-  }
+function onError (err) {
+  const { formatted, cause } = getErrorLog(err)
+
+  // calling twice logger.error() because Error cause is only available in nodejs v16.9.0
+  // TODO: replace it with Error(message, { cause }) when cause has broad support
+  if (formatted) withNoop(() => logger.error(new Error(formatted)))
+  if (cause) withNoop(() => logger.error(cause))
+}
+
+function onWarn (log) {
+  const { formatted, cause } = getErrorLog(log)
+  if (formatted) withNoop(() => logger.warn(formatted))
+  if (cause) withNoop(() => logger.warn(cause))
+}
 
-  withNoop(() => logger.error(err))
+function onInfo (log) {
+  const { formatted, cause } = getErrorLog(log)
+  if (formatted) withNoop(() => logger.info(formatted))
+  if (cause) withNoop(() => logger.info(cause))
 }
 
-function warn (message) {
-  if (!logger.warn) return debug(message)
-  withNoop(() => logger.warn(message))
+function onDebug (log) {
+  const { formatted, cause } = getErrorLog(log)
+  if (formatted) withNoop(() => logger.debug(formatted))
+  if (cause) withNoop(() => logger.debug(cause))
 }
 
-function info (message) {
-  if (!logger.info) return debug(message)
-  withNoop(() => logger.info(message))
+function error (...args) {
+  onError(Log.parse(...args))
+}
+
+function warn (...args) {
+  const log = Log.parse(...args)
+  if (!logger.warn) return onDebug(log)
+
+  onWarn(log)
+}
+
+function info (...args) {
+  const log = Log.parse(...args)
+  if (!logger.info) return onDebug(log)
+
+  onInfo(log)
 }
 
-function debug (message) {
-  withNoop(() => logger.debug(message))
+function debug (...args) {
+  onDebug(Log.parse(...args))
 }
 
 module.exports = { use, toggle, reset, error, warn, info, debug }

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

@@ -3,16 +3,19 @@
 const NoopTracer = require('./tracer')
 const NoopAppsecSdk = require('../appsec/sdk/noop')
 const NoopDogStatsDClient = require('./dogstatsd')
+const NoopLLMObsSDK = require('../llmobs/noop')
 
 const noop = new NoopTracer()
 const noopAppsec = new NoopAppsecSdk()
 const noopDogStatsDClient = new NoopDogStatsDClient()
+const noopLLMObs = new NoopLLMObsSDK(noop)
 
 class Tracer {
   constructor () {
     this._tracer = noop
     this.appsec = noopAppsec
     this.dogstatsd = noopDogStatsDClient
+    this.llmobs = noopLLMObs
   }
 
   init () {

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

@@ -16,9 +16,13 @@ class NoopSpan {
   setOperationName (name) { return this }
   setBaggageItem (key, value) { return this }
   getBaggageItem (key) {}
+  getAllBaggageItems () {}
+  removeBaggageItem (key) { return this }
+  removeAllBaggageItems () { return this }
   setTag (key, value) { return this }
   addTags (keyValueMap) { return this }
   addLink (link) { return this }
+  addSpanPointer (ptrKind, ptrDir, ptrHash) { return this }
   log () { return this }
   logEvent () {}
   finish (finishTime) {}

package/packages/dd-trace/src/opentelemetry/span.js

@@ -14,6 +14,7 @@ const { SERVICE_NAME, RESOURCE_NAME } = require('../../../../ext/tags')
 const kinds = require('../../../../ext/kinds')
 
 const SpanContext = require('./span_context')
+const id = require('../id')
 
 // The one built into OTel rounds so we lose sub-millisecond precision.
 function hrTimeToMilliseconds (time) {
@@ -142,7 +143,7 @@ class Span {
       context: spanContext._ddContext,
       startTime,
       hostname: _tracer._hostname,
-      integrationName: 'otel',
+      integrationName: parentTracer?._isOtelLibrary ? 'otel.library' : 'otel',
       tags: {
         [SERVICE_NAME]: _tracer._service,
         [RESOURCE_NAME]: spanName
@@ -217,6 +218,20 @@ class Span {
     return this
   }
 
+  addSpanPointer (ptrKind, ptrDir, ptrHash) {
+    const zeroContext = new SpanContext({
+      traceId: id('0'),
+      spanId: id('0')
+    })
+    const attributes = {
+      'ptr.kind': ptrKind,
+      'ptr.dir': ptrDir,
+      'ptr.hash': ptrHash,
+      'link.kind': 'span-pointer'
+    }
+    return this.addLink(zeroContext, attributes)
+  }
+
   setStatus ({ code, message }) {
     if (!this.ended && !this._hasStatus && code) {
       this._hasStatus = true

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

@@ -16,6 +16,7 @@ class Tracer {
     this._tracerProvider = tracerProvider
     // Is there a reason this is public?
     this.instrumentationLibrary = library
+    this._isOtelLibrary = library?.name?.startsWith('@opentelemetry/instrumentation-')
     this._spanLimits = {}
   }