dd-trace 5.26.0 → 5.27.1

package/index.d.ts

@@ -179,6 +179,7 @@ interface Plugins {
   "kafkajs": tracer.plugins.kafkajs
   "knex": tracer.plugins.knex;
   "koa": tracer.plugins.koa;
+  "langchain": tracer.plugins.langchain;
   "mariadb": tracer.plugins.mariadb;
   "memcached": tracer.plugins.memcached;
   "microgateway-core": tracer.plugins.microgateway_core;
@@ -1592,6 +1593,12 @@ declare namespace tracer {
      */
     interface kafkajs extends Instrumentation {}
 
+    /**
+     * This plugin automatically instruments the
+     * [langchain](https://js.langchain.com/) module
+     */
+    interface langchain extends Instrumentation {}
+
     /**
      * This plugin automatically instruments the
      * [ldapjs](https://github.com/ldapjs/node-ldapjs/) module.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.26.0",
+  "version": "5.27.1",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",

package/packages/datadog-instrumentations/src/helpers/hooks.js

@@ -19,6 +19,8 @@ module.exports = {
   '@jest/test-sequencer': () => require('../jest'),
   '@jest/transform': () => require('../jest'),
   '@koa/router': () => require('../koa'),
+  '@langchain/core': () => require('../langchain'),
+  '@langchain/openai': () => require('../langchain'),
   '@node-redis/client': () => require('../redis'),
   '@opensearch-project/opensearch': () => require('../opensearch'),
   '@opentelemetry/sdk-trace-node': () => require('../otel-sdk-trace'),
@@ -67,6 +69,7 @@ module.exports = {
   koa: () => require('../koa'),
   'koa-router': () => require('../koa'),
   kafkajs: () => require('../kafkajs'),
+  langchain: () => require('../langchain'),
   ldapjs: () => require('../ldapjs'),
   'limitd-client': () => require('../limitd-client'),
   lodash: () => require('../lodash'),

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

@@ -0,0 +1,77 @@
+'use strict'
+
+const { addHook } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const tracingChannel = require('dc-polyfill').tracingChannel
+
+const invokeTracingChannel = tracingChannel('apm:langchain:invoke')
+
+function wrapLangChainPromise (fn, type, namespace = []) {
+  return function () {
+    if (!invokeTracingChannel.start.hasSubscribers) {
+      return fn.apply(this, arguments)
+    }
+
+    // Runnable interfaces have an `lc_namespace` property
+    const ns = this.lc_namespace || namespace
+    const resource = [...ns, this.constructor.name].join('.')
+
+    const ctx = {
+      args: arguments,
+      instance: this,
+      type,
+      resource
+    }
+
+    return invokeTracingChannel.tracePromise(fn, ctx, this, ...arguments)
+  }
+}
+
+// langchain compiles into ESM and CommonJS, with ESM being the default and landing in the `.js` files
+// however, CommonJS ends up in `cjs` files, and are required under the hood with `.cjs` files
+// we patch each separately and explicitly to match against exports only once, and not rely on file regex matching
+const extensions = ['js', 'cjs']
+
+for (const extension of extensions) {
+  addHook({ name: '@langchain/core', file: `dist/runnables/base.${extension}`, versions: ['>=0.1'] }, exports => {
+    const RunnableSequence = exports.RunnableSequence
+    shimmer.wrap(RunnableSequence.prototype, 'invoke', invoke => wrapLangChainPromise(invoke, 'chain'))
+    shimmer.wrap(RunnableSequence.prototype, 'batch', batch => wrapLangChainPromise(batch, 'chain'))
+    return exports
+  })
+
+  addHook({
+    name: '@langchain/core',
+    file: `dist/language_models/chat_models.${extension}`,
+    versions: ['>=0.1']
+  }, exports => {
+    const BaseChatModel = exports.BaseChatModel
+    shimmer.wrap(
+      BaseChatModel.prototype,
+      'generate',
+      generate => wrapLangChainPromise(generate, 'chat_model')
+    )
+    return exports
+  })
+
+  addHook({ name: '@langchain/core', file: `dist/language_models/llms.${extension}`, versions: ['>=0.1'] }, exports => {
+    const BaseLLM = exports.BaseLLM
+    shimmer.wrap(BaseLLM.prototype, 'generate', generate => wrapLangChainPromise(generate, 'llm'))
+    return exports
+  })
+
+  addHook({ name: '@langchain/openai', file: `dist/embeddings.${extension}`, versions: ['>=0.1'] }, exports => {
+    const OpenAIEmbeddings = exports.OpenAIEmbeddings
+
+    // OpenAI (and Embeddings in general) do not define an lc_namespace
+    const namespace = ['langchain', 'embeddings', 'openai']
+    shimmer.wrap(OpenAIEmbeddings.prototype, 'embedDocuments', embedDocuments =>
+      wrapLangChainPromise(embedDocuments, 'embedding', namespace)
+    )
+    shimmer.wrap(OpenAIEmbeddings.prototype, 'embedQuery', embedQuery =>
+      wrapLangChainPromise(embedQuery, 'embedding', namespace)
+    )
+    return exports
+  })
+}

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

@@ -14,8 +14,14 @@ const queryParsedChannel = channel('apm:next:query-parsed')
 const requests = new WeakSet()
 const nodeNextRequestsToNextRequests = new WeakMap()
 
+// Next.js <= 14.2.6
 const MIDDLEWARE_HEADER = 'x-middleware-invoke'
 
+// Next.js >= 14.2.7
+const NEXT_REQUEST_META = Symbol.for('NextInternalRequestMeta')
+const META_IS_MIDDLEWARE = 'middlewareInvoke'
+const encounteredMiddleware = new WeakSet()
+
 function wrapHandleRequest (handleRequest) {
   return function (req, res, pathname, query) {
     return instrument(req, res, () => handleRequest.apply(this, arguments))
@@ -111,6 +117,11 @@ function getPageFromPath (page, dynamicRoutes = []) {
   return getPagePath(page)
 }
 
+function getRequestMeta (req, key) {
+  const meta = req[NEXT_REQUEST_META] || {}
+  return typeof key === 'string' ? meta[key] : meta
+}
+
 function instrument (req, res, error, handler) {
   if (typeof error === 'function') {
     handler = error
@@ -121,8 +132,9 @@ function instrument (req, res, error, handler) {
   res = res.originalResponse || res
 
   // TODO support middleware properly in the future?
-  const isMiddleware = req.headers[MIDDLEWARE_HEADER]
-  if (isMiddleware || requests.has(req)) {
+  const isMiddleware = req.headers[MIDDLEWARE_HEADER] || getRequestMeta(req, META_IS_MIDDLEWARE)
+  if ((isMiddleware && !encounteredMiddleware.has(req)) || requests.has(req)) {
+    encounteredMiddleware.add(req)
     if (error) {
       errorChannel.publish({ error })
     }
@@ -188,7 +200,7 @@ function finish (ctx, result, err) {
 // however, it is not provided as a class function or exported property
 addHook({
   name: 'next',
-  versions: ['>=13.3.0 <14.2.7'],
+  versions: ['>=13.3.0'],
   file: 'dist/server/web/spec-extension/adapters/next-request.js'
 }, NextRequestAdapter => {
   shimmer.wrap(NextRequestAdapter.NextRequestAdapter, 'fromNodeNextRequest', fromNodeNextRequest => {
@@ -203,7 +215,7 @@ addHook({
 
 addHook({
   name: 'next',
-  versions: ['>=11.1 <14.2.7'],
+  versions: ['>=11.1'],
   file: 'dist/server/serve-static.js'
 }, serveStatic => shimmer.wrap(serveStatic, 'serveStatic', wrapServeStatic))
 
@@ -213,7 +225,7 @@ addHook({
   file: 'dist/next-server/server/serve-static.js'
 }, serveStatic => shimmer.wrap(serveStatic, 'serveStatic', wrapServeStatic))
 
-addHook({ name: 'next', versions: ['>=11.1 <14.2.7'], file: 'dist/server/next-server.js' }, nextServer => {
+addHook({ name: 'next', versions: ['>=11.1'], file: 'dist/server/next-server.js' }, nextServer => {
   const Server = nextServer.default
 
   shimmer.wrap(Server.prototype, 'handleRequest', wrapHandleRequest)
@@ -230,7 +242,7 @@ addHook({ name: 'next', versions: ['>=11.1 <14.2.7'], file: 'dist/server/next-se
 })
 
 // `handleApiRequest` changes parameters/implementation at 13.2.0
-addHook({ name: 'next', versions: ['>=13.2 <14.2.7'], file: 'dist/server/next-server.js' }, nextServer => {
+addHook({ name: 'next', versions: ['>=13.2'], file: 'dist/server/next-server.js' }, nextServer => {
   const Server = nextServer.default
   shimmer.wrap(Server.prototype, 'handleApiRequest', wrapHandleApiRequestWithMatch)
   return nextServer
@@ -264,7 +276,7 @@ addHook({
 
 addHook({
   name: 'next',
-  versions: ['>=13 <14.2.7'],
+  versions: ['>=13'],
   file: 'dist/server/web/spec-extension/request.js'
 }, request => {
   const nextUrlDescriptor = Object.getOwnPropertyDescriptor(request.NextRequest.prototype, 'nextUrl')

package/packages/datadog-plugin-amqplib/src/consumer.js

@@ -26,8 +26,7 @@ class AmqplibConsumerPlugin extends ConsumerPlugin {
         'amqp.consumerTag': fields.consumerTag,
         'amqp.source': fields.source,
         'amqp.destination': fields.destination
-      },
-      extractedLinks: childOf?._links
+      }
     })
 
     if (

package/packages/datadog-plugin-aws-sdk/src/services/kinesis.js

@@ -42,8 +42,7 @@ class Kinesis extends BaseAwsSdkPlugin {
               {},
               this.requestTags.get(request) || {},
               { 'span.kind': 'server' }
-            ),
-            extractedLinks: responseExtraction.maybeChildOf._links
+            )
           }
           span = plugin.tracer.startSpan('aws.response', options)
           this.enter(span, store)

package/packages/datadog-plugin-aws-sdk/src/services/sqs.js

@@ -33,8 +33,7 @@ class Sqs extends BaseAwsSdkPlugin {
             {},
             this.requestTags.get(request) || {},
             { 'span.kind': 'server' }
-          ),
-          extractedLinks: contextExtraction.datadogContext._links
+          )
         }
         parsedMessageAttributes = contextExtraction.parsedAttributes
         span = plugin.tracer.startSpan('aws.response', options)

package/packages/datadog-plugin-google-cloud-pubsub/src/consumer.js

@@ -22,8 +22,7 @@ class GoogleCloudPubsubConsumerPlugin extends ConsumerPlugin {
       },
       metrics: {
         'pubsub.ack': 0
-      },
-      extractedLinks: childOf?._links
+      }
     })
     if (this.config.dsmEnabled && message?.attributes) {
       const payloadSize = getMessageSize(message)

package/packages/datadog-plugin-grpc/src/server.js

@@ -48,8 +48,7 @@ class GrpcServerPlugin extends ServerPlugin {
       },
       metrics: {
         'grpc.status.code': 0
-      },
-      extractedLinks: childOf?._links
+      }
     })
 
     addMetadataTags(span, metadata, metadataFilter, 'request')

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

@@ -219,8 +219,7 @@ class JestPlugin extends CiPlugin {
           [COMPONENT]: this.constructor.id,
           ...this.testEnvironmentMetadata,
           ...testSuiteMetadata
-        },
-        extractedLinks: testSessionSpanContext?._links
+        }
       })
       this.telemetry.ciVisEvent(TELEMETRY_EVENT_CREATED, 'suite')
       if (_ddTestCodeCoverageEnabled) {

package/packages/datadog-plugin-kafkajs/src/consumer.js

@@ -76,8 +76,7 @@ class KafkajsConsumerPlugin extends ConsumerPlugin {
       },
       metrics: {
         'kafka.partition': partition
-      },
-      extractedLinks: childOf?._links
+      }
     })
     if (this.config.dsmEnabled && message?.headers) {
       const payloadSize = getMessageSize(message)

package/packages/datadog-plugin-langchain/src/handlers/chain.js

@@ -0,0 +1,50 @@
+'use strict'
+
+const LangChainHandler = require('./default')
+
+class LangChainChainHandler extends LangChainHandler {
+  getSpanStartTags (ctx) {
+    const tags = {}
+
+    if (!this.isPromptCompletionSampled()) return tags
+
+    let inputs = ctx.args?.[0]
+    inputs = Array.isArray(inputs) ? inputs : [inputs]
+
+    for (const idx in inputs) {
+      const input = inputs[idx]
+      if (typeof input !== 'object') {
+        tags[`langchain.request.inputs.${idx}`] = this.normalize(input)
+      } else {
+        for (const [key, value] of Object.entries(input)) {
+        // these are mappings to the python client names, ie lc_kwargs
+        // only present on BaseMessage types
+          if (key.includes('lc_')) continue
+          tags[`langchain.request.inputs.${idx}.${key}`] = this.normalize(value)
+        }
+      }
+    }
+
+    return tags
+  }
+
+  getSpanEndTags (ctx) {
+    const tags = {}
+
+    if (!this.isPromptCompletionSampled()) return tags
+
+    let outputs = ctx.result
+    outputs = Array.isArray(outputs) ? outputs : [outputs]
+
+    for (const idx in outputs) {
+      const output = outputs[idx]
+      tags[`langchain.response.outputs.${idx}`] = this.normalize(
+        typeof output === 'string' ? output : JSON.stringify(output)
+      )
+    }
+
+    return tags
+  }
+}
+
+module.exports = LangChainChainHandler

package/packages/datadog-plugin-langchain/src/handlers/default.js

@@ -0,0 +1,53 @@
+'use strict'
+
+const Sampler = require('../../../dd-trace/src/sampler')
+
+const RE_NEWLINE = /\n/g
+const RE_TAB = /\t/g
+
+// TODO: should probably refactor the OpenAI integration to use a shared LLMTracingPlugin base class
+// This logic isn't particular to LangChain
+class LangChainHandler {
+  constructor (config) {
+    this.config = config
+    this.sampler = new Sampler(config.spanPromptCompletionSampleRate)
+  }
+
+  // no-op for default handler
+  getSpanStartTags (ctx) {}
+
+  // no-op for default handler
+  getSpanEndTags (ctx) {}
+
+  // no-op for default handler
+  extractApiKey (instance) {}
+
+  // no-op for default handler
+  extractProvider (instance) {}
+
+  // no-op for default handler
+  extractModel (instance) {}
+
+  normalize (text) {
+    if (!text) return
+    if (typeof text !== 'string' || !text || (typeof text === 'string' && text.length === 0)) return
+
+    const max = this.config.spanCharLimit
+
+    text = text
+      .replace(RE_NEWLINE, '\\n')
+      .replace(RE_TAB, '\\t')
+
+    if (text.length > max) {
+      return text.substring(0, max) + '...'
+    }
+
+    return text
+  }
+
+  isPromptCompletionSampled () {
+    return this.sampler.isSampled()
+  }
+}
+
+module.exports = LangChainHandler

package/packages/datadog-plugin-langchain/src/handlers/embedding.js

@@ -0,0 +1,63 @@
+'use strict'
+
+const LangChainHandler = require('./default')
+
+class LangChainEmbeddingHandler extends LangChainHandler {
+  getSpanStartTags (ctx) {
+    const tags = {}
+
+    const inputTexts = ctx.args?.[0]
+
+    const sampled = this.isPromptCompletionSampled()
+    if (typeof inputTexts === 'string') {
+      // embed query
+      if (sampled) {
+        tags['langchain.request.inputs.0.text'] = this.normalize(inputTexts)
+      }
+      tags['langchain.request.input_counts'] = 1
+    } else {
+      // embed documents
+      if (sampled) {
+        for (const idx in inputTexts) {
+          const inputText = inputTexts[idx]
+          tags[`langchain.request.inputs.${idx}.text`] = this.normalize(inputText)
+        }
+      }
+      tags['langchain.request.input_counts'] = inputTexts.length
+    }
+
+    return tags
+  }
+
+  getSpanEndTags (ctx) {
+    const tags = {}
+
+    const { result } = ctx
+    if (!Array.isArray(result)) return
+
+    tags['langchain.response.outputs.embedding_length'] = (
+      Array.isArray(result[0]) ? result[0] : result
+    ).length
+
+    return tags
+  }
+
+  extractApiKey (instance) {
+    const apiKey = instance.clientConfig?.apiKey
+    if (!apiKey || apiKey.length < 4) return ''
+    return `...${apiKey.slice(-4)}`
+  }
+
+  extractProvider (instance) {
+    return instance.constructor.name.split('Embeddings')[0].toLowerCase()
+  }
+
+  extractModel (instance) {
+    for (const attr of ['model', 'modelName', 'modelId', 'modelKey', 'repoId']) {
+      const modelName = instance[attr]
+      if (modelName) return modelName
+    }
+  }
+}
+
+module.exports = LangChainEmbeddingHandler

package/packages/datadog-plugin-langchain/src/handlers/language_models/chat_model.js

@@ -0,0 +1,99 @@
+'use strict'
+
+const LangChainLanguageModelHandler = require('.')
+
+const COMPLETIONS = 'langchain.response.completions'
+
+class LangChainChatModelHandler extends LangChainLanguageModelHandler {
+  getSpanStartTags (ctx, provider) {
+    const tags = {}
+
+    const inputs = ctx.args?.[0]
+
+    for (const messageSetIndex in inputs) {
+      const messageSet = inputs[messageSetIndex]
+
+      for (const messageIndex in messageSet) {
+        const message = messageSet[messageIndex]
+        if (this.isPromptCompletionSampled()) {
+          tags[`langchain.request.messages.${messageSetIndex}.${messageIndex}.content`] =
+            this.normalize(message.content) || ''
+        }
+        tags[`langchain.request.messages.${messageSetIndex}.${messageIndex}.message_type`] = message.constructor.name
+      }
+    }
+
+    const instance = ctx.instance
+    const identifyingParams = (typeof instance._identifyingParams === 'function' && instance._identifyingParams()) || {}
+    for (const [param, val] of Object.entries(identifyingParams)) {
+      if (param.toLowerCase().includes('apikey') || param.toLowerCase().includes('apitoken')) continue
+      if (typeof val === 'object') {
+        for (const [key, value] of Object.entries(val)) {
+          tags[`langchain.request.${provider}.parameters.${param}.${key}`] = value
+        }
+      } else {
+        tags[`langchain.request.${provider}.parameters.${param}`] = val
+      }
+    }
+
+    return tags
+  }
+
+  getSpanEndTags (ctx) {
+    const { result } = ctx
+
+    const tags = {}
+
+    this.extractTokenMetrics(ctx.currentStore?.span, result)
+
+    for (const messageSetIdx in result.generations) {
+      const messageSet = result.generations[messageSetIdx]
+
+      for (const chatCompletionIdx in messageSet) {
+        const chatCompletion = messageSet[chatCompletionIdx]
+
+        const text = chatCompletion.text
+        const message = chatCompletion.message
+        let toolCalls = message.tool_calls
+
+        if (text && this.isPromptCompletionSampled()) {
+          tags[
+          `${COMPLETIONS}.${messageSetIdx}.${chatCompletionIdx}.content`
+          ] = this.normalize(text)
+        }
+
+        tags[
+        `${COMPLETIONS}.${messageSetIdx}.${chatCompletionIdx}.message_type`
+        ] = message.constructor.name
+
+        if (toolCalls) {
+          if (!Array.isArray(toolCalls)) {
+            toolCalls = [toolCalls]
+          }
+
+          for (const toolCallIndex in toolCalls) {
+            const toolCall = toolCalls[toolCallIndex]
+
+            tags[
+            `${COMPLETIONS}.${messageSetIdx}.${chatCompletionIdx}.tool_calls.${toolCallIndex}.id`
+            ] = toolCall.id
+            tags[
+            `${COMPLETIONS}.${messageSetIdx}.${chatCompletionIdx}.tool_calls.${toolCallIndex}.name`
+            ] = toolCall.name
+
+            const args = toolCall.args || {}
+            for (const [name, value] of Object.entries(args)) {
+              tags[
+              `${COMPLETIONS}.${messageSetIdx}.${chatCompletionIdx}.tool_calls.${toolCallIndex}.args.${name}`
+              ] = this.normalize(value)
+            }
+          }
+        }
+      }
+    }
+
+    return tags
+  }
+}
+
+module.exports = LangChainChatModelHandler

package/packages/datadog-plugin-langchain/src/handlers/language_models/index.js

@@ -0,0 +1,48 @@
+'use strict'
+
+const { getTokensFromLlmOutput } = require('../../tokens')
+const LangChainHandler = require('../default')
+
+class LangChainLanguageModelHandler extends LangChainHandler {
+  extractApiKey (instance) {
+    const key = Object.keys(instance)
+      .find(key => {
+        const lower = key.toLowerCase()
+        return lower.includes('apikey') || lower.includes('apitoken')
+      })
+
+    let apiKey = instance[key]
+    if (apiKey?.secretValue && typeof apiKey.secretValue === 'function') {
+      apiKey = apiKey.secretValue()
+    }
+    if (!apiKey || apiKey.length < 4) return ''
+    return `...${apiKey.slice(-4)}`
+  }
+
+  extractProvider (instance) {
+    return typeof instance._llmType === 'function' && instance._llmType().split('-')[0]
+  }
+
+  extractModel (instance) {
+    for (const attr of ['model', 'modelName', 'modelId', 'modelKey', 'repoId']) {
+      const modelName = instance[attr]
+      if (modelName) return modelName
+    }
+  }
+
+  extractTokenMetrics (span, result) {
+    if (!span || !result) return
+
+    // we do not tag token metrics for non-openai providers
+    const provider = span.context()._tags['langchain.request.provider']
+    if (provider !== 'openai') return
+
+    const tokens = getTokensFromLlmOutput(result)
+
+    for (const [tokenKey, tokenCount] of Object.entries(tokens)) {
+      span.setTag(`langchain.tokens.${tokenKey}_tokens`, tokenCount)
+    }
+  }
+}
+
+module.exports = LangChainLanguageModelHandler

package/packages/datadog-plugin-langchain/src/handlers/language_models/llm.js

@@ -0,0 +1,57 @@
+'use strict'
+
+const LangChainLanguageModelHandler = require('.')
+
+class LangChainLLMHandler extends LangChainLanguageModelHandler {
+  getSpanStartTags (ctx, provider) {
+    const tags = {}
+
+    const prompts = ctx.args?.[0]
+    for (const promptIdx in prompts) {
+      if (!this.isPromptCompletionSampled()) continue
+
+      const prompt = prompts[promptIdx]
+      tags[`langchain.request.prompts.${promptIdx}.content`] = this.normalize(prompt) || ''
+    }
+
+    const instance = ctx.instance
+    const identifyingParams = (typeof instance._identifyingParams === 'function' && instance._identifyingParams()) || {}
+    for (const [param, val] of Object.entries(identifyingParams)) {
+      if (param.toLowerCase().includes('apikey') || param.toLowerCase().includes('apitoken')) continue
+      if (typeof val === 'object') {
+        for (const [key, value] of Object.entries(val)) {
+          tags[`langchain.request.${provider}.parameters.${param}.${key}`] = value
+        }
+      } else {
+        tags[`langchain.request.${provider}.parameters.${param}`] = val
+      }
+    }
+
+    return tags
+  }
+
+  getSpanEndTags (ctx) {
+    const { result } = ctx
+
+    const tags = {}
+
+    this.extractTokenMetrics(ctx.currentStore?.span, result)
+
+    for (const completionIdx in result.generations) {
+      const completion = result.generations[completionIdx]
+      if (this.isPromptCompletionSampled()) {
+        tags[`langchain.response.completions.${completionIdx}.text`] = this.normalize(completion[0].text) || ''
+      }
+
+      if (completion && completion[0].generationInfo) {
+        const generationInfo = completion[0].generationInfo
+        tags[`langchain.response.completions.${completionIdx}.finish_reason`] = generationInfo.finishReason
+        tags[`langchain.response.completions.${completionIdx}.logprobs`] = generationInfo.logprobs
+      }
+    }
+
+    return tags
+  }
+}
+
+module.exports = LangChainLLMHandler

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

@@ -0,0 +1,89 @@
+'use strict'
+
+const { MEASURED } = require('../../../ext/tags')
+const { storage } = require('../../datadog-core')
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+
+const API_KEY = 'langchain.request.api_key'
+const MODEL = 'langchain.request.model'
+const PROVIDER = 'langchain.request.provider'
+const TYPE = 'langchain.request.type'
+
+const LangChainHandler = require('./handlers/default')
+const LangChainChatModelHandler = require('./handlers/language_models/chat_model')
+const LangChainLLMHandler = require('./handlers/language_models/llm')
+const LangChainChainHandler = require('./handlers/chain')
+const LangChainEmbeddingHandler = require('./handlers/embedding')
+
+class LangChainPlugin extends TracingPlugin {
+  static get id () { return 'langchain' }
+  static get operation () { return 'invoke' }
+  static get system () { return 'langchain' }
+  static get prefix () {
+    return 'tracing:apm:langchain:invoke'
+  }
+
+  constructor () {
+    super(...arguments)
+
+    const langchainConfig = this._tracerConfig.langchain || {}
+    this.handlers = {
+      chain: new LangChainChainHandler(langchainConfig),
+      chat_model: new LangChainChatModelHandler(langchainConfig),
+      llm: new LangChainLLMHandler(langchainConfig),
+      embedding: new LangChainEmbeddingHandler(langchainConfig),
+      default: new LangChainHandler(langchainConfig)
+    }
+  }
+
+  bindStart (ctx) {
+    const { resource, type } = ctx
+    const handler = this.handlers[type]
+
+    const instance = ctx.instance
+    const apiKey = handler.extractApiKey(instance)
+    const provider = handler.extractProvider(instance)
+    const model = handler.extractModel(instance)
+
+    const tags = handler.getSpanStartTags(ctx, provider) || []
+
+    if (apiKey) tags[API_KEY] = apiKey
+    if (provider) tags[PROVIDER] = provider
+    if (model) tags[MODEL] = model
+    if (type) tags[TYPE] = type
+
+    const span = this.startSpan('langchain.request', {
+      service: this.config.service,
+      resource,
+      kind: 'client',
+      meta: {
+        [MEASURED]: 1,
+        ...tags
+      }
+    }, false)
+
+    const store = storage.getStore() || {}
+    ctx.currentStore = { ...store, span }
+
+    return ctx.currentStore
+  }
+
+  asyncEnd (ctx) {
+    const span = ctx.currentStore.span
+
+    const { type } = ctx
+
+    const handler = this.handlers[type]
+    const tags = handler.getSpanEndTags(ctx) || {}
+
+    span.addTags(tags)
+
+    span.finish()
+  }
+
+  getHandler (type) {
+    return this.handlers[type] || this.handlers.default
+  }
+}
+
+module.exports = LangChainPlugin

package/packages/datadog-plugin-langchain/src/tokens.js

@@ -0,0 +1,35 @@
+'use strict'
+
+function getTokensFromLlmOutput (result) {
+  const tokens = {
+    input: 0,
+    output: 0,
+    total: 0
+  }
+  const { llmOutput } = result
+  if (!llmOutput) return tokens
+
+  const tokenUsage = llmOutput.tokenUsage || llmOutput.usage_metadata || llmOutput.usage_metadata
+  if (!tokenUsage) return tokens
+
+  for (const tokenNames of [['input', 'prompt'], ['output', 'completion'], ['total']]) {
+    let token = 0
+    for (const tokenName of tokenNames) {
+      const underScore = `${tokenName}_tokens`
+      const camelCase = `${tokenName}Tokens`
+
+      token = tokenUsage[underScore] || tokenUsage[camelCase] || token
+    }
+
+    tokens[tokenNames[0]] = token
+  }
+
+  // assign total_tokens again in case it was improperly set the first time, or was not on tokenUsage
+  tokens.total = tokens.total || tokens.input + tokens.output
+
+  return tokens
+}
+
+module.exports = {
+  getTokensFromLlmOutput
+}

package/packages/datadog-plugin-moleculer/src/server.js

@@ -18,8 +18,7 @@ class MoleculerServerPlugin extends ServerPlugin {
       meta: {
         'resource.name': action.name,
         ...moleculerTags(broker, ctx, this.config)
-      },
-      extractedLinks: followsFrom?._links
+      }
     })
   }
 }

package/packages/datadog-plugin-rhea/src/consumer.js

@@ -28,8 +28,7 @@ class RheaConsumerPlugin extends ConsumerPlugin {
         component: 'rhea',
         'amqp.link.source.address': name,
         'amqp.link.role': 'receiver'
-      },
-      extractedLinks: childOf?._links
+      }
     })
 
     if (

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

@@ -191,8 +191,7 @@ class VitestPlugin extends CiPlugin {
           [COMPONENT]: this.constructor.id,
           ...this.testEnvironmentMetadata,
           ...testSuiteMetadata
-        },
-        extractedLinks: testSessionSpanContext?._links
+        }
       })
       this.telemetry.ciVisEvent(TELEMETRY_EVENT_CREATED, 'suite')
       const store = storage.getStore()

package/packages/dd-trace/src/appsec/sdk/utils.js

@@ -1,8 +1,27 @@
 'use strict'
 
 function getRootSpan (tracer) {
-  const span = tracer.scope().active()
-  return span && span.context()._trace.started[0]
+  let span = tracer.scope().active()
+  if (!span) return
+
+  const context = span.context()
+  const started = context._trace.started
+
+  let parentId = context._parentId
+  while (parentId) {
+    const parent = started.find(s => s.context()._spanId === parentId)
+    const pContext = parent?.context()
+
+    if (!pContext) break
+
+    parentId = pContext._parentId
+
+    if (!pContext._tags?._inferred_span) {
+      span = parent
+    }
+  }
+
+  return span
 }
 
 module.exports = {

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

@@ -505,6 +505,8 @@ class Config {
     this._setValue(defaults, 'isGitUploadEnabled', false)
     this._setValue(defaults, 'isIntelligentTestRunnerEnabled', false)
     this._setValue(defaults, 'isManualApiEnabled', false)
+    this._setValue(defaults, 'langchain.spanCharLimit', 128)
+    this._setValue(defaults, 'langchain.spanPromptCompletionSampleRate', 1.0)
     this._setValue(defaults, 'llmobs.agentlessEnabled', false)
     this._setValue(defaults, 'llmobs.enabled', false)
     this._setValue(defaults, 'llmobs.mlApp', undefined)
@@ -615,6 +617,8 @@ class Config {
       DD_INSTRUMENTATION_TELEMETRY_ENABLED,
       DD_INSTRUMENTATION_CONFIG_ID,
       DD_LOGS_INJECTION,
+      DD_LANGCHAIN_SPAN_CHAR_LIMIT,
+      DD_LANGCHAIN_SPAN_PROMPT_COMPLETION_SAMPLE_RATE,
       DD_LLMOBS_AGENTLESS_ENABLED,
       DD_LLMOBS_ENABLED,
       DD_LLMOBS_ML_APP,
@@ -771,6 +775,10 @@ class Config {
     this._setArray(env, 'injectionEnabled', DD_INJECTION_ENABLED)
     this._setBoolean(env, 'isAzureFunction', getIsAzureFunction())
     this._setBoolean(env, 'isGCPFunction', getIsGCPFunction())
+    this._setValue(env, 'langchain.spanCharLimit', maybeInt(DD_LANGCHAIN_SPAN_CHAR_LIMIT))
+    this._setValue(
+      env, 'langchain.spanPromptCompletionSampleRate', maybeFloat(DD_LANGCHAIN_SPAN_PROMPT_COMPLETION_SAMPLE_RATE)
+    )
     this._setBoolean(env, 'legacyBaggageEnabled', DD_TRACE_LEGACY_BAGGAGE_ENABLED)
     this._setBoolean(env, 'llmobs.agentlessEnabled', DD_LLMOBS_AGENTLESS_ENABLED)
     this._setBoolean(env, 'llmobs.enabled', DD_LLMOBS_ENABLED)

package/packages/dd-trace/src/crashtracking/crashtracker.js

@@ -53,14 +53,14 @@ class Crashtracker {
         // TODO: Use the string directly when deserialization is fixed.
         url: {
           scheme: url.protocol.slice(0, -1),
-          authority: url.protocol === 'unix'
+          authority: url.protocol === 'unix:'
             ? Buffer.from(url.pathname).toString('hex')
             : url.host,
           path_and_query: ''
         },
         timeout_ms: 3000
       },
-      timeout_ms: 0,
+      timeout_ms: 5000,
       // TODO: Use `EnabledWithSymbolsInReceiver` instead for Linux when fixed.
       resolve_frames: 'EnabledWithInprocessSymbols'
     }

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

@@ -15,6 +15,8 @@ module.exports = {
   get '@jest/test-sequencer' () { return require('../../../datadog-plugin-jest/src') },
   get '@jest/transform' () { return require('../../../datadog-plugin-jest/src') },
   get '@koa/router' () { return require('../../../datadog-plugin-koa/src') },
+  get '@langchain/core' () { return require('../../../datadog-plugin-langchain/src') },
+  get '@langchain/openai' () { return require('../../../datadog-plugin-langchain/src') },
   get '@node-redis/client' () { return require('../../../datadog-plugin-redis/src') },
   get '@opensearch-project/opensearch' () { return require('../../../datadog-plugin-opensearch/src') },
   get '@redis/client' () { return require('../../../datadog-plugin-redis/src') },
@@ -52,6 +54,7 @@ module.exports = {
   get koa () { return require('../../../datadog-plugin-koa/src') },
   get 'koa-router' () { return require('../../../datadog-plugin-koa/src') },
   get kafkajs () { return require('../../../datadog-plugin-kafkajs/src') },
+  get langchain () { return require('../../../datadog-plugin-langchain/src') },
   get mariadb () { return require('../../../datadog-plugin-mariadb/src') },
   get memcached () { return require('../../../datadog-plugin-memcached/src') },
   get 'microgateway-core' () { return require('../../../datadog-plugin-microgateway-core/src') },

package/packages/dd-trace/src/plugins/tracing.js

@@ -101,7 +101,7 @@ class TracingPlugin extends Plugin {
     }
   }
 
-  startSpan (name, { childOf, kind, meta, metrics, service, resource, type, extractedLinks } = {}, enter = true) {
+  startSpan (name, { childOf, kind, meta, metrics, service, resource, type } = {}, enter = true) {
     const store = storage.getStore()
     if (store && childOf === undefined) {
       childOf = store.span
@@ -119,7 +119,7 @@ class TracingPlugin extends Plugin {
         ...metrics
       },
       integrationName: type,
-      links: extractedLinks
+      links: childOf?._links
     })
 
     analyticsSampler.sample(span, this.config.measured)

package/packages/dd-trace/src/plugins/util/web.js

@@ -267,7 +267,7 @@ const web = {
       }
     }
 
-    const span = tracer.startSpan(name, { childOf, extractedLinks: childOf?.links })
+    const span = tracer.startSpan(name, { childOf, links: childOf?._links })
 
     return span
   },

package/packages/dd-trace/src/profiling/exporters/agent.js

@@ -13,15 +13,42 @@ const os = require('os')
 const { urlToHttpOptions } = require('url')
 const perf = require('perf_hooks').performance
 
+const telemetryMetrics = require('../../telemetry/metrics')
+const profilersNamespace = telemetryMetrics.manager.namespace('profilers')
+
 const containerId = docker.id()
 
+const statusCodeCounters = []
+const requestCounter = profilersNamespace.count('profile_api.requests', [])
+const sizeDistribution = profilersNamespace.distribution('profile_api.bytes', [])
+const durationDistribution = profilersNamespace.distribution('profile_api.ms', [])
+const statusCodeErrorCounter = profilersNamespace.count('profile_api.errors', ['type:status_code'])
+const networkErrorCounter = profilersNamespace.count('profile_api.errors', ['type:network'])
+// TODO: implement timeout error counter when we have a way to track timeouts
+// const timeoutErrorCounter = profilersNamespace.count('profile_api.errors', ['type:timeout'])
+
+function countStatusCode (statusCode) {
+  let counter = statusCodeCounters[statusCode]
+  if (counter === undefined) {
+    counter = statusCodeCounters[statusCode] = profilersNamespace.count(
+      'profile_api.responses', [`status_code:${statusCode}`]
+    )
+  }
+  counter.inc()
+}
+
 function sendRequest (options, form, callback) {
   const request = options.protocol === 'https:' ? httpsRequest : httpRequest
 
   const store = storage.getStore()
   storage.enterWith({ noop: true })
+  requestCounter.inc()
+  const start = perf.now()
   const req = request(options, res => {
+    durationDistribution.track(perf.now() - start)
+    countStatusCode(res.statusCode)
     if (res.statusCode >= 400) {
+      statusCodeErrorCounter.inc()
       const error = new Error(`HTTP Error ${res.statusCode}`)
       error.status = res.statusCode
       callback(error)
@@ -29,14 +56,24 @@ function sendRequest (options, form, callback) {
       callback(null, res)
     }
   })
-  req.on('error', callback)
-  if (form) form.pipe(req)
+
+  req.on('error', (err) => {
+    networkErrorCounter.inc()
+    callback(err)
+  })
+  if (form) {
+    sizeDistribution.track(form.size())
+    form.pipe(req)
+  }
   storage.enterWith(store)
 }
 
 function getBody (stream, callback) {
   const chunks = []
-  stream.on('error', callback)
+  stream.on('error', (err) => {
+    networkErrorCounter.inc()
+    callback(err)
+  })
   stream.on('data', chunk => chunks.push(chunk))
   stream.on('end', () => {
     callback(null, Buffer.concat(chunks))
@@ -198,7 +235,7 @@ class AgentExporter {
           if (err) {
             const { status } = err
             if ((typeof status !== 'number' || status >= 500 || status === 429) && operation.retry(err)) {
-              this._logger.error(`Error from the agent: ${err.message}`)
+              this._logger.warn(`Error from the agent: ${err.message}`)
             } else {
               reject(err)
             }
@@ -207,7 +244,7 @@ class AgentExporter {
 
           getBody(response, (err, body) => {
             if (err) {
-              this._logger.error(`Error reading agent response: ${err.message}`)
+              this._logger.warn(`Error reading agent response: ${err.message}`)
             } else {
               this._logger.debug(() => {
                 const bytes = (body.toString('hex').match(/../g) || []).join(' ')

package/packages/dd-trace/src/profiling/profiler.js

@@ -199,8 +199,11 @@ class Profiler extends EventEmitter {
     tags.snapshot = snapshotKind
     for (const exporter of this._config.exporters) {
       const task = exporter.export({ profiles, start, end, tags })
-        .catch(err => this._logError(err))
-
+        .catch(err => {
+          if (this._logger) {
+            this._logger.warn(err)
+          }
+        })
       tasks.push(task)
     }