@depup/dd-trace 5.90.0-depup.0

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

@@ -0,0 +1,326 @@
+'use strict'
+
+const dc = require('dc-polyfill')
+const shimmer = require('../../datadog-shimmer')
+const { addHook } = require('./helpers/instrument')
+
+const ch = dc.tracingChannel('apm:openai:request')
+const onStreamedChunkCh = dc.channel('apm:openai:request:chunk')
+
+const V4_PACKAGE_SHIMS = [
+  {
+    file: 'resources/chat/completions',
+    targetClass: 'Completions',
+    baseResource: 'chat.completions',
+    methods: ['create'],
+    streamedResponse: true,
+  },
+  {
+    file: 'resources/completions',
+    targetClass: 'Completions',
+    baseResource: 'completions',
+    methods: ['create'],
+    streamedResponse: true,
+  },
+  {
+    file: 'resources/responses/responses',
+    targetClass: 'Responses',
+    baseResource: 'responses',
+    methods: ['create'],
+    streamedResponse: true,
+    versions: ['>=4.87.0'],
+  },
+  {
+    file: 'resources/embeddings',
+    targetClass: 'Embeddings',
+    baseResource: 'embeddings',
+    methods: ['create'],
+  },
+  {
+    file: 'resources/files',
+    targetClass: 'Files',
+    baseResource: 'files',
+    methods: ['create', 'list', 'retrieve'],
+  },
+  {
+    file: 'resources/files',
+    targetClass: 'Files',
+    baseResource: 'files',
+    methods: ['del'],
+    versions: ['>=4.0.0 <5.0.0'],
+  },
+  {
+    file: 'resources/files',
+    targetClass: 'Files',
+    baseResource: 'files',
+    methods: ['delete'],
+    versions: ['>=5'],
+  },
+  {
+    file: 'resources/files',
+    targetClass: 'Files',
+    baseResource: 'files',
+    methods: ['retrieveContent'],
+    versions: ['>=4.0.0 <4.17.1'],
+  },
+  {
+    file: 'resources/files',
+    targetClass: 'Files',
+    baseResource: 'files',
+    methods: ['content'], // replaced `retrieveContent` in v4.17.1
+    versions: ['>=4.17.1'],
+  },
+  {
+    file: 'resources/images',
+    targetClass: 'Images',
+    baseResource: 'images',
+    methods: ['createVariation', 'edit', 'generate'],
+  },
+  {
+    file: 'resources/fine-tuning/jobs/jobs',
+    targetClass: 'Jobs',
+    baseResource: 'fine_tuning.jobs',
+    methods: ['cancel', 'create', 'list', 'listEvents', 'retrieve'],
+    versions: ['>=4.34.0'], // file location changed in 4.34.0
+  },
+  {
+    file: 'resources/fine-tuning/jobs',
+    targetClass: 'Jobs',
+    baseResource: 'fine_tuning.jobs',
+    methods: ['cancel', 'create', 'list', 'listEvents', 'retrieve'],
+    versions: ['>=4.1.0 <4.34.0'],
+  },
+  {
+    file: 'resources/fine-tunes', // deprecated after 4.1.0
+    targetClass: 'FineTunes',
+    baseResource: 'fine-tune',
+    methods: ['cancel', 'create', 'list', 'listEvents', 'retrieve'],
+    versions: ['>=4.0.0 <4.1.0'],
+  },
+  {
+    file: 'resources/models',
+    targetClass: 'Models',
+    baseResource: 'models',
+    methods: ['list', 'retrieve'],
+  },
+  {
+    file: 'resources/models',
+    targetClass: 'Models',
+    baseResource: 'models',
+    methods: ['del'],
+    versions: ['>=4 <5'],
+  },
+  {
+    file: 'resources/models',
+    targetClass: 'Models',
+    baseResource: 'models',
+    methods: ['delete'],
+    versions: ['>=5'],
+  },
+  {
+    file: 'resources/moderations',
+    targetClass: 'Moderations',
+    baseResource: 'moderations',
+    methods: ['create'],
+  },
+  {
+    file: 'resources/audio/transcriptions',
+    targetClass: 'Transcriptions',
+    baseResource: 'audio.transcriptions',
+    methods: ['create'],
+  },
+  {
+    file: 'resources/audio/translations',
+    targetClass: 'Translations',
+    baseResource: 'audio.translations',
+    methods: ['create'],
+  },
+  {
+    file: 'resources/chat/completions/completions',
+    targetClass: 'Completions',
+    baseResource: 'chat.completions',
+    methods: ['create'],
+    streamedResponse: true,
+    versions: ['>=4.85.0'],
+  },
+]
+
+addHook({ name: 'openai', file: 'dist/api.js', versions: ['>=3.0.0 <4'] }, exports => {
+  const methodNames = Object.getOwnPropertyNames(exports.OpenAIApi.prototype)
+  methodNames.shift() // remove leading 'constructor' method
+
+  for (const methodName of methodNames) {
+    shimmer.wrap(exports.OpenAIApi.prototype, methodName, fn => function () {
+      if (!ch.start.hasSubscribers) {
+        return fn.apply(this, arguments)
+      }
+
+      const ctx = {
+        methodName,
+        args: arguments,
+        basePath: this.basePath,
+      }
+
+      return ch.tracePromise(fn, ctx, this, ...arguments)
+    })
+  }
+
+  return exports
+})
+
+/**
+ * For streamed responses, we need to accumulate all of the content in
+ * the chunks, and let the combined content be the final response.
+ * This way, spans look the same as when not streamed.
+ */
+function wrapStreamIterator (response, options, ctx) {
+  return function (itr) {
+    return function () {
+      const iterator = itr.apply(this, arguments)
+      shimmer.wrap(iterator, 'next', next => function () {
+        return next.apply(this, arguments)
+          .then(res => {
+            const { done, value: chunk } = res
+            onStreamedChunkCh.publish({ ctx, chunk, done })
+
+            if (done) {
+              finish(ctx, {
+                headers: response.headers,
+                request: {
+                  path: response.url,
+                  method: options.method,
+                },
+              })
+            }
+
+            return res
+          })
+          .catch(err => {
+            finish(ctx, undefined, err)
+
+            throw err
+          })
+      })
+      return iterator
+    }
+  }
+}
+
+const extensions = ['.js', '.mjs']
+
+for (const extension of extensions) {
+  for (const shim of V4_PACKAGE_SHIMS) {
+    const { file, targetClass, baseResource, methods, versions, streamedResponse } = shim
+    addHook({ name: 'openai', file: file + extension, versions: versions || ['>=4'] }, exports => {
+      const targetPrototype = exports[targetClass].prototype
+
+      for (const methodName of methods) {
+        shimmer.wrap(targetPrototype, methodName, methodFn => function () {
+          if (!ch.start.hasSubscribers) {
+            return methodFn.apply(this, arguments)
+          }
+
+          // The OpenAI library lets you set `stream: true` on the options arg to any method
+          // However, we only want to handle streamed responses in specific cases
+          // chat.completions and completions
+          const stream = streamedResponse && getOption(arguments, 'stream', false)
+
+          const client = this._client || this.client
+
+          const ctx = {
+            methodName: `${baseResource}.${methodName}`,
+            args: arguments,
+            basePath: client.baseURL,
+          }
+
+          return ch.start.runStores(ctx, () => {
+            const apiProm = methodFn.apply(this, arguments)
+
+            if (baseResource === 'chat.completions' && typeof apiProm._thenUnwrap === 'function') {
+              // this should only ever be invoked from a client.beta.chat.completions.parse call
+              shimmer.wrap(apiProm, '_thenUnwrap', origApiPromThenUnwrap => function () {
+                // TODO(sam.brenner): I wonder if we can patch the APIPromise prototype instead, although
+                // we might not have access to everything we need...
+
+                // this is a new apipromise instance
+                const unwrappedPromise = origApiPromThenUnwrap.apply(this, arguments)
+
+                shimmer.wrap(unwrappedPromise, 'parse', origApiPromParse => function () {
+                  const parsedPromise = origApiPromParse.apply(this, arguments)
+                    .then(body => Promise.all([this.responsePromise, body]))
+
+                  return handleUnwrappedAPIPromise(parsedPromise, ctx, stream)
+                })
+
+                return unwrappedPromise
+              })
+            }
+
+            // wrapping `parse` avoids problematic wrapping of `then` when trying to call
+            // `withResponse` in userland code after. This way, we can return the whole `APIPromise`
+            shimmer.wrap(apiProm, 'parse', origApiPromParse => function () {
+              const parsedPromise = origApiPromParse.apply(this, arguments)
+                .then(body => Promise.all([this.responsePromise, body]))
+
+              return handleUnwrappedAPIPromise(parsedPromise, ctx, stream)
+            })
+
+            ch.end.publish(ctx)
+
+            return apiProm
+          })
+        })
+      }
+      return exports
+    })
+  }
+}
+
+function handleUnwrappedAPIPromise (apiProm, ctx, stream) {
+  return apiProm
+    .then(([{ response, options }, body]) => {
+      if (stream) {
+        if (body.iterator) {
+          shimmer.wrap(body, 'iterator', wrapStreamIterator(response, options, ctx))
+        } else {
+          shimmer.wrap(
+            body.response.body, Symbol.asyncIterator, wrapStreamIterator(response, options, ctx)
+          )
+        }
+      } else {
+        finish(ctx, {
+          headers: response.headers,
+          data: body,
+          request: {
+            path: response.url,
+            method: options.method,
+          },
+        })
+      }
+
+      return body
+    })
+    .catch(error => {
+      finish(ctx, undefined, error)
+
+      throw error
+    })
+}
+
+function finish (ctx, response, error) {
+  if (error) {
+    ctx.error = error
+    ch.error.publish(ctx)
+  }
+
+  // for successful streamed responses, we've already set the result on ctx.body,
+  // so we don't want to override it here
+  ctx.result ??= {}
+  Object.assign(ctx.result, response)
+
+  ch.asyncEnd.publish(ctx)
+}
+
+function getOption (args, option, defaultValue) {
+  return args[0]?.[option] || defaultValue
+}

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

@@ -0,0 +1,11 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { addHook } = require('./helpers/instrument')
+const { createWrapRequest, createWrapGetConnection } = require('./elasticsearch')
+
+addHook({ name: '@opensearch-project/opensearch', file: 'lib/Transport.js', versions: ['>=1'] }, Transport => {
+  shimmer.wrap(Transport.prototype, 'request', createWrapRequest('opensearch'))
+  shimmer.wrap(Transport.prototype, 'getConnection', createWrapGetConnection('opensearch'))
+  return Transport
+})

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

@@ -0,0 +1,162 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const {
+  channel,
+  addHook,
+} = require('./helpers/instrument')
+
+const connectionAttributes = new WeakMap()
+const poolAttributes = new WeakMap()
+
+const startChannel = channel('apm:oracledb:query:start')
+const errorChannel = channel('apm:oracledb:query:error')
+const finishChannel = channel('apm:oracledb:query:finish')
+
+function finish (ctx) {
+  if (ctx.error) {
+    errorChannel.publish(ctx)
+  }
+  finishChannel.publish(ctx)
+}
+
+addHook({ name: 'oracledb', versions: ['>=5'], file: 'lib/oracledb.js' }, oracledb => {
+  shimmer.wrap(oracledb.Connection.prototype, 'execute', execute => {
+    return function wrappedExecute (dbQuery, ...args) {
+      if (!startChannel.hasSubscribers) {
+        return execute.apply(this, arguments)
+      }
+
+      if (arguments.length && typeof arguments[arguments.length - 1] === 'function') {
+        const cb = arguments[arguments.length - 1]
+        arguments[arguments.length - 1] = shimmer.wrapFunction(cb, cb => function wrappedCb (err, result) {
+          if (err) {
+            ctx.error = err
+            errorChannel.publish(ctx)
+          }
+          return finishChannel.runStores(ctx, () => {
+            return cb.apply(this, arguments)
+          })
+        })
+      }
+
+      let hostname
+      let port
+      let dbInstance
+
+      try {
+        if (this.thin) {
+          const details = this._impl ?? this
+          // Prefer public getters when available (v6), fallback to nscon in v5.
+          dbInstance = this.serviceName ?? details.serviceName
+          hostname = this.hostName ?? details.nscon?.ntAdapter?.hostName
+          const p = this.port ?? details.nscon?.ntAdapter?.port
+          if (p != null) port = String(p)
+        } else {
+          // Avoid host/port getters in thick mode, as they may throw.
+          dbInstance = this.serviceName
+        }
+      } catch {}
+
+      // The connAttrs are used to pass through the argument to the potential
+      // serviceName method a user might have passed through as well as parsing
+      // the connection string in v5 as well as in thick mode.
+      const connAttrs = connectionAttributes.get(this)
+
+      const ctx = {
+        dbInstance,
+        port,
+        hostname,
+        query: dbQuery,
+        connAttrs,
+      }
+
+      return startChannel.runStores(ctx, () => {
+        try {
+          let result = execute.apply(this, arguments)
+
+          if (typeof result?.then === 'function') {
+            result = result.then(
+              x => {
+                finish(ctx)
+                return x
+              },
+              e => {
+                ctx.error = e
+                finish(ctx)
+                throw e
+              }
+            )
+          }
+
+          return result
+        } catch (err) {
+          ctx.error = err
+          finish(ctx)
+          throw err
+        }
+      })
+    }
+  })
+  shimmer.wrap(oracledb, 'getConnection', getConnection => {
+    return function wrappedGetConnection (connAttrs, callback) {
+      if (callback) {
+        arguments[1] = shimmer.wrapFunction(callback, callback => (err, connection) => {
+          if (connection) {
+            connectionAttributes.set(connection, connAttrs)
+          }
+          callback(err, connection)
+        })
+
+        getConnection.apply(this, arguments)
+      } else {
+        return getConnection.apply(this, arguments).then((connection) => {
+          connectionAttributes.set(connection, connAttrs)
+          return connection
+        })
+      }
+    }
+  })
+  shimmer.wrap(oracledb, 'createPool', createPool => {
+    return function wrappedCreatePool (poolAttrs, callback) {
+      if (callback) {
+        arguments[1] = shimmer.wrapFunction(callback, callback => (err, pool) => {
+          if (pool) {
+            poolAttributes.set(pool, poolAttrs)
+          }
+          callback(err, pool)
+        })
+
+        createPool.apply(this, arguments)
+      } else {
+        return createPool.apply(this, arguments).then((pool) => {
+          poolAttributes.set(pool, poolAttrs)
+          return pool
+        })
+      }
+    }
+  })
+  shimmer.wrap(oracledb.Pool.prototype, 'getConnection', getConnection => {
+    return function wrappedGetConnection () {
+      let callback
+      if (typeof arguments[arguments.length - 1] === 'function') {
+        callback = arguments[arguments.length - 1]
+      }
+      if (callback) {
+        arguments[arguments.length - 1] = shimmer.wrapFunction(callback, callback => (err, connection) => {
+          if (connection) {
+            connectionAttributes.set(connection, poolAttributes.get(this))
+          }
+          callback(err, connection)
+        })
+        getConnection.apply(this, arguments)
+      } else {
+        return getConnection.apply(this, arguments).then((connection) => {
+          connectionAttributes.set(connection, poolAttributes.get(this))
+          return connection
+        })
+      }
+    }
+  })
+  return oracledb
+})

package/packages/datadog-instrumentations/src/orchestrion-config/index.js

@@ -0,0 +1,86 @@
+'use strict'
+
+module.exports = `
+version: 1
+dc_module: dc-polyfill
+instrumentations:
+  - module_name: "@langchain/core"
+    version_range: ">=0.1.0"
+    file_path: dist/runnables/base.js
+    function_query:
+      name: invoke
+      type: method
+      kind: async
+      class: RunnableSequence
+    operator: tracePromise
+    channel_name: "RunnableSequence_invoke"
+  - module_name: "@langchain/core"
+    version_range: ">=0.1.0"
+    file_path: dist/runnables/base.js
+    function_query:
+      name: batch
+      type: method
+      kind: async
+      class: RunnableSequence
+    operator: tracePromise
+    channel_name: "RunnableSequence_batch"
+  - module_name: "@langchain/core"
+    version_range: ">=0.1.0"
+    file_path: dist/language_models/chat_models.js
+    function_query:
+      name: generate
+      type: method
+      kind: async
+      class: BaseChatModel
+    operator: tracePromise
+    channel_name: "BaseChatModel_generate"
+  - module_name: "@langchain/core"
+    version_range: ">=0.1.0"
+    file_path: dist/language_models/llms.js
+    function_query:
+      name: generate
+      type: method
+      kind: async
+    operator: tracePromise
+    channel_name: "BaseLLM_generate"
+  - module_name: "@langchain/core"
+    version_range: ">=0.1.0"
+    file_path: dist/embeddings.js
+    function_query:
+      name: constructor
+      type: method
+      kind: sync
+      class: Embeddings
+    operator: traceSync
+    channel_name: "Embeddings_constructor"
+  - module_name: "@langchain/core"
+    version_range: ">=0.1.0"
+    file_path: dist/tools/index.js
+    function_query:
+      name: invoke
+      type: method
+      kind: async
+      class: StructuredTool
+    operator: tracePromise
+    channel_name: "Tool_invoke"
+  - module_name: "@langchain/core"
+    version_range: ">=0.1.0"
+    file_path: dist/vectorstores.js
+    function_query:
+      name: similaritySearch
+      type: method
+      kind: async
+      class: VectorStore
+    operator: tracePromise
+    channel_name: "VectorStore_similaritySearch"
+  - module_name: "@langchain/core"
+    version_range: ">=0.1.0"
+    file_path: dist/vectorstores.js
+    function_query:
+      name: similaritySearchWithScore
+      type: method
+      kind: async
+      class: VectorStore
+    operator: tracePromise
+    channel_name: "VectorStore_similaritySearchWithScore"
+`

package/packages/datadog-instrumentations/src/otel-sdk-trace.js

@@ -0,0 +1,24 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const tracer = require('../../dd-trace')
+const { getValueFromEnvSources } = require('../../dd-trace/src/config/helper')
+const { addHook } = require('./helpers/instrument')
+
+const otelSdkEnabled = getValueFromEnvSources('DD_TRACE_OTEL_ENABLED') ||
+getValueFromEnvSources('OTEL_SDK_DISABLED')
+  ? !getValueFromEnvSources('OTEL_SDK_DISABLED')
+  : undefined
+
+if (otelSdkEnabled) {
+  addHook({
+    name: '@opentelemetry/sdk-trace-node',
+    file: 'build/src/NodeTracerProvider.js',
+    versions: ['*'],
+  }, (mod) => {
+    shimmer.wrap(mod, 'NodeTracerProvider', () => {
+      return tracer.TracerProvider
+    })
+    return mod
+  })
+}

package/packages/datadog-instrumentations/src/passport-http.js

@@ -0,0 +1,10 @@
+'use strict'
+
+const { addHook } = require('./helpers/instrument')
+const { strategyHook } = require('./passport-utils')
+
+addHook({
+  name: 'passport-http',
+  file: 'lib/passport-http/strategies/basic.js',
+  versions: ['>=0.3.0'],
+}, strategyHook)

package/packages/datadog-instrumentations/src/passport-local.js

@@ -0,0 +1,10 @@
+'use strict'
+
+const { addHook } = require('./helpers/instrument')
+const { strategyHook } = require('./passport-utils')
+
+addHook({
+  name: 'passport-local',
+  file: 'lib/strategy.js',
+  versions: ['>=1.0.0'],
+}, strategyHook)

package/packages/datadog-instrumentations/src/passport-utils.js

@@ -0,0 +1,61 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { channel } = require('./helpers/instrument')
+
+const passportVerifyChannel = channel('datadog:passport:verify:finish')
+
+function wrapVerifiedAndPublish (framework, username, verified) {
+  return shimmer.wrapFunction(verified, function wrapVerified (verified) {
+    return function wrappedVerified (err, user) {
+      // if there is an error, it's neither an auth success nor a failure
+      if (!err) {
+        const abortController = new AbortController()
+
+        passportVerifyChannel.publish({ framework, login: username, user, success: !!user, abortController })
+
+        if (abortController.signal.aborted) return
+      }
+
+      return verified.apply(this, arguments)
+    }
+  })
+}
+
+function wrapVerify (verify) {
+  return function wrappedVerify (req, username, password, verified) {
+    if (passportVerifyChannel.hasSubscribers) {
+      const framework = `passport-${this.name}`
+
+      // replace the callback with our own wrapper to get the result
+      if (this._passReqToCallback) {
+        arguments[3] = wrapVerifiedAndPublish(framework, arguments[1], arguments[3])
+      } else {
+        arguments[2] = wrapVerifiedAndPublish(framework, arguments[0], arguments[2])
+      }
+    }
+
+    return verify.apply(this, arguments)
+  }
+}
+
+function wrapStrategy (Strategy) {
+  return function wrappedStrategy () {
+    // verify function can be either the first or second argument
+    if (typeof arguments[0] === 'function') {
+      arguments[0] = wrapVerify(arguments[0])
+    } else {
+      arguments[1] = wrapVerify(arguments[1])
+    }
+
+    return Strategy.apply(this, arguments)
+  }
+}
+
+function strategyHook (Strategy) {
+  return shimmer.wrapFunction(Strategy, wrapStrategy)
+}
+
+module.exports = {
+  strategyHook,
+}