@depup/dd-trace 5.90.0-depup.0

package/packages/datadog-plugin-openai/src/services.js

@@ -0,0 +1,48 @@
+'use strict'
+
+const { DogStatsDClient } = require('../../dd-trace/src/dogstatsd')
+const NoopDogStatsDClient = require('../../dd-trace/src/noop/dogstatsd')
+const { ExternalLogger, NoopExternalLogger } = require('../../dd-trace/src/external-logger/src')
+
+const FLUSH_INTERVAL = 10 * 1000
+
+let metrics = null
+let logger = null
+let interval = null
+
+module.exports.init = function (tracerConfig) {
+  metrics = tracerConfig && tracerConfig.dogstatsd
+    ? new DogStatsDClient({
+      host: tracerConfig.dogstatsd.hostname,
+      port: tracerConfig.dogstatsd.port,
+      tags: [
+        `service:${tracerConfig.tags.service}`,
+        `env:${tracerConfig.tags.env}`,
+        `version:${tracerConfig.tags.version}`,
+      ],
+    })
+    : new NoopDogStatsDClient()
+
+  logger = tracerConfig && tracerConfig.apiKey
+    ? new ExternalLogger({
+      ddsource: 'openai',
+      hostname: tracerConfig.hostname,
+      service: tracerConfig.service,
+      apiKey: tracerConfig.apiKey,
+      interval: FLUSH_INTERVAL,
+    })
+    : new NoopExternalLogger()
+
+  interval = setInterval(() => {
+    metrics.flush()
+  }, FLUSH_INTERVAL).unref()
+
+  return { metrics, logger }
+}
+
+module.exports.shutdown = function () {
+  clearInterval(interval)
+  metrics = null
+  logger = null
+  interval = null
+}

package/packages/datadog-plugin-openai/src/stream-helpers.js

@@ -0,0 +1,159 @@
+'use strict'
+
+/**
+ * @typedef {Record<string, unknown>} JsonObject
+ *
+ * @typedef {{ function: { arguments: string } }} ToolCall
+ * @typedef {{ content?: string, tool_calls?: ToolCall[] }} ChatDelta
+ *
+ * @typedef {{
+ *   index: number,
+ *   finish_reason?: string | null,
+ *   text?: string,
+ *   delta?: ChatDelta
+ * }} StreamChoice
+ *
+ * @typedef {JsonObject & { choices: StreamChoice[], usage?: unknown }} StreamChunk
+ * @typedef {JsonObject & { choices: Array<StreamChoice | undefined>, usage?: unknown }} StreamResponseBody
+ *
+ * @typedef {JsonObject & { status?: string }} ResponsesApiResponse
+ * @typedef {JsonObject & { response?: ResponsesApiResponse }} ResponsesApiChunk
+ */
+
+/**
+ * Combines legacy OpenAI streamed chunks into a single object.
+ * These legacy chunks are returned as buffers instead of individual objects.
+ * @param {readonly Uint8Array[]} chunks
+ * @returns {JsonObject[]}
+ */
+function convertBuffersToObjects (chunks) {
+  return Buffer
+    .concat(chunks) // combine the buffers
+    .toString() // stringify
+    .split(/(?=data:)/) // split on "data:"
+    .map(chunk => chunk.replaceAll('\n', '').slice(6)) // remove newlines and 'data: ' from the front
+    .slice(0, -1) // remove the last [DONE] message
+    .map(JSON.parse) // parse all of the returned objects
+}
+
+/**
+ * Common function for combining chunks with n choices into a single response body.
+ * The shared logic will add a new choice index entry if it doesn't exist, and otherwise
+ * hand off to a onChoice handler to add that choice to the previously stored choice.
+ *
+ * @param {StreamChunk[]} chunks
+ * @param {number} n
+ * @param {(newChoice: StreamChoice, existingChoice: StreamChoice) => void} onChoice
+ * @returns {StreamResponseBody}
+ */
+function constructResponseFromStreamedChunks (chunks, n, onChoice) {
+  const body = { ...chunks[0], choices: Array.from({ length: n }) }
+
+  for (const chunk of chunks) {
+    body.usage = chunk.usage
+    for (const choice of chunk.choices) {
+      const choiceIdx = choice.index
+      const oldChoice = body.choices.find(choice => choice?.index === choiceIdx)
+
+      if (!oldChoice) {
+        body.choices[choiceIdx] = choice
+        continue
+      }
+
+      if (!oldChoice.finish_reason) {
+        oldChoice.finish_reason = choice.finish_reason
+      }
+
+      onChoice(choice, oldChoice)
+    }
+  }
+
+  return body
+}
+
+/**
+ * Constructs the entire response from a stream of OpenAI completion chunks,
+ * mainly combining the text choices of each chunk into a single string per choice.
+ * @param {StreamChunk[]} chunks
+ * @param {number} n the number of choices to expect in the response
+ * @returns {StreamResponseBody}
+ */
+function constructCompletionResponseFromStreamedChunks (chunks, n) {
+  return constructResponseFromStreamedChunks(chunks, n, (choice, oldChoice) => {
+    const text = choice.text
+    if (text) {
+      if (oldChoice.text) {
+        oldChoice.text += text
+      } else {
+        oldChoice.text = text
+      }
+    }
+  })
+}
+
+/**
+ * Constructs the entire response from a stream of OpenAI chat completion chunks,
+ * mainly combining the text choices of each chunk into a single string per choice.
+ * @param {StreamChunk[]} chunks
+ * @param {number} n the number of choices to expect in the response
+ * @returns {StreamResponseBody}
+ */
+function constructChatCompletionResponseFromStreamedChunks (chunks, n) {
+  return constructResponseFromStreamedChunks(chunks, n, (choice, oldChoice) => {
+    const delta = choice.delta
+    if (!delta) return
+
+    const content = delta.content
+    if (content) {
+      if (oldChoice.delta.content) {
+        oldChoice.delta.content += content
+      } else {
+        oldChoice.delta.content = content
+      }
+    }
+
+    const tools = delta.tool_calls
+    if (!tools) return
+
+    oldChoice.delta.tool_calls = tools.map((newTool, toolIdx) => {
+      const oldTool = oldChoice.delta.tool_calls?.[toolIdx]
+      if (oldTool) {
+        oldTool.function.arguments += newTool.function.arguments
+        return oldTool
+      }
+
+      return newTool
+    })
+  })
+}
+
+/**
+ * Constructs the entire response from a stream of OpenAI responses chunks.
+ * The responses API uses event-based streaming with delta chunks.
+ * @param {ResponsesApiChunk[]} chunks
+ * @returns {ResponsesApiResponse|undefined}
+ */
+function constructResponseResponseFromStreamedChunks (chunks) {
+  // The responses API streams events with different types:
+  // - response.output_text.delta: incremental text deltas
+  // - response.output_text.done: complete text for a content part
+  // - response.output_item.done: complete output item with role
+  // - response.done/response.incomplete/response.completed: final response with output array and usage
+
+  // Find the last chunk with a complete response object (status: done, incomplete, or completed)
+  const responseStatusSet = new Set(['done', 'incomplete', 'completed'])
+
+  for (let i = chunks.length - 1; i >= 0; i--) {
+    const chunk = chunks[i]
+    if (chunk.response && responseStatusSet.has(chunk.response.status)) {
+      return chunk.response
+    }
+  }
+}
+
+module.exports = {
+  convertBuffersToObjects,
+  constructCompletionResponseFromStreamedChunks,
+  constructChatCompletionResponseFromStreamedChunks,
+  constructResponseResponseFromStreamedChunks,
+}

package/packages/datadog-plugin-openai/src/token-estimator.js

@@ -0,0 +1,20 @@
+'use strict'
+
+// If model is unavailable or tiktoken is not imported, then provide a very rough estimate of the number of tokens
+// Approximate using the following assumptions:
+//    * English text
+//    * 1 token ~= 4 chars
+//    * 1 token ~= ¾ words
+module.exports.estimateTokens = function (content) {
+  let estimatedTokens = 0
+  if (typeof content === 'string') {
+    const estimation1 = content.length / 4
+
+    const matches = content.match(/[\w']+|[.,!?;~@#$%^&*()+/-]/g)
+    const estimation2 = matches ? matches.length * 0.75 : 0 // in the case of an empty string
+    estimatedTokens = Math.round((1.5 * estimation1 + 0.5 * estimation2) / 2)
+  } else if (Array.isArray(content) && typeof content[0] === 'number') {
+    estimatedTokens = content.length
+  }
+  return estimatedTokens
+}