dd-trace 6.20.1 → 6.22.0

package/packages/datadog-instrumentations/src/nova-sonic/session.js

@@ -0,0 +1,483 @@
+'use strict'
+
+const { randomUUID } = require('node:crypto')
+
+const log = require('../../../dd-trace/src/log')
+const { InputAudio, OutputAudio } = require('./audio')
+
+const MAX_TEXT = 65_536
+// Replayed history can exceed 16 messages after only eight exchanges. Allow longer resumed
+// conversations while bounding tiny/empty message overhead independently of the total text budget.
+const MAX_HISTORY_MESSAGES = 128
+const MAX_BLOCKS = 256
+const MAX_TOOLS = 16
+const MAX_TOOL_TEXT = 4096
+
+class Turn {
+  windows = []
+  userText = ''
+  finalText = ''
+  speculativeText = ''
+  tools = []
+  toolResults = []
+  inputPcm
+  inputRate = 0
+  inputStart
+  inputEnd
+  inputAudioObserved = false
+  outputAudioObserved = false
+  audioStarted = false
+  output = new OutputAudio()
+  started
+  generationEnd
+  textEnd
+  completionId
+  metrics = { input_tokens: 0, output_tokens: 0, total_tokens: 0 }
+  missingAudioMetrics = new Set()
+  emitted = false
+}
+
+/** @param {Turn} turn */
+function hasInput (turn) {
+  return turn.windows.length || turn.userText || turn.toolResults.length
+}
+
+/** @param {Turn} turn */
+function completionTime (turn) {
+  // Text can finish before audio starts. Keep its boundary as a fallback, without completing
+  // an unfinished or interrupted audio response when its final transcript arrives.
+  return turn.generationEnd ?? (!turn.audioStarted && turn.output.interrupted === undefined ? turn.textEnd : undefined)
+}
+
+/** @param {unknown} value */
+function object (value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+}
+
+/**
+ * @param {string} text
+ */
+function parse (text) {
+  try {
+    return JSON.parse(text)
+  } catch {
+    return {}
+  }
+}
+
+/**
+ * Nova's completion ID can cover the entire connection. Local response ownership is driven by
+ * pending input and new generation, with FINAL text staying on the preceding response.
+ */
+class SonicSession {
+  #emit
+  #audio = new InputAudio()
+  #pending = new Turn()
+  #current
+  #outbound = new Map()
+  #blocks = new Map()
+  #completed = new Set()
+  #prompt
+  #configuration = {}
+  #outputConfiguration = {}
+  #history = []
+  #closed = false
+  #turnIndex = 0
+  #sessionId = randomUUID()
+  #providerSessionId
+  #totals = { input_tokens: 0, output_tokens: 0 }
+  #audioTotals = { input: 0, output: 0 }
+
+  /** @param {(descriptor: object) => void} emit */
+  constructor (emit) {
+    this.#emit = emit
+  }
+
+  /**
+   * Observe decoded SDK union members without consuming either iterable ahead of its owner.
+   * @param {{ chunk?: { bytes?: Uint8Array } }} event
+   * @param {boolean} outbound
+   * @param {number} [now]
+   */
+  observe (event, outbound, now = Date.now()) {
+    if (this.#closed) return
+    try {
+      const bytes = event?.chunk?.bytes
+      if (!ArrayBuffer.isView(bytes)) return
+      const payload = parse(Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString('utf8'))
+      if (!object(payload?.event)) return
+      for (const [name, data] of Object.entries(payload.event)) {
+        if (!object(data)) continue
+        if (outbound) {
+          this.#sent(name, data, now)
+        } else {
+          this.#received(name, data, now)
+        }
+        if (this.#closed) break
+      }
+    } catch {
+      // Malformed telemetry never changes transport behavior or logs captured conversation data.
+      log.debug('Cannot process Nova Sonic telemetry')
+    }
+  }
+
+  /**
+   * @param {string} name
+   * @param {object} data
+   * @param {number} now
+   */
+  #sent (name, data, now) {
+    const key = data.contentName ?? ''
+    switch (name) {
+      case 'sessionStart':
+        for (const name of ['inferenceConfiguration', 'turnDetectionConfiguration']) {
+          const config = this.#configuration[name] = {}
+          if (!object(data[name])) continue
+          for (const key of ['maxTokens', 'topP', 'temperature', 'endpointingSensitivity']) {
+            const value = data[name][key]
+            if ((typeof value === 'number' || typeof value === 'string') && String(value).length < 128) {
+              config[key] = value
+            }
+          }
+        }
+        break
+      case 'promptStart':
+        if (this.#prompt !== undefined && this.#prompt !== data.promptName) {
+          this.finish(undefined, now)
+          return
+        }
+        this.#prompt = data.promptName
+        this.#outputConfiguration = data.audioOutputConfiguration ?? {}
+        break
+      case 'contentStart':
+        this.#outbound.set(key, { ...data, text: '' })
+        if (data.type === 'AUDIO' && data.role === 'USER') this.#audio.configure(data.audioInputConfiguration)
+        this.#bound(this.#outbound)
+        break
+      case 'audioInput': {
+        const block = this.#outbound.get(key)
+        if (block?.type === 'AUDIO' && block.role === 'USER') {
+          if (typeof data.content === 'string' && data.content.length) this.#pending.inputAudioObserved = true
+          this.#audio.append(data.content, now)
+        }
+        break
+      }
+      case 'textInput': {
+        const block = this.#outbound.get(key)
+        if (block && typeof data.content === 'string') block.text = (block.text + data.content).slice(0, MAX_TEXT)
+        break
+      }
+      case 'toolResult': {
+        const block = this.#outbound.get(key)
+        const target = this.#current ?? this.#pending
+        if (target.toolResults.length < MAX_TOOLS && typeof data.content === 'string') {
+          target.toolResults.push({
+            role: 'tool',
+            content: '',
+            toolResults: [{
+              result: data.content.slice(0, MAX_TOOL_TEXT),
+              toolId: block?.toolResultInputConfiguration?.toolUseId ?? '',
+              type: 'tool_result',
+            }],
+          })
+        }
+        break
+      }
+      case 'contentEnd': {
+        const block = this.#outbound.get(key)
+        this.#outbound.delete(key)
+        if (block?.type !== 'TEXT') break
+        if (block.role === 'USER' && block.interactive) {
+          this.#pending.userText = (this.#pending.userText + block.text).slice(0, MAX_TEXT)
+        } else if (this.#history.length < MAX_HISTORY_MESSAGES) {
+          const remaining = MAX_TEXT - this.#history.reduce((n, message) => n + message.content.length, 0)
+          this.#history.push({
+            role: String(block.role ?? 'USER').toLowerCase(), content: block.text.slice(0, remaining),
+          })
+        }
+        break
+      }
+    }
+  }
+
+  /**
+   * @param {Map<string, object>} map
+   */
+  #bound (map) {
+    while (map.size > MAX_BLOCKS) map.delete(map.keys().next().value)
+  }
+
+  #hasPendingInput () {
+    if (hasInput(this.#pending)) return true
+    // ASR text may precede contentEnd, even when speech boundary events are absent.
+    for (const block of this.#blocks.values()) {
+      if (block.turn === this.#pending && block.data.role === 'USER' && block.text) return true
+    }
+    return false
+  }
+
+  /**
+   * @param {object} data
+   * @param {number} now
+   */
+  #startResponse (data, now) {
+    if (!this.#current || this.#hasPendingInput()) {
+      if (this.#current) {
+        // A new response can arrive before the previous response's text blocks close.
+        for (const block of this.#blocks.values()) {
+          if (block.turn === this.#current) this.#text(block)
+        }
+        this.#emitTurn(this.#current, now)
+      }
+      const turn = this.#pending
+      this.#pending = new Turn()
+      turn.started = now
+      turn.completionId = data.completionId
+      this.#snapshotInput(turn)
+      this.#current = turn
+      for (const [key, block] of this.#blocks) {
+        if (block.turn !== turn) this.#blocks.delete(key)
+      }
+    }
+    return this.#current
+  }
+
+  /** @param {Turn} turn */
+  #snapshotInput (turn) {
+    if (turn.windows.length && !turn.inputPcm) {
+      turn.inputRate = this.#audio.rate
+      turn.inputPcm = this.#audio.clip(turn.windows[0].start_ms, turn.windows.at(-1).end_ms)
+    }
+  }
+
+  /**
+   * @param {string} name
+   * @param {object} data
+   * @param {number} now
+   */
+  #received (name, data, now) {
+    // Once any turn has been emitted, its conversation identity must never change.
+    if (!this.#providerSessionId && typeof data.sessionId === 'string' && data.sessionId) {
+      this.#providerSessionId = data.sessionId
+      if (!this.#turnIndex) this.#sessionId = data.sessionId
+    }
+    switch (name) {
+      case 'userSpeechStart': {
+        const offset = data.inputAudioOffsetMs
+        if (!Number.isFinite(offset) || offset < 0 || this.#pending.windows.length >= MAX_BLOCKS) return
+        this.#pending.windows.push({ start_ms: offset })
+        this.#pending.inputAudioObserved = true
+        this.#pending.inputEnd = undefined
+        this.#pending.inputStart ??= this.#audio.anchor === undefined
+          ? now
+          : Math.min(now, this.#audio.anchor + offset)
+        break
+      }
+      case 'userSpeechEnd': {
+        const window = this.#pending.windows.at(-1)
+        const end = data.inputAudioOffsetMs
+        if (!window || !Number.isFinite(end) || end <= window.start_ms) return
+        window.end_ms = end
+        if (Number.isFinite(data.inputAudioDetectionOffsetMs)) window.detection_ms = data.inputAudioDetectionOffsetMs
+        this.#pending.inputEnd = now
+        break
+      }
+      case 'contentStart': {
+        const key = data.contentId ?? ''
+        if (this.#blocks.has(key) || this.#completed.has(key)) return
+        const fields = object(data.additionalModelFields)
+          ? data.additionalModelFields
+          : parse(data.additionalModelFields)
+        const stage = object(fields) ? fields.generationStage : undefined
+        let turn
+        if (data.role === 'ASSISTANT' || data.type === 'TOOL') {
+          const newTextResponse = this.#current && !this.#current.audioStarted &&
+            completionTime(this.#current) !== undefined && this.#hasPendingInput()
+          turn = stage === 'FINAL' && this.#current && !newTextResponse
+            ? this.#current
+            : this.#startResponse(data, now)
+        } else {
+          turn = this.#hasPendingInput() || !this.#current || completionTime(this.#current) !== undefined
+            ? this.#pending
+            : this.#current
+        }
+        if (data.role === 'ASSISTANT' && data.type === 'AUDIO') turn.audioStarted = true
+        this.#blocks.set(key, { data, stage, turn, text: '', control: false })
+        this.#bound(this.#blocks)
+        break
+      }
+      case 'textOutput':
+      case 'audioOutput':
+      case 'toolUse':
+      case 'contentEnd':
+        this.#content(name, data, now)
+        break
+      case 'usageEvent':
+        this.#usage(data)
+        break
+      case 'completionEnd':
+        this.finish(undefined, now)
+        break
+    }
+  }
+
+  /**
+   * @param {string} name
+   * @param {object} data
+   * @param {number} now
+   */
+  #content (name, data, now) {
+    const key = data.contentId ?? ''
+    const block = this.#blocks.get(key)
+    if (!block) return
+    const { turn } = block
+    if (name === 'textOutput' && typeof data.content === 'string') {
+      block.text = (block.text + data.content).slice(0, MAX_TEXT)
+      if (block.data.role === 'ASSISTANT' && parse(block.text)?.interrupted === true) {
+        // Keep literal JSON until contentEnd confirms protocol control. Retain its
+        // receipt time so confirmation does not move the projected playback cut.
+        block.interruptionTime ??= now
+      } else {
+        block.interruptionTime = undefined
+      }
+    } else if (name === 'audioOutput' && block.data.role === 'ASSISTANT') {
+      if (typeof data.content === 'string' && data.content.length) turn.outputAudioObserved = true
+      turn.output.append(data.content, block.data.audioOutputConfiguration ?? this.#outputConfiguration, now)
+    } else if (name === 'toolUse' && turn.tools.length < MAX_TOOLS) {
+      const args = typeof data.content === 'string' && data.content.length <= MAX_TOOL_TEXT ? parse(data.content) : {}
+      turn.tools.push({
+        name: data.toolName ?? '',
+        arguments: object(args) ? args : {},
+        toolId: data.toolUseId ?? '',
+        type: 'function',
+      })
+    } else if (name === 'contentEnd') {
+      if (block.data.role === 'ASSISTANT' && data.stopReason === 'INTERRUPTED') {
+        block.control = block.interruptionTime !== undefined
+        turn.output.interrupt(block.interruptionTime ?? now)
+      }
+      this.#text(block)
+      if (block.data.type === 'AUDIO' && data.stopReason === 'END_TURN') turn.generationEnd = now
+      if (block.data.role === 'ASSISTANT' && block.data.type === 'TEXT' &&
+          !block.control && data.stopReason === 'END_TURN') turn.textEnd = now
+      this.#blocks.delete(key)
+      this.#completed.add(key)
+      if (this.#completed.size > MAX_BLOCKS) this.#completed.delete(this.#completed.values().next().value)
+    }
+  }
+
+  /** @param {{ control: boolean, data: object, stage?: string, text: string, turn: object }} block */
+  #text (block) {
+    if (block.control) return
+    const field = block.data.role === 'USER'
+      ? 'userText'
+      : block.stage === 'FINAL' ? 'finalText' : 'speculativeText'
+    block.turn[field] = (block.turn[field] + block.text).slice(0, MAX_TEXT)
+  }
+
+  /** @param {object} data */
+  #usage (data) {
+    for (const direction of ['input', 'output']) {
+      const key = `${direction}_tokens`
+      const total = data[direction === 'input' ? 'totalInputTokens' : 'totalOutputTokens']
+      if (!Number.isSafeInteger(total) || total < this.#totals[key]) continue
+      const delta = total - this.#totals[key]
+      this.#totals[key] = total
+      const target = !this.#current || (direction === 'input' && this.#hasPendingInput())
+        ? this.#pending
+        : this.#current
+      target.metrics[key] += delta
+      target.metrics.total_tokens += delta
+
+      // Speech usage is a subset of these totals, never another charge to total_tokens.
+      const audioKey = `${direction}_audio_tokens`
+      const audioTotal = data.details?.total?.[direction]?.speechTokens
+      const previous = this.#audioTotals[direction]
+      const valid = Number.isSafeInteger(audioTotal) && audioTotal >= 0 && audioTotal <= total &&
+        (previous === undefined || audioTotal >= previous)
+      const audioDelta = valid && previous !== undefined ? audioTotal - previous : undefined
+      this.#audioTotals[direction] = valid ? audioTotal : delta ? undefined : previous
+      if (audioDelta === undefined || audioDelta > delta) {
+        if (delta || audioDelta > delta) {
+          target.missingAudioMetrics.add(audioKey)
+          delete target.metrics[audioKey]
+        }
+      } else if (!target.missingAudioMetrics.has(audioKey)) {
+        target.metrics[audioKey] = (target.metrics[audioKey] ?? 0) + audioDelta
+      }
+    }
+  }
+
+  /**
+   * @param {Turn} turn
+   * @param {number} now
+   * @param {Error} [error]
+   */
+  #emitTurn (turn, now, error) {
+    if (turn.emitted) return
+    turn.emitted = true
+    this.#turnIndex++
+    try {
+      this.#snapshotInput(turn)
+      const start = turn.inputStart ?? turn.started ?? now
+      const llmStart = turn.inputEnd ?? turn.started ?? start
+      const completed = completionTime(turn)
+      const responseEnd = Math.max(llmStart, completed ?? turn.output.interrupted ?? now)
+      this.#emit({
+        turn,
+        error,
+        sessionId: this.#sessionId,
+        history: this.#history,
+        startTime: start,
+        finishTime: Math.max(responseEnd, turn.output.end ?? 0, turn.inputEnd ?? 0),
+        llmStart,
+        responseEnd,
+        metadata: {
+          turn_index: this.#turnIndex,
+          completion_id: turn.completionId,
+          speech_windows: turn.windows,
+          ttfa_boundary: 'speech_end_event_receipt',
+          output_timing: 'projected_playback',
+          interrupted: turn.output.interrupted !== undefined,
+          partial: completed === undefined,
+          transcript_stage: turn.finalText ? 'FINAL' : 'SPECULATIVE',
+          usage_attribution: 'event_receipt',
+          generated_output_bytes: turn.output.generatedBytes,
+          session_configuration: this.#configuration,
+        },
+      })
+    } catch {
+      log.debug('Cannot emit Nova Sonic turn')
+    }
+  }
+
+  /**
+   * Input EOF is deliberately not a finish. Only output completion, cancellation or failure flushes.
+   * @param {Error} [error]
+   * @param {number} [now]
+   */
+  finish (error, now = Date.now()) {
+    if (this.#closed) return
+    this.#closed = true
+    for (const block of this.#blocks.values()) this.#text(block)
+    if (this.#current) {
+      // A failure before the next response starts belongs to its pending utterance,
+      // not to the response that has already completed.
+      const laterTurnFailed = completionTime(this.#current) !== undefined && this.#hasPendingInput()
+      this.#emitTurn(this.#current, now, laterTurnFailed ? undefined : error)
+    }
+    if (hasInput(this.#pending) || this.#pending.metrics.total_tokens || (error && !this.#current)) {
+      this.#emitTurn(this.#pending, now, error)
+    }
+    this.#current = undefined
+    this.#pending = new Turn()
+    this.#blocks.clear()
+    this.#outbound.clear()
+    this.#completed.clear()
+    this.#history = []
+    this.#audio.clear()
+    this.#emit = undefined
+  }
+}
+
+module.exports = SonicSession

package/packages/datadog-instrumentations/src/openai-realtime/index.js

@@ -10,6 +10,11 @@ const RealtimeSession = require('./session')
 /**
  * @typedef {import('./session').TurnDescriptor} TurnDescriptor
  * @typedef {import('./turns').ResponseTurn} ResponseTurn
+ * @typedef {{
+ *   session: RealtimeSession,
+ *   socket: object | undefined,
+ *   finalize: (failed?: boolean) => void,
+ * }} Connection
  */
 
 // One span per phase of a turn. `user speech` and `agent speech` share a channel: they differ only
@@ -36,7 +41,7 @@ const audioChannel = dc.channel('dd-trace:openai:realtime:audio')
 const USER_SPEECH = { operation: 'createRealtimeUserSpeech', llmobsName: 'user speech' }
 const AGENT_SPEECH = { operation: 'createRealtimeAgentSpeech', llmobsName: 'agent speech' }
 
-/** @type {WeakMap<object, { session: RealtimeSession, finalize: () => void }>} */
+/** @type {WeakMap<object, Connection>} */
 const connections = new WeakMap()
 
 /**
@@ -92,7 +97,7 @@ function captureContext (turn) {
  * Start tracking a connection, reading the model and base path off the URL the SDK already built.
  *
  * @param {object} emitter
- * @returns {{ session: RealtimeSession, finalize: () => void }}
+ * @returns {Connection}
  */
 function createConnection (emitter) {
   let model
@@ -135,7 +140,7 @@ function createConnection (emitter) {
     session.finishSession(Date.now(), failed)
   }
 
-  const connection = { session, finalize }
+  const connection = { session, socket: emitter.socket, finalize }
   attachSocketClose(emitter, finalize)
   return connection
 }
@@ -181,14 +186,21 @@ function attachSocketClose (emitter, finalize) {
 
 /**
  * @param {object} emitter
- * @returns {{ session: RealtimeSession, finalize: () => void } | undefined}
+ * @returns {Connection | undefined}
  */
 function getConnection (emitter) {
   const connection = connections.get(emitter)
-  if (connection !== undefined) return connection
+  if (connection !== undefined) {
+    if (connection.socket === emitter.socket) return connection
+
+    // Opt-in SDK recovery keeps the emitter but replaces its socket with a new server session.
+    // Retire the old state before attaching close and exit cleanup to the replacement.
+    connection.finalize(true)
+    connections.delete(emitter)
+  }
 
   // Nothing is listening, so never allocate. Checked only on the miss path, so an established
-  // connection pays one WeakMap lookup per event.
+  // connection reuses its state while the socket is unchanged.
   if (!turnChannel.start.hasSubscribers) return
 
   const created = createConnection(emitter)

package/packages/datadog-instrumentations/src/openai-realtime/session.js

@@ -829,7 +829,7 @@ class RealtimeSession {
       input.audio.totalDecodedBytes, inputFormat.mimeType, inputFormat.sampleRate
     )
     const userEnd = input.speechEndTime ??
-      (userStart !== undefined && inputDurationMs !== undefined ? userStart + inputDurationMs : undefined)
+      (userStart === undefined || inputDurationMs === undefined ? undefined : userStart + inputDurationMs)
 
     const agentStart = turn.audio.startTime
     const playbackMs = segmentDurationMs(

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

@@ -58,6 +58,13 @@ const V4_PACKAGE_SHIMS = [
     versions: ['>=4.87.0'],
     interceptChannel: responsesInterceptChannel,
   },
+  {
+    file: 'resources/decisions',
+    targetClass: 'Decisions',
+    baseResource: 'decisions',
+    methods: ['create'],
+    versions: ['>=7.30.0'],
+  },
   {
     file: 'resources/embeddings',
     targetClass: 'Embeddings',

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

@@ -10,10 +10,9 @@ const logSubmissionCh = channel('ci:log-submission:log')
 
 /**
  * @param {string} symbol
- * @param {(original: Function) => Function} wrapper
  * @param {Function} pino
  */
-function wrapPino (symbol, wrapper, pino) {
+function wrapPino (symbol, pino) {
   /**
    * @param {unknown[]} args
    * @returns {unknown}
@@ -25,7 +24,7 @@ function wrapPino (symbol, wrapper, pino) {
       configurable: true,
       enumerable: true,
       writable: true,
-      value: wrapper(instance[symbol]),
+      value: wrapAsJson(instance[symbol]),
     })
 
     return instance
@@ -83,19 +82,19 @@ function wrapPrettyFactory (prettyFactory) {
 addHook({ name: 'pino', versions: ['2 - 3', '4'], patchDefault: true }, (pino) => {
   const asJsonSym = (pino.symbols && pino.symbols.asJsonSym) || 'asJson'
 
-  return shimmer.wrapFunction(pino, pino => wrapPino(asJsonSym, wrapAsJson, pino))
+  return shimmer.wrapFunction(pino, pino => wrapPino(asJsonSym, pino))
 })
 
 addHook({ name: 'pino', versions: ['>=5 <6.8.0'], patchDefault: true }, (pino) => {
   const asJsonSym = ((pino.default || pino)?.symbols.asJsonSym) || 'asJson'
 
-  return shimmer.wrapFunction(pino, pino => wrapPino(asJsonSym, wrapAsJson, pino.default || pino))
+  return shimmer.wrapFunction(pino, pino => wrapPino(asJsonSym, pino.default || pino))
 })
 
 addHook({ name: 'pino', versions: ['>=6.8.0'], patchDefault: false }, (pino) => {
   const asJsonSym = pino.symbols.asJsonSym
 
-  const wrapped = shimmer.wrapFunction(pino, pino => wrapPino(asJsonSym, wrapAsJson, pino))
+  const wrapped = shimmer.wrapFunction(pino, pino => wrapPino(asJsonSym, pino))
   wrapped.pino = wrapped
   wrapped.default = wrapped
 

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

@@ -2657,11 +2657,14 @@ function instrumentWorkerMainMethods (workerMain) {
       }
 
       // In cases where there is no afterEach hook with _ddHook, we need to add one
+      // Playwright 1.64 builds the hook step stack from hook.location, so an undefined
+      // location ends up as [undefined] and breaks trace writing
       if (!existAfterEachHook) {
         test.parent._hooks.push({
           type: 'afterEach',
           fn: cleanupRumPages,
           title: 'afterEach hook',
+          location: test.location,
           _ddHook: true,
         })
       }