dd-trace 5.55.0 → 5.57.0

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

@@ -13,6 +13,8 @@ const makeUtilities = require('../../dd-trace/src/plugins/util/llm')
 
 let normalize
 
+const { DD_MAJOR } = require('../../../version')
+
 function safeRequire (path) {
   try {
     return require(path)
@@ -59,11 +61,19 @@ class OpenAiTracingPlugin extends TracingPlugin {
   bindStart (ctx) {
     const { methodName, args, basePath, apiKey } = ctx
     const payload = normalizeRequestPayload(methodName, args)
+    const normalizedMethodName = normalizeMethodName(methodName)
+
     const store = storage('legacy').getStore() || {}
 
+    // hold onto these to make response extraction matching efficient
+    // the original method name corresponds to the SDK method name (e.g. createChatCompletion, chat.completions.create)
+    // the normalized method name corresponds to the resource name (e.g. createChatCompletion, createCompletion)
+    store.originalMethodName = methodName
+    store.normalizedMethodName = normalizedMethodName
+
     const span = this.startSpan('openai.request', {
       service: this.config.service,
-      resource: methodName,
+      resource: DD_MAJOR >= 6 ? normalizedMethodName : methodName,
       type: 'openai',
       kind: 'client',
       meta: {
@@ -129,62 +139,43 @@ class OpenAiTracingPlugin extends TracingPlugin {
       tags['openai.request.stream'] = payload.stream
     }
 
-    switch (methodName) {
+    switch (normalizedMethodName) {
       case 'createFineTune':
-      case 'fine_tuning.jobs.create':
-      case 'fine-tune.create':
         createFineTuneRequestExtraction(tags, payload)
         break
 
       case 'createImage':
-      case 'images.generate':
       case 'createImageEdit':
-      case 'images.edit':
       case 'createImageVariation':
-      case 'images.createVariation':
         commonCreateImageRequestExtraction(tags, payload, openaiStore)
         break
 
       case 'createChatCompletion':
-      case 'chat.completions.create':
         createChatCompletionRequestExtraction(tags, payload, openaiStore)
         break
 
       case 'createFile':
-      case 'files.create':
       case 'retrieveFile':
-      case 'files.retrieve':
         commonFileRequestExtraction(tags, payload)
         break
 
       case 'createTranscription':
-      case 'audio.transcriptions.create':
       case 'createTranslation':
-      case 'audio.translations.create':
         commonCreateAudioRequestExtraction(tags, payload, openaiStore)
         break
 
       case 'retrieveModel':
-      case 'models.retrieve':
         retrieveModelRequestExtraction(tags, payload)
         break
 
       case 'listFineTuneEvents':
-      case 'fine_tuning.jobs.listEvents':
-      case 'fine-tune.listEvents':
       case 'retrieveFineTune':
-      case 'fine_tuning.jobs.retrieve':
-      case 'fine-tune.retrieve':
       case 'deleteModel':
-      case 'models.del':
       case 'cancelFineTune':
-      case 'fine_tuning.jobs.cancel':
-      case 'fine-tune.cancel':
         commonLookupFineTuneRequestExtraction(tags, payload)
         break
 
       case 'createEdit':
-      case 'edits.create':
         createEditRequestExtraction(tags, payload, openaiStore)
         break
     }
@@ -216,9 +207,11 @@ class OpenAiTracingPlugin extends TracingPlugin {
     if (!error && headers?.constructor.name === 'Headers') {
       headers = Object.fromEntries(headers)
     }
-    const methodName = span._spanContext._tags['resource.name']
 
-    body = coerceResponseBody(body, methodName)
+    const resource = span._spanContext._tags['resource.name']
+    const normalizedMethodName = store.normalizedMethodName
+
+    body = coerceResponseBody(body, normalizedMethodName)
 
     const openaiStore = store.openai
 
@@ -227,7 +220,9 @@ class OpenAiTracingPlugin extends TracingPlugin {
       // not using a full regex as it will likely be "https://api.openai.com/..."
       path = new URL(path).pathname
     }
-    const endpoint = lookupOperationEndpoint(methodName, path)
+
+    const originalMethodName = store.originalMethodName
+    const endpoint = lookupOperationEndpoint(normalizedMethodName, originalMethodName, path)
 
     const tags = error
       ? {}
@@ -248,11 +243,11 @@ class OpenAiTracingPlugin extends TracingPlugin {
           'openai.response.created_at': body.created_at
         }
 
-    responseDataExtractionByMethod(methodName, tags, body, openaiStore)
+    responseDataExtractionByMethod(normalizedMethodName, tags, body, openaiStore)
     span.addTags(tags)
 
     span.finish()
-    this.sendLog(methodName, span, tags, openaiStore, error)
+    this.sendLog(resource, span, tags, openaiStore, error)
     this.sendMetrics(headers, body, endpoint, span._duration, error, tags)
   }
 
@@ -343,10 +338,90 @@ class OpenAiTracingPlugin extends TracingPlugin {
   }
 }
 
+function normalizeMethodName (methodName) {
+  switch (methodName) {
+    // moderations
+    case 'moderations.create':
+      return 'createModeration'
+
+    // completions
+    case 'completions.create':
+      return 'createCompletion'
+
+    // chat completions
+    case 'chat.completions.create':
+      return 'createChatCompletion'
+
+    // edits
+    case 'edits.create':
+      return 'createEdit'
+
+    // embeddings
+    case 'embeddings.create':
+      return 'createEmbedding'
+
+    // files
+    case 'files.create':
+      return 'createFile'
+    case 'files.retrieve':
+      return 'retrieveFile'
+    case 'files.del':
+    case 'files.delete':
+      return 'deleteFile'
+    case 'files.retrieveContent':
+    case 'files.content':
+      return 'downloadFile'
+    case 'files.list':
+      return 'listFiles'
+
+    // fine-tuning
+    case 'fine_tuning.jobs.list':
+    case 'fine-tune.list':
+      return 'listFineTunes'
+    case 'fine_tuning.jobs.listEvents':
+    case 'fine-tune.listEvents':
+      return 'listFineTuneEvents'
+    case 'fine_tuning.jobs.create':
+    case 'fine-tune.create':
+      return 'createFineTune'
+    case 'fine_tuning.jobs.retrieve':
+    case 'fine-tune.retrieve':
+      return 'retrieveFineTune'
+    case 'fine_tuning.jobs.cancel':
+    case 'fine-tune.cancel':
+      return 'cancelFineTune'
+
+    // audio
+    case 'audio.transcriptions.create':
+      return 'createTranscription'
+    case 'audio.translations.create':
+      return 'createTranslation'
+
+    // images
+    case 'images.generate':
+      return 'createImage'
+    case 'images.edit':
+      return 'createImageEdit'
+    case 'images.createVariation':
+      return 'createImageVariation'
+
+    // models
+    case 'models.list':
+      return 'listModels'
+    case 'models.retrieve':
+      return 'retrieveModel'
+    case 'models.del':
+    case 'models.delete':
+      return 'deleteModel'
+    default:
+      return methodName
+  }
+}
+
 function countPromptTokens (methodName, payload, model) {
   let promptTokens = 0
   let promptEstimated = false
-  if (methodName === 'chat.completions.create') {
+  if (methodName === 'createChatCompletion') {
     const messages = payload.messages
     for (const message of messages) {
       const content = message.content
@@ -367,7 +442,7 @@ function countPromptTokens (methodName, payload, model) {
         }
       }
     }
-  } else if (methodName === 'completions.create') {
+  } else if (methodName === 'createCompletion') {
     let prompt = payload.prompt
     if (!Array.isArray(prompt)) prompt = [prompt]
 
@@ -468,88 +543,60 @@ function commonCreateImageRequestExtraction (tags, payload, openaiStore) {
 function responseDataExtractionByMethod (methodName, tags, body, openaiStore) {
   switch (methodName) {
     case 'createModeration':
-    case 'moderations.create':
       createModerationResponseExtraction(tags, body)
       break
 
     case 'createCompletion':
-    case 'completions.create':
     case 'createChatCompletion':
-    case 'chat.completions.create':
     case 'createEdit':
-    case 'edits.create':
       commonCreateResponseExtraction(tags, body, openaiStore, methodName)
       break
 
     case 'listFiles':
-    case 'files.list':
     case 'listFineTunes':
-    case 'fine_tuning.jobs.list':
-    case 'fine-tune.list':
     case 'listFineTuneEvents':
-    case 'fine_tuning.jobs.listEvents':
-    case 'fine-tune.listEvents':
       commonListCountResponseExtraction(tags, body)
       break
 
     case 'createEmbedding':
-    case 'embeddings.create':
       createEmbeddingResponseExtraction(tags, body, openaiStore)
       break
 
     case 'createFile':
-    case 'files.create':
     case 'retrieveFile':
-    case 'files.retrieve':
       createRetrieveFileResponseExtraction(tags, body)
       break
 
     case 'deleteFile':
-    case 'files.del':
       deleteFileResponseExtraction(tags, body)
       break
 
     case 'downloadFile':
-    case 'files.retrieveContent':
-    case 'files.content':
       downloadFileResponseExtraction(tags, body)
       break
 
     case 'createFineTune':
-    case 'fine_tuning.jobs.create':
-    case 'fine-tune.create':
     case 'retrieveFineTune':
-    case 'fine_tuning.jobs.retrieve':
-    case 'fine-tune.retrieve':
     case 'cancelFineTune':
-    case 'fine_tuning.jobs.cancel':
-    case 'fine-tune.cancel':
       commonFineTuneResponseExtraction(tags, body)
       break
 
     case 'createTranscription':
-    case 'audio.transcriptions.create':
     case 'createTranslation':
-    case 'audio.translations.create':
       createAudioResponseExtraction(tags, body)
       break
 
     case 'createImage':
-    case 'images.generate':
     case 'createImageEdit':
-    case 'images.edit':
     case 'createImageVariation':
-    case 'images.createVariation':
       commonImageResponseExtraction(tags, body)
       break
 
     case 'listModels':
-    case 'models.list':
       listModelsResponseExtraction(tags, body)
       break
 
     case 'retrieveModel':
-    case 'models.retrieve':
       retrieveModelResponseExtraction(tags, body)
       break
   }
@@ -641,8 +688,8 @@ function commonFineTuneResponseExtraction (tags, body) {
 
 // the OpenAI package appears to stream the content download then provide it all as a singular string
 function downloadFileResponseExtraction (tags, body) {
-  if (!body.file) return
-  tags['openai.response.total_bytes'] = body.file.length
+  if (typeof body.file !== 'string') return
+  tags['openai.response.total_bytes'] = Buffer.byteLength(body.file)
 }
 
 function deleteFileResponseExtraction (tags, body) {
@@ -763,7 +810,7 @@ function usageExtraction (tags, body, methodName, openaiStore) {
     promptTokens = body.usage.prompt_tokens
     completionTokens = body.usage.completion_tokens
     totalTokens = body.usage.total_tokens
-  } else if (body.model && ['chat.completions.create', 'completions.create'].includes(methodName)) {
+  } else if (body.model && ['createChatCompletion', 'createCompletion'].includes(methodName)) {
     // estimate tokens based on method name for completions and chat completions
     const { model } = body
 
@@ -819,8 +866,6 @@ function tagChatCompletionRequestContent (contents, messageIdx, tags) {
 function coerceResponseBody (body, methodName) {
   switch (methodName) {
     case 'downloadFile':
-    case 'files.retrieveContent':
-    case 'files.content':
       return { file: body }
   }
 
@@ -839,42 +884,42 @@ function coerceResponseBody (body, methodName) {
 }
 
 // This method is used to replace a dynamic URL segment with an asterisk
-function lookupOperationEndpoint (operationId, url) {
+function lookupOperationEndpoint (operationId, methodName, url) {
   switch (operationId) {
     case 'deleteModel':
-    case 'models.del':
     case 'retrieveModel':
-    case 'models.retrieve':
       return '/v1/models/*'
 
     case 'deleteFile':
-    case 'files.del':
     case 'retrieveFile':
-    case 'files.retrieve':
       return '/v1/files/*'
 
     case 'downloadFile':
-    case 'files.retrieveContent':
-    case 'files.content':
       return '/v1/files/*/content'
 
     case 'retrieveFineTune':
-    case 'fine-tune.retrieve':
-      return '/v1/fine-tunes/*'
-    case 'fine_tuning.jobs.retrieve':
-      return '/v1/fine_tuning/jobs/*'
+      switch (methodName) {
+        case 'fine_tuning.jobs.retrieve':
+          return '/v1/fine_tuning/jobs/*'
+        default:
+          return '/v1/fine-tunes/*'
+      }
 
     case 'listFineTuneEvents':
-    case 'fine-tune.listEvents':
-      return '/v1/fine-tunes/*/events'
-    case 'fine_tuning.jobs.listEvents':
-      return '/v1/fine_tuning/jobs/*/events'
+      switch (methodName) {
+        case 'fine_tuning.jobs.listEvents':
+          return '/v1/fine_tuning/jobs/*/events'
+        default:
+          return '/v1/fine-tunes/*/events'
+      }
 
     case 'cancelFineTune':
-    case 'fine-tune.cancel':
-      return '/v1/fine-tunes/*/cancel'
-    case 'fine_tuning.jobs.cancel':
-      return '/v1/fine_tuning/jobs/*/cancel'
+      switch (methodName) {
+        case 'fine_tuning.jobs.cancel':
+          return '/v1/fine_tuning/jobs/*/cancel'
+        default:
+          return '/v1/fine-tunes/*/cancel'
+      }
   }
 
   return url
@@ -909,6 +954,7 @@ function normalizeRequestPayload (methodName, args) {
 
     case 'deleteFile':
     case 'files.del':
+    case 'files.delete':
     case 'retrieveFile':
     case 'files.retrieve':
     case 'downloadFile':
@@ -929,6 +975,7 @@ function normalizeRequestPayload (methodName, args) {
     case 'fine-tune.retrieve':
     case 'deleteModel':
     case 'models.del':
+    case 'models.delete':
     case 'cancelFineTune':
     case 'fine_tuning.jobs.cancel':
     case 'fine-tune.cancel':

package/packages/datadog-plugin-oracledb/src/index.js

@@ -11,7 +11,8 @@ class OracledbPlugin extends DatabasePlugin {
 
   start ({ query, connAttrs }) {
     const service = this.serviceName({ pluginConfig: this.config, params: connAttrs })
-    const url = getUrl(connAttrs.connectString)
+    // Users can pass either connectString or connectionString
+    const url = getUrl(connAttrs.connectString || connAttrs.connectionString)
 
     this.startSpan(this.operationName(), {
       service,

package/packages/datadog-plugin-pino/src/index.js

@@ -1,8 +1,8 @@
 'use strict'
 
-const LogPlugin = require('../../dd-trace/src/plugins/log_plugin')
+const StructuredLogPlugin = require('../../dd-trace/src/plugins/structured_log_plugin')
 
-class PinoPlugin extends LogPlugin {
+class PinoPlugin extends StructuredLogPlugin {
   static get id () {
     return 'pino'
   }

package/packages/datadog-plugin-prisma/src/client.js

@@ -0,0 +1,62 @@
+'use strict'
+const DatabasePlugin = require('../../dd-trace/src/plugins/database')
+class PrismaClientPlugin extends DatabasePlugin {
+  static get id () { return 'prisma' }
+  static get operation () { return 'client' }
+  static get system () { return 'prisma' }
+  static get prefix () {
+    return 'tracing:apm:prisma:client'
+  }
+
+  bindStart (ctx) {
+    const service = this.serviceName({ pluginConfig: this.config })
+    const resource = formatResourceName(ctx.resourceName, ctx.attributes)
+
+    const options = { service, resource }
+
+    if (ctx.resourceName === 'operation') {
+      options.meta = {
+        prisma: {
+          method: ctx.attributes.method,
+          model: ctx.attributes.model,
+          type: 'client'
+        }
+      }
+    }
+    const operationName = this.operationName({ operation: this.operation })
+    this.startSpan(operationName, options, ctx)
+
+    return ctx.currentStore
+  }
+
+  end (ctx) {
+    // Only synchronous operations would have `result` on `end`.
+    if (Object.hasOwn(ctx, 'result')) {
+      this.finish(ctx)
+    }
+  }
+
+  bindAsyncStart (ctx) {
+    return this.bindFinish(ctx)
+  }
+
+  asyncStart (ctx) {
+    this.finish(ctx)
+  }
+
+  error (error) {
+    this.addError(error)
+  }
+}
+
+function formatResourceName (resource, attributes) {
+  if (attributes?.name) {
+    return `${attributes.name}`.trim()
+  }
+  if (attributes?.model && attributes.method) {
+    return `${attributes.model}.${attributes.method}`.trim()
+  }
+  return resource
+}
+
+module.exports = PrismaClientPlugin

package/packages/datadog-plugin-prisma/src/engine.js

@@ -0,0 +1,81 @@
+'use strict'
+
+const DatabasePlugin = require('../../dd-trace/src/plugins/database')
+const { CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
+
+const databaseDriverMapper = {
+  postgresql: {
+    type: 'sql',
+    'db.type': 'postgres'
+  },
+  mysql: {
+    type: 'sql',
+    'db.type': 'mysql'
+  },
+  mongodb: {
+    type: 'mongodb',
+    'db.type': 'mongodb'
+  },
+  sqlite: {
+    type: 'sql',
+    'db.type': 'sqlite'
+  }
+}
+
+class PrismaEngine extends DatabasePlugin {
+  static get id () { return 'prisma' }
+  static get operation () { return 'engine' }
+  static get system () { return 'prisma' }
+
+  start (ctx) {
+    const { engineSpan, allEngineSpans, childOf, dbConfig } = ctx
+    const service = this.serviceName({ pluginConfig: this.config, system: this.system })
+    const spanName = engineSpan.name.slice(14) // remove 'prisma:engine:' prefix
+    const options = {
+      childOf,
+      resource: spanName,
+      service,
+      kind: engineSpan.kind,
+      meta: {
+        prisma: {
+          name: spanName,
+          type: 'engine'
+        }
+      }
+    }
+
+    if (spanName === 'db_query') {
+      const query = engineSpan.attributes['db.query.text']
+      const originalStatement = this.maybeTruncate(query)
+      const type = databaseDriverMapper[engineSpan.attributes['db.system']]?.type
+      const dbType = databaseDriverMapper[engineSpan.attributes['db.system']]?.['db.type']
+
+      options.resource = originalStatement
+      options.type = type || engineSpan.attributes['db.system']
+      options.meta['db.type'] = dbType || engineSpan.attributes['db.system']
+      options.meta['db.instance'] = dbConfig?.database
+      options.meta['db.name'] = dbConfig?.user
+      options.meta['out.host'] = dbConfig?.host
+      options.meta[CLIENT_PORT_KEY] = dbConfig?.port
+    }
+
+    const activeSpan = this.startSpan(this.operationName({ operation: this.operation }), options)
+    activeSpan._startTime = hrTimeToUnixTimeMs(engineSpan.startTime)
+    for (const span of allEngineSpans) {
+      if (span.parentId === engineSpan.id) {
+        const startCtx = { engineSpan: span, allEngineSpans, childOf: activeSpan, dbConfig }
+        this.start(startCtx)
+      }
+    }
+    const unixEndTime = hrTimeToUnixTimeMs(engineSpan.endTime)
+    activeSpan.finish(unixEndTime)
+  }
+}
+
+// Opentelemetry time format is defined here
+// https://github.com/open-telemetry/opentelemetry-js/blob/cbc912d/api/src/common/Time.ts#L19-L30.
+function hrTimeToUnixTimeMs ([seconds, nanoseconds]) {
+  return seconds * 1000 + nanoseconds / 1e6
+}
+
+module.exports = PrismaEngine

package/packages/datadog-plugin-prisma/src/index.js

@@ -0,0 +1,22 @@
+'use strict'
+
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+
+const PrismaClientPlugin = require('./client')
+const PrismaEnginePlugin = require('./engine')
+
+class PrismaPlugin extends CompositePlugin {
+  static get id () { return 'prisma' }
+  static get plugins () {
+    return {
+      client: PrismaClientPlugin,
+      engine: PrismaEnginePlugin
+    }
+  }
+
+  configure (config) {
+    return super.configure(config)
+  }
+}
+
+module.exports = PrismaPlugin

package/packages/datadog-plugin-protobufjs/src/schema_iterator.js

@@ -108,7 +108,7 @@ class SchemaExtractor {
     }
     for (const field of schema.fieldsArray) {
       if (!this.extractProperty(field, schemaName, field.name, builder, depth)) {
-        log.warn(`DSM: Unable to extract field with name: ${field.name} from Avro schema with name: ${schemaName}`)
+        log.warn('DSM: Unable to extract field with name: %s from Avro schema with name:', field.name, schemaName)
       }
     }
     return true

package/packages/datadog-plugin-redis/src/index.js

@@ -13,10 +13,14 @@ class RedisPlugin extends CachePlugin {
     this._spanType = 'redis'
   }
 
-  start ({ db, command, args, connectionOptions = {}, connectionName }) {
+  bindStart (ctx) {
+    const { db, command, args, connectionOptions, connectionName } = ctx
+
     const resource = command
     const normalizedCommand = command.toUpperCase()
-    if (!this.config.filter(normalizedCommand)) return this.skip()
+    if (!this.config.filter(normalizedCommand)) {
+      return { noop: true }
+    }
 
     this.startSpan({
       resource,
@@ -29,7 +33,9 @@ class RedisPlugin extends CachePlugin {
         'out.host': connectionOptions.host,
         [CLIENT_PORT_KEY]: connectionOptions.port
       }
-    })
+    }, ctx)
+
+    return ctx.currentStore
   }
 
   configure (config) {

package/packages/datadog-plugin-router/src/index.js

@@ -106,6 +106,7 @@ class RouterPlugin extends WebPlugin {
 
     const span = this.tracer.startSpan(`${this.constructor.id}.middleware`, {
       childOf,
+      integrationName: this.constructor.id,
       tags: {
         [COMPONENT]: this.constructor.id,
         'resource.name': name || '<anonymous>'