dd-trace 5.70.0 → 5.72.0

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

@@ -9,7 +9,8 @@ const tagger = require('./tagger')
 const set = require('../../datadog-core/src/utils/src/set')
 const { isTrue, isFalse, normalizeProfilingEnabledValue } = require('./util')
 const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('./plugins/util/tags')
-const { getGitMetadataFromGitProperties, removeUserSensitiveInfo } = require('./git_properties')
+const { getGitMetadataFromGitProperties, removeUserSensitiveInfo, getRemoteOriginURL, resolveGitHeadSHA } =
+  require('./git_properties')
 const { updateConfig } = require('./telemetry')
 const telemetryMetrics = require('./telemetry/metrics')
 const { isInServerlessEnvironment, getIsGCPFunction, getIsAzureFunction } = require('./serverless')
@@ -17,6 +18,7 @@ const { ORIGIN_KEY } = require('./constants')
 const { appendRules } = require('./payload-tagging/config')
 const { getEnvironmentVariable, getEnvironmentVariables } = require('./config-helper')
 const defaults = require('./config_defaults')
+const path = require('path')
 
 const tracerMetrics = telemetryMetrics.manager.namespace('tracers')
 
@@ -67,6 +69,8 @@ const VALID_PROPAGATION_BEHAVIOR_EXTRACT = new Set(['continue', 'restart', 'igno
 
 const VALID_LOG_LEVELS = new Set(['debug', 'info', 'warn', 'error'])
 
+const DEFAULT_OTLP_PORT = 4318
+
 function getFromOtelSamplerMap (otelTracesSampler, otelTracesSamplerArg) {
   const OTEL_TRACES_SAMPLER_MAPPING = {
     always_on: '1.0',
@@ -380,30 +384,7 @@ class Config {
     }
 
     if (this.gitMetadataEnabled) {
-      this.repositoryUrl = removeUserSensitiveInfo(
-        getEnvironmentVariable('DD_GIT_REPOSITORY_URL') ??
-        this.tags[GIT_REPOSITORY_URL]
-      )
-      this.commitSHA = getEnvironmentVariable('DD_GIT_COMMIT_SHA') ??
-        this.tags[GIT_COMMIT_SHA]
-      if (!this.repositoryUrl || !this.commitSHA) {
-        const DD_GIT_PROPERTIES_FILE = getEnvironmentVariable('DD_GIT_PROPERTIES_FILE') ??
-          `${process.cwd()}/git.properties`
-        let gitPropertiesString
-        try {
-          gitPropertiesString = fs.readFileSync(DD_GIT_PROPERTIES_FILE, 'utf8')
-        } catch (e) {
-          // Only log error if the user has set a git.properties path
-          if (getEnvironmentVariable('DD_GIT_PROPERTIES_FILE')) {
-            log.error('Error reading DD_GIT_PROPERTIES_FILE: %s', DD_GIT_PROPERTIES_FILE, e)
-          }
-        }
-        if (gitPropertiesString) {
-          const { commitSHA, repositoryUrl } = getGitMetadataFromGitProperties(gitPropertiesString)
-          this.commitSHA = this.commitSHA || commitSHA
-          this.repositoryUrl = this.repositoryUrl || repositoryUrl
-        }
-      }
+      this._loadGitMetadata()
     }
   }
 
@@ -554,6 +535,7 @@ class Config {
       DD_INSTRUMENTATION_TELEMETRY_ENABLED,
       DD_INSTRUMENTATION_CONFIG_ID,
       DD_LOGS_INJECTION,
+      DD_LOGS_OTEL_ENABLED,
       DD_LANGCHAIN_SPAN_CHAR_LIMIT,
       DD_LANGCHAIN_SPAN_PROMPT_COMPLETION_SAMPLE_RATE,
       DD_LLMOBS_AGENTLESS_ENABLED,
@@ -635,7 +617,18 @@ class Config {
       OTEL_RESOURCE_ATTRIBUTES,
       OTEL_SERVICE_NAME,
       OTEL_TRACES_SAMPLER,
-      OTEL_TRACES_SAMPLER_ARG
+      OTEL_TRACES_SAMPLER_ARG,
+      DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED,
+      OTEL_EXPORTER_OTLP_LOGS_ENDPOINT,
+      OTEL_EXPORTER_OTLP_LOGS_HEADERS,
+      OTEL_EXPORTER_OTLP_LOGS_PROTOCOL,
+      OTEL_EXPORTER_OTLP_LOGS_TIMEOUT,
+      OTEL_EXPORTER_OTLP_PROTOCOL,
+      OTEL_EXPORTER_OTLP_ENDPOINT,
+      OTEL_EXPORTER_OTLP_HEADERS,
+      OTEL_EXPORTER_OTLP_TIMEOUT,
+      OTEL_BSP_SCHEDULE_DELAY,
+      OTEL_BSP_MAX_EXPORT_BATCH_SIZE
     } = getEnvironmentVariables()
 
     const tags = {}
@@ -649,6 +642,23 @@ class Config {
     tagger.add(tags, DD_TRACE_TAGS)
     tagger.add(tags, DD_TRACE_GLOBAL_TAGS)
 
+    this._setBoolean(env, 'otelLogsEnabled', isTrue(DD_LOGS_OTEL_ENABLED))
+    // Set OpenTelemetry logs configuration with specific _LOGS_ vars taking precedence over generic _EXPORTERS_ vars
+    if (OTEL_EXPORTER_OTLP_ENDPOINT) {
+      // Only set if there's a custom URL, otherwise let calc phase handle the default
+      this._setString(env, 'otelUrl', OTEL_EXPORTER_OTLP_ENDPOINT)
+    }
+    if (OTEL_EXPORTER_OTLP_ENDPOINT || OTEL_EXPORTER_OTLP_LOGS_ENDPOINT) {
+      this._setString(env, 'otelLogsUrl', OTEL_EXPORTER_OTLP_LOGS_ENDPOINT || env.otelUrl)
+    }
+    this._setString(env, 'otelHeaders', OTEL_EXPORTER_OTLP_HEADERS)
+    this._setString(env, 'otelLogsHeaders', OTEL_EXPORTER_OTLP_LOGS_HEADERS || env.otelHeaders)
+    this._setString(env, 'otelProtocol', OTEL_EXPORTER_OTLP_PROTOCOL)
+    this._setString(env, 'otelLogsProtocol', OTEL_EXPORTER_OTLP_LOGS_PROTOCOL || env.otelProtocol)
+    env.otelTimeout = maybeInt(OTEL_EXPORTER_OTLP_TIMEOUT)
+    env.otelLogsTimeout = maybeInt(OTEL_EXPORTER_OTLP_LOGS_TIMEOUT) || env.otelTimeout
+    env.otelLogsBatchTimeout = maybeInt(OTEL_BSP_SCHEDULE_DELAY)
+    env.otelLogsMaxExportBatchSize = maybeInt(OTEL_BSP_MAX_EXPORT_BATCH_SIZE)
     this._setBoolean(
       env,
       'apmTracingEnabled',
@@ -668,6 +678,7 @@ class Config {
     this._envUnprocessed['appsec.blockedTemplateJson'] = DD_APPSEC_HTTP_BLOCKED_TEMPLATE_JSON
     this._setBoolean(env, 'appsec.enabled', DD_APPSEC_ENABLED)
     this._setString(env, 'appsec.eventTracking.mode', DD_APPSEC_AUTO_USER_INSTRUMENTATION_MODE)
+    // TODO appsec.extendedHeadersCollection are deprecated, to delete in a major
     this._setBoolean(env, 'appsec.extendedHeadersCollection.enabled', DD_APPSEC_COLLECT_ALL_HEADERS)
     this._setBoolean(
       env,
@@ -679,6 +690,7 @@ class Config {
     this._setString(env, 'appsec.obfuscatorKeyRegex', DD_APPSEC_OBFUSCATION_PARAMETER_KEY_REGEXP)
     this._setString(env, 'appsec.obfuscatorValueRegex', DD_APPSEC_OBFUSCATION_PARAMETER_VALUE_REGEXP)
     this._setBoolean(env, 'appsec.rasp.enabled', DD_APPSEC_RASP_ENABLED)
+    // TODO Deprecated, to delete in a major
     this._setBoolean(env, 'appsec.rasp.bodyCollection', DD_APPSEC_RASP_COLLECT_REQUEST_BODY)
     env['appsec.rateLimit'] = maybeInt(DD_APPSEC_TRACE_RATE_LIMIT)
     this._envUnprocessed['appsec.rateLimit'] = DD_APPSEC_TRACE_RATE_LIMIT
@@ -719,6 +731,7 @@ class Config {
     env['dynamicInstrumentation.uploadIntervalSeconds'] = maybeFloat(DD_DYNAMIC_INSTRUMENTATION_UPLOAD_INTERVAL_SECONDS)
     this._envUnprocessed['dynamicInstrumentation.uploadInterval'] = DD_DYNAMIC_INSTRUMENTATION_UPLOAD_INTERVAL_SECONDS
     this._setString(env, 'env', DD_ENV || tags.env)
+    this._setBoolean(env, 'experimental.flaggingProvider.enabled', DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED)
     this._setBoolean(env, 'traceEnabled', DD_TRACE_ENABLED)
     this._setBoolean(env, 'experimental.aiguard.enabled', DD_AI_GUARD_ENABLED)
     this._setString(env, 'experimental.aiguard.endpoint', DD_AI_GUARD_ENDPOINT)
@@ -968,6 +981,7 @@ class Config {
     this._optsUnprocessed['experimental.aiguard.timeout'] = options.experimental?.aiguard?.timeout
     this._setBoolean(opts, 'experimental.enableGetRumData', options.experimental?.enableGetRumData)
     this._setString(opts, 'experimental.exporter', options.experimental?.exporter)
+    this._setBoolean(opts, 'experimental.flaggingProvider.enabled', options.experimental?.flaggingProvider?.enabled)
     opts.flushInterval = maybeInt(options.flushInterval)
     this._optsUnprocessed.flushInterval = options.flushInterval
     opts.flushMinSpans = maybeInt(options.flushMinSpans)
@@ -1154,7 +1168,20 @@ class Config {
       calc.testManagementAttemptToFixRetries = maybeInt(DD_TEST_MANAGEMENT_ATTEMPT_TO_FIX_RETRIES) ?? 20
       this._setBoolean(calc, 'isImpactedTestsEnabled', !isFalse(DD_CIVISIBILITY_IMPACTED_TESTS_DETECTION_ENABLED))
     }
+
+    // Disable log injection when OTEL logs are enabled
+    // OTEL logs and DD log injection are mutually exclusive
+    if (this._env.otelLogsEnabled) {
+      this._setBoolean(calc, 'logInjection', false)
+    }
+
     calc['dogstatsd.hostname'] = this._getHostname()
+
+    // Compute OTLP logs URL to send payloads to the active Datadog Agent
+    const agentHostname = this._getHostname()
+    calc.otelLogsUrl = `http://${agentHostname}:${DEFAULT_OTLP_PORT}`
+    calc.otelUrl = `http://${agentHostname}:${DEFAULT_OTLP_PORT}`
+
     this._setBoolean(calc, 'isGitUploadEnabled',
       calc.isIntelligentTestRunnerEnabled && !isFalse(this._isCiVisibilityGitUploadEnabled()))
     this._setBoolean(calc, 'spanComputePeerService', this._getSpanComputePeerService())
@@ -1364,6 +1391,63 @@ class Config {
       }
     }
   }
+
+  _loadGitMetadata () {
+    // try to read Git metadata from the environment variables
+    this.repositoryUrl = removeUserSensitiveInfo(
+      getEnvironmentVariable('DD_GIT_REPOSITORY_URL') ??
+      this.tags[GIT_REPOSITORY_URL]
+    )
+    this.commitSHA = getEnvironmentVariable('DD_GIT_COMMIT_SHA') ??
+      this.tags[GIT_COMMIT_SHA]
+
+    // otherwise, try to read Git metadata from the git.properties file
+    if (!this.repositoryUrl || !this.commitSHA) {
+      const DD_GIT_PROPERTIES_FILE = getEnvironmentVariable('DD_GIT_PROPERTIES_FILE') ??
+        `${process.cwd()}/git.properties`
+      let gitPropertiesString
+      try {
+        gitPropertiesString = fs.readFileSync(DD_GIT_PROPERTIES_FILE, 'utf8')
+      } catch (e) {
+        // Only log error if the user has set a git.properties path
+        if (getEnvironmentVariable('DD_GIT_PROPERTIES_FILE')) {
+          log.error('Error reading DD_GIT_PROPERTIES_FILE: %s', DD_GIT_PROPERTIES_FILE, e)
+        }
+      }
+      if (gitPropertiesString) {
+        const { commitSHA, repositoryUrl } = getGitMetadataFromGitProperties(gitPropertiesString)
+        this.commitSHA = this.commitSHA || commitSHA
+        this.repositoryUrl = this.repositoryUrl || repositoryUrl
+      }
+    }
+    // otherwise, try to read Git metadata from the .git/ folder
+    if (!this.repositoryUrl || !this.commitSHA) {
+      const DD_GIT_FOLDER_PATH = getEnvironmentVariable('DD_GIT_FOLDER_PATH') ??
+        path.join(process.cwd(), '.git')
+      if (!this.repositoryUrl) {
+        // try to read git config (repository URL)
+        const gitConfigPath = path.join(DD_GIT_FOLDER_PATH, 'config')
+        try {
+          const gitConfigContent = fs.readFileSync(gitConfigPath, 'utf8')
+          if (gitConfigContent) {
+            this.repositoryUrl = getRemoteOriginURL(gitConfigContent)
+          }
+        } catch (e) {
+          // Only log error if the user has set a .git/ path
+          if (getEnvironmentVariable('DD_GIT_FOLDER_PATH')) {
+            log.error('Error reading git config: %s', gitConfigPath, e)
+          }
+        }
+      }
+      if (!this.commitSHA) {
+        // try to read git HEAD (commit SHA)
+        const gitHeadSha = resolveGitHeadSHA(DD_GIT_FOLDER_PATH)
+        if (gitHeadSha) {
+          this.commitSHA = gitHeadSha
+        }
+      }
+    }
+  }
 }
 
 function handleOtel (tagString) {

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

@@ -36,12 +36,14 @@ module.exports = {
   'appsec.blockedTemplateJson': undefined,
   'appsec.enabled': undefined,
   'appsec.eventTracking.mode': 'identification',
+  // TODO appsec.extendedHeadersCollection is deprecated, to delete in a major
   'appsec.extendedHeadersCollection.enabled': false,
   'appsec.extendedHeadersCollection.redaction': true,
   'appsec.extendedHeadersCollection.maxHeaders': 50,
   'appsec.obfuscatorKeyRegex': defaultWafObfuscatorKeyRegex,
   'appsec.obfuscatorValueRegex': defaultWafObfuscatorValueRegex,
   'appsec.rasp.enabled': true,
+  // TODO Deprecated, to delete in a major
   'appsec.rasp.bodyCollection': false,
   'appsec.rateLimit': 100,
   'appsec.rules': undefined,
@@ -75,6 +77,7 @@ module.exports = {
   'experimental.aiguard.timeout': 10_000, // ms
   'experimental.enableGetRumData': false,
   'experimental.exporter': undefined,
+  'experimental.flaggingProvider.enabled': false,
   flushInterval: 2000,
   flushMinSpans: 1000,
   gitMetadataEnabled: true,
@@ -124,6 +127,17 @@ module.exports = {
   isTestManagementEnabled: false,
   isImpactedTestsEnabled: false,
   logInjection: true,
+  otelLogsEnabled: false,
+  otelUrl: undefined,
+  otelLogsUrl: undefined, // Will be computed using agent host
+  otelHeaders: undefined,
+  otelLogsHeaders: '',
+  otelProtocol: 'http/protobuf',
+  otelLogsProtocol: 'http/protobuf',
+  otelLogsTimeout: 10_000,
+  otelTimeout: 10_000,
+  otelLogsBatchTimeout: 5000,
+  otelLogsMaxExportBatchSize: 512,
   lookup: undefined,
   inferredProxyServicesEnabled: false,
   memcachedCommandEnabled: false,

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

@@ -1,7 +1,14 @@
 'use strict'
 
-const commitSHARegex = /git\.commit\.sha=([a-f\d]{40})/
-const repositoryUrlRegex = /git\.repository_url=([\w\d:@/.-]+)/
+const fs = require('fs')
+const path = require('path')
+
+const gitPropertiesCommitSHARegex = /git\.commit\.sha=([a-f\d]{40})/
+const gitPropertiesRepositoryUrlRegex = /git\.repository_url=([\w\d:@/.-]+)/
+const repositoryUrlRegex = /^([\w\d:@/.-]+)$/
+const remoteOriginRegex = /^\[remote\s+"origin"\]/i
+const gitHeadRefRegex = /ref:\s+(refs\/[A-Za-z0-9._/-]+)/
+const commitSHARegex = /^[0-9a-f]{40}$/
 
 function removeUserSensitiveInfo (repositoryUrl) {
   try {
@@ -21,8 +28,8 @@ function getGitMetadataFromGitProperties (gitPropertiesString) {
   if (!gitPropertiesString) {
     return {}
   }
-  const commitSHAMatch = gitPropertiesString.match(commitSHARegex)
-  const repositoryUrlMatch = gitPropertiesString.match(repositoryUrlRegex)
+  const commitSHAMatch = gitPropertiesString.match(gitPropertiesCommitSHARegex)
+  const repositoryUrlMatch = gitPropertiesString.match(gitPropertiesRepositoryUrlRegex)
 
   const repositoryUrl = repositoryUrlMatch ? repositoryUrlMatch[1] : undefined
 
@@ -32,4 +39,82 @@ function getGitMetadataFromGitProperties (gitPropertiesString) {
   }
 }
 
-module.exports = { getGitMetadataFromGitProperties, removeUserSensitiveInfo }
+function getRemoteOriginURL (gitConfigContent) {
+  if (!gitConfigContent) {
+    return
+  }
+  const lines = gitConfigContent.split('\n')
+  let index = 0
+
+  // find the remote origin section
+  for (; index < lines.length; index++) {
+    const line = lines[index]
+    if (line[0] !== '[') continue // fast path
+    if (remoteOriginRegex.test(line)) break
+  }
+
+  // find the url key/value in the [remote "origin"] section
+  index++
+  for (; index < lines.length; index++) {
+    const line = lines[index]
+    if (line[0] === '[') return // abort, section didn't contain a url
+    const splitAt = line.indexOf('=')
+    if (splitAt === -1) continue
+    const key = line.slice(0, splitAt).trim().toLowerCase()
+    if (key !== 'url') continue
+    const repositoryUrlValue = line.slice(splitAt + 1).trim()
+    const repositoryUrlMatch = repositoryUrlValue.match(repositoryUrlRegex)
+    if (!repositoryUrlMatch) continue
+    return removeUserSensitiveInfo(repositoryUrlMatch[0])
+  }
+}
+
+function getGitHeadRef (gitHeadContent) {
+  if (!gitHeadContent) {
+    return
+  }
+
+  // Extract the ref after 'ref: '
+  const gitRefMatch = gitHeadContent.match(gitHeadRefRegex)
+  return gitRefMatch?.[1]
+}
+
+function resolveGitHeadSHA (DD_GIT_FOLDER_PATH) {
+  const gitHeadPath = path.join(DD_GIT_FOLDER_PATH, 'HEAD')
+
+  try {
+    const gitHeadContent = fs.readFileSync(gitHeadPath, 'utf8')
+    if (!gitHeadContent) {
+      return
+    }
+
+    const headContent = gitHeadContent.trim()
+
+    // Handle detached head case
+    if (commitSHARegex.test(headContent)) {
+      return headContent
+    }
+
+    // Handle ref case - extract the ref and read the SHA from the ref file
+    const gitHeadRef = getGitHeadRef(headContent)
+    if (!gitHeadRef) {
+      return
+    }
+    const gitHeadRefPath = path.join(DD_GIT_FOLDER_PATH, gitHeadRef)
+    const gitHeadRefContent = fs.readFileSync(gitHeadRefPath, 'utf8')
+    if (gitHeadRefContent) {
+      const headRefContent = gitHeadRefContent.trim()
+      if (commitSHARegex.test(headRefContent)) {
+        return headRefContent
+      }
+    }
+  } catch {}
+}
+
+module.exports = {
+  getGitMetadataFromGitProperties,
+  removeUserSensitiveInfo,
+  getGitHeadRef,
+  getRemoteOriginURL,
+  resolveGitHeadSHA,
+}

package/packages/dd-trace/src/llmobs/plugins/anthropic.js

@@ -0,0 +1,282 @@
+'use strict'
+
+const LLMObsPlugin = require('./base')
+
+const ALLOWED_METADATA_KEYS = new Set([
+  'max_tokens',
+  'stop_sequences',
+  'temperature',
+  'top_k',
+  'top_p',
+])
+
+class AnthropicLLMObsPlugin extends LLMObsPlugin {
+  static integration = 'anthropic' // used for llmobs telemetry
+  static id = 'anthropic'
+  static prefix = 'tracing:apm:anthropic:request'
+
+  constructor () {
+    super(...arguments)
+
+    this.addSub('apm:anthropic:request:chunk', ({ ctx, chunk, done }) => {
+      ctx.chunks ??= []
+      const chunks = ctx.chunks
+      if (chunk) chunks.push(chunk)
+
+      if (!done) return
+
+      const response = { content: [] }
+
+      for (const chunk of chunks) {
+        switch (chunk.type) {
+          case 'message_start': {
+            const { message } = chunk
+            if (!message) continue
+
+            const { role, usage } = message
+            if (role) response.role = role
+            if (usage) response.usage = usage
+            break
+          }
+          case 'content_block_start': {
+            const contentBlock = chunk.content_block
+            if (!contentBlock) continue
+
+            const { type } = contentBlock
+            if (type === 'text') {
+              response.content.push({ type, text: contentBlock.text })
+            } else if (type === 'tool_use') {
+              response.content.push({ type, name: contentBlock.name, input: '', id: contentBlock.id })
+            }
+            break
+          }
+          case 'content_block_delta': {
+            const { delta } = chunk
+            if (!delta) continue
+
+            const { text } = delta
+            if (text) response.content[response.content.length - 1].text += text
+
+            const partialJson = delta.partial_json
+            if (partialJson && delta.type === 'input_json_delta') {
+              response.content[response.content.length - 1].input += partialJson
+            }
+            break
+          }
+          case 'content_block_stop': {
+            const type = response.content[response.content.length - 1].type
+            if (type === 'tool_use') {
+              const input = response.content[response.content.length - 1].input ?? '{}'
+              response.content[response.content.length - 1].input = JSON.parse(input)
+            }
+            break
+          }
+          case 'message_delta': {
+            const { delta } = chunk
+
+            const finishReason = delta?.stop_reason
+            if (finishReason) response.finish_reason = finishReason
+
+            const { usage } = chunk
+            if (usage) {
+              const responseUsage = response.usage ?? (response.usage = { input_tokens: 0, output_tokens: 0 })
+              responseUsage.output_tokens = usage.output_tokens
+
+              const cacheCreationTokens = usage.cache_creation_input_tokens
+              const cacheReadTokens = usage.cache_read_input_tokens
+              if (cacheCreationTokens) responseUsage.cache_creation_input_tokens = cacheCreationTokens
+              if (cacheReadTokens) responseUsage.cache_read_input_tokens = cacheReadTokens
+            }
+
+            break
+          }
+          case 'error': {
+            const { error } = chunk
+            if (!error) continue
+
+            response.error = {}
+            if (error.type) response.error.type = error.type
+            if (error.message) response.error.message = error.message
+
+            break
+          }
+        }
+
+        ctx.result = response
+      }
+    })
+  }
+
+  getLLMObsSpanRegisterOptions (ctx) {
+    const { options } = ctx
+    const { model } = options
+
+    return {
+      kind: 'llm',
+      modelName: model,
+      modelProvider: 'anthropic'
+    }
+  }
+
+  setLLMObsTags (ctx) {
+    const span = ctx.currentStore?.span
+    if (!span) return
+
+    const { options, result } = ctx
+
+    this.#tagAnthropicInputMessages(span, options)
+    this.#tagAnthropicOutputMessages(span, result)
+    this.#tagAnthropicMetadata(span, options)
+    this.#tagAnthropicUsage(span, result)
+  }
+
+  #tagAnthropicInputMessages (span, options) {
+    const { system, messages } = options
+    const inputMessages = []
+
+    if (system) {
+      messages.unshift({ content: system, role: 'system' })
+    }
+
+    for (const message of messages) {
+      const { content, role } = message
+
+      if (typeof content === 'string') {
+        inputMessages.push({ content, role })
+        continue
+      }
+
+      for (const block of content) {
+        if (block.type === 'text') {
+          inputMessages.push({ content: block.text, role })
+        } else if (block.type === 'image') {
+          inputMessages.push({ content: '([IMAGE DETECTED])', role })
+        } else if (block.type === 'tool_use') {
+          const { text, name, id, type } = block
+          let input = block.input
+          if (typeof input === 'string') {
+            input = JSON.parse(input)
+          }
+
+          const toolCall = {
+            name,
+            arguments: input,
+            toolId: id,
+            type
+          }
+
+          inputMessages.push({ content: text ?? '', role, toolCalls: [toolCall] })
+        } else if (block.type === 'tool_result') {
+          const { content } = block
+          const formattedContent = this.#formatAnthropicToolResultContent(content)
+          const toolResult = {
+            result: formattedContent,
+            toolId: block.tool_use_id,
+            type: 'tool_result'
+          }
+
+          inputMessages.push({ content: '', role, toolResults: [toolResult] })
+        } else {
+          inputMessages.push({ content: JSON.stringify(block), role })
+        }
+      }
+    }
+
+    this._tagger.tagLLMIO(span, inputMessages)
+  }
+
+  #tagAnthropicOutputMessages (span, result) {
+    if (!result) return
+
+    const { content, role } = result
+
+    if (typeof content === 'string') {
+      this._tagger.tagLLMIO(span, null, [{ content, role }])
+      return
+    }
+
+    const outputMessages = []
+    for (const block of content) {
+      const { text } = block
+      if (typeof text === 'string') {
+        outputMessages.push({ content: text, role })
+      } else if (block.type === 'tool_use') {
+        let input = block.input
+        if (typeof input === 'string') {
+          input = JSON.parse(input)
+        }
+
+        const toolCall = {
+          name: block.name,
+          arguments: input,
+          toolId: block.id,
+          type: block.type
+        }
+
+        outputMessages.push({ content: text ?? '', role, toolCalls: [toolCall] })
+      }
+    }
+
+    this._tagger.tagLLMIO(span, null, outputMessages)
+  }
+
+  #tagAnthropicMetadata (span, options) {
+    const metadata = {}
+    for (const [key, value] of Object.entries(options)) {
+      if (ALLOWED_METADATA_KEYS.has(key)) {
+        metadata[key] = value
+      }
+    }
+
+    this._tagger.tagMetadata(span, metadata)
+  }
+
+  #tagAnthropicUsage (span, result) {
+    if (!result) return
+
+    const { usage } = result
+    if (!usage) return
+
+    const inputTokens = usage.input_tokens
+    const outputTokens = usage.output_tokens
+    const cacheWriteTokens = usage.cache_creation_input_tokens
+    const cacheReadTokens = usage.cache_read_input_tokens
+
+    const metrics = {}
+
+    metrics.inputTokens =
+      (inputTokens ?? 0) +
+      (cacheWriteTokens ?? 0) +
+      (cacheReadTokens ?? 0)
+
+    if (outputTokens) metrics.outputTokens = outputTokens
+    const totalTokens = metrics.inputTokens + (outputTokens ?? 0)
+    if (totalTokens) metrics.totalTokens = totalTokens
+
+    if (cacheWriteTokens != null) metrics.cacheWriteTokens = cacheWriteTokens
+    if (cacheReadTokens != null) metrics.cacheReadTokens = cacheReadTokens
+
+    this._tagger.tagMetrics(span, metrics)
+  }
+
+  // maybe can make into a util file
+  #formatAnthropicToolResultContent (content) {
+    if (typeof content === 'string') {
+      return content
+    } else if (Array.isArray(content)) {
+      const formattedContent = []
+      for (const toolResultBlock of content) {
+        if (toolResultBlock.text) {
+          formattedContent.push(toolResultBlock.text)
+        } else if (toolResultBlock.type === 'image') {
+          formattedContent.push('([IMAGE DETECTED])')
+        }
+      }
+
+      return formattedContent.join(',')
+    }
+    return JSON.stringify(content)
+  }
+}
+
+module.exports = AnthropicLLMObsPlugin