newrelic 13.6.2 → 13.6.4

package/lib/instrumentation/mysql/mysql.js

@@ -1,333 +0,0 @@
-/*
- * Copyright 2020 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-'use strict'
-
-const dbutils = require('../../db/utils')
-const properties = require('../../util/properties')
-const symbols = require('../../symbols')
-const { QuerySpec } = require('../../shim/specs')
-const DatastoreParameters = require('../../shim/specs/params/datastore')
-
-/**
- * Used to instrument `mysql` and `mysql2` packages
- * the `mysql2/promise` instrumentation is below in `promiseInitialize`
- *
- * @param {Shim} shim instance of shim
- * @param {object} mysql package to instrument
- */
-function callbackInitialize(shim, mysql) {
-  shim.setDatastore(shim.MYSQL)
-  shim[symbols.wrappedPoolConnection] = false
-
-  shim.wrapReturn(mysql, 'createConnection', wrapCreateConnection)
-  shim.wrapReturn(mysql, 'createPool', wrapCreatePool)
-  shim.wrapReturn(mysql, 'createPoolCluster', wrapCreatePoolCluster)
-}
-
-/**
- * Used to instrument `mysql2/promise`
- *
- * @param {Shim} shim instance of shim
- * @param {object} mysql2 package to instrument
- */
-function promiseInitialize(shim, mysql2) {
-  shim.setDatastore(shim.MYSQL)
-  shim[symbols.wrappedPoolConnection] = false
-  shim.wrap(
-    mysql2,
-    'createConnection',
-    function wrapPromiseCreateConnection(shim, createConnection) {
-      return async function wrappedPromiseCreateConnection() {
-        const promiseConnection = await createConnection.apply(this, arguments)
-        wrapCreateConnection(
-          shim,
-          createConnection,
-          'createConnection',
-          promiseConnection.connection
-        )
-        return promiseConnection
-      }
-    }
-  )
-
-  shim.wrap(mysql2, 'createPool', function wrapPromiseCreatePool(shim, createPool) {
-    return function wrappedPromiseCreatePool() {
-      const promisePool = createPool.apply(this, arguments)
-      wrapCreatePool(shim, createPool, 'createPool', promisePool.pool)
-      return promisePool
-    }
-  })
-
-  shim.wrap(
-    mysql2,
-    'createPoolCluster',
-    function wrapPromiseCreatePoolCluster(shim, createPoolCluster) {
-      return function wrappedPromiseCreatePoolCluster() {
-        const promisePoolCluster = createPoolCluster.apply(this, arguments)
-        wrapCreatePoolCluster(
-          shim,
-          createPoolCluster,
-          'createPoolCluster',
-          promisePoolCluster.poolCluster
-        )
-        return promisePoolCluster
-      }
-    }
-  )
-}
-
-function wrapCreateConnection(shim, fn, fnName, connection) {
-  if (shim[symbols.unwrapConnection]) {
-    return
-  }
-  shim.logger.debug('Wrapping Connection#query')
-  if (wrapQueryable(shim, connection, false)) {
-    const connProto = Object.getPrototypeOf(connection)
-    connProto[symbols.storeDatabase] = true
-    shim[symbols.unwrapConnection] = true
-  }
-}
-
-function wrapCreatePool(shim, fn, fnName, pool) {
-  if (shim[symbols.unwrapPool]) {
-    return
-  }
-  shim.logger.debug('Wrapping Pool#query and Pool#getConnection')
-  if (wrapQueryable(shim, pool, true) && wrapGetConnection(shim, pool)) {
-    shim[symbols.unwrapPool] = true
-  }
-}
-
-function wrapCreatePoolCluster(shim, fn, fnName, poolCluster) {
-  if (shim[symbols.createPoolCluster]) {
-    return
-  }
-  shim.logger.debug('Wrapping PoolCluster#of')
-  const proto = Object.getPrototypeOf(poolCluster)
-  shim.wrapReturn(proto, 'of', wrapPoolClusterOf)
-  function wrapPoolClusterOf(shim, of, _n, poolNamespace) {
-    if (poolNamespace[symbols.clusterOf]) {
-      return
-    }
-
-    if (wrapGetConnection(shim, poolNamespace) && wrapQueryable(shim, poolNamespace, false)) {
-      poolNamespace[symbols.clusterOf] = true
-    }
-  }
-
-  shim.logger.debug('Wrapping PoolCluster#getConnection')
-  if (wrapGetConnection(shim, poolCluster)) {
-    shim[symbols.createPoolCluster] = true
-  }
-}
-
-function wrapGetConnection(shim, connectable) {
-  if (!connectable || !connectable.getConnection || shim.isWrapped(connectable.getConnection)) {
-    shim.logger.trace(
-      {
-        connectable: !!connectable,
-        getConnection: !!(connectable && connectable.getConnection),
-        isWrapped: !!(connectable && shim.isWrapped(connectable.getConnection))
-      },
-      'Not wrapping getConnection'
-    )
-    return false
-  }
-
-  const proto = Object.getPrototypeOf(connectable)
-  shim.wrap(proto, 'getConnection', function doWrapGetConnection(shim, fn) {
-    return function wrappedGetConnection() {
-      const args = shim.toArray(arguments)
-      const cbIdx = args.length - 1
-
-      // avoid an infinite loop and check both the cb and the "original" cb before re-wrapping
-      // this is only applicable now with the security agent + us doing the same thing
-      const original = shim.getOriginalOnce(args[cbIdx])
-      if (
-        shim.isFunction(args[cbIdx]) &&
-        !(shim.isWrapped(args[cbIdx]) || shim.isWrapped(original))
-      ) {
-        shim.logger.trace(
-          {
-            hasSegment: !!shim.getSegment()
-          },
-          'Wrapping callback with segment'
-        )
-        let cb = args[cbIdx]
-        if (!shim[symbols.wrappedPoolConnection]) {
-          cb = shim.wrap(cb, wrapGetConnectionCallback)
-        }
-        args[cbIdx] = shim.bindSegment(cb)
-      }
-      return fn.apply(this, args)
-    }
-  })
-
-  return true
-}
-
-function wrapGetConnectionCallback(shim, cb) {
-  return function wrappedGetConnectionCallback(err, conn) {
-    try {
-      shim.logger.debug('Wrapping PoolConnection#query')
-      if (!err && wrapQueryable(shim, conn, false)) {
-        // Leave getConnection wrapped in order to maintain TX state, but we can
-        // simplify the wrapping of its callback in future calls.
-        shim[symbols.wrappedPoolConnection] = true
-      }
-    } catch (_err) {
-      shim.logger.debug(
-        { error: _err },
-        'Attempt to wrap PoolConnection#query resulted in thrown error'
-      )
-    }
-    return cb.apply(this, arguments)
-  }
-}
-
-function wrapQueryable(shim, queryable, isPoolQuery) {
-  if (!queryable || !queryable.query || shim.isWrapped(queryable.query)) {
-    shim.logger.debug(
-      {
-        queryable: !!queryable,
-        query: !!(queryable && queryable.query),
-        isWrapped: !!(queryable && shim.isWrapped(queryable.query))
-      },
-      'Not wrapping queryable'
-    )
-    return false
-  }
-
-  const proto = Object.getPrototypeOf(queryable)
-
-  let describe
-  if (isPoolQuery) {
-    describe = describePoolQuery
-  } else {
-    describe = describeQuery
-    proto[symbols.databaseName] = null
-  }
-
-  shim.recordQuery(proto, 'query', describe)
-
-  if (queryable.execute) {
-    shim.recordQuery(proto, 'execute', describe)
-  }
-
-  return true
-}
-
-function extractQueryArgs(shim, args) {
-  let query = ''
-  let callback = null
-
-  // Figure out the query parameter.
-  if (shim.isString(args[0])) {
-    // query(sql [, values], callback)
-    query = args[0]
-  } else {
-    // query(opts [, values], callback)
-    query = args[0].sql
-  }
-
-  // Then determine the query values and callback parameters.
-  if (shim.isArray(args[1])) {
-    // query({opts|sql}, values, callback)
-    callback = 2
-  } else {
-    // query({opts|sql}, callback)
-    callback = 1
-  }
-
-  return {
-    query,
-    callback
-  }
-}
-
-function describeQuery(shim, queryFn, fnName, args) {
-  shim.logger.trace('Recording query')
-  const extractedArgs = extractQueryArgs(shim, args)
-
-  // Pull out instance attributes.
-  const parameters = getInstanceParameters(shim, this, extractedArgs.query)
-
-  shim.logger.trace(
-    {
-      query: !!extractedArgs.query,
-      callback: !!extractedArgs.callback,
-      parameters: !!parameters
-    },
-    'Query segment descriptor'
-  )
-
-  return new QuerySpec({
-    stream: true,
-    query: extractedArgs.query,
-    callback: extractedArgs.callback,
-    parameters,
-    record: true
-  })
-}
-
-function describePoolQuery(shim, queryFn, fnName, args) {
-  shim.logger.trace('Recording pool query')
-  const extractedArgs = extractQueryArgs(shim, args)
-  return new QuerySpec({
-    internal: false,
-    stream: true,
-    query: null,
-    callback: extractedArgs.callback,
-    name: 'MySQL Pool#query',
-    record: false
-  })
-}
-
-function getInstanceParameters(shim, queryable, query) {
-  const parameters = new DatastoreParameters()
-  let conf = queryable.config
-  conf = conf?.connectionConfig || conf
-  const databaseName = queryable[symbols.databaseName] || null
-  if (conf) {
-    parameters.database_name = databaseName || conf.database
-
-    if (properties.hasOwn(conf, 'socketPath') && conf.socketPath) {
-      // In the unix domain socket case we force the host to be localhost
-      parameters.host = 'localhost'
-      parameters.port_path_or_id = conf.socketPath
-    } else {
-      parameters.host = conf.host
-      parameters.port_path_or_id = conf.port
-    }
-  } else {
-    shim.logger.trace('No query config detected, not collecting db instance data')
-  }
-
-  storeDatabaseName(queryable, query)
-  return parameters
-}
-
-function storeDatabaseName(queryable, query) {
-  if (queryable[symbols.storeDatabase]) {
-    const databaseName = dbutils.extractDatabaseChangeFromUse(query)
-    if (databaseName) {
-      queryable[symbols.databaseName] = databaseName
-    }
-  }
-}
-
-module.exports = {
-  callbackInitialize,
-  promiseInitialize,
-  wrapGetConnection,
-  wrapGetConnectionCallback,
-  wrapQueryable,
-  extractQueryArgs,
-  describeQuery,
-  describePoolQuery,
-  getInstanceParameters,
-  storeDatabaseName
-}

package/lib/instrumentation/mysql/nr-hooks.js

@@ -1,26 +0,0 @@
-/*
- * Copyright 2022 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-'use strict'
-const instrumentation = require('./mysql')
-const InstrumentationDescriptor = require('../../instrumentation-descriptor')
-
-module.exports = [
-  {
-    type: InstrumentationDescriptor.TYPE_DATASTORE,
-    moduleName: 'mysql',
-    onRequire: instrumentation.callbackInitialize
-  },
-  {
-    type: InstrumentationDescriptor.TYPE_DATASTORE,
-    moduleName: 'mysql2',
-    onRequire: instrumentation.callbackInitialize
-  },
-  {
-    type: InstrumentationDescriptor.TYPE_DATASTORE,
-    moduleName: 'mysql2/promise',
-    onRequire: instrumentation.promiseInitialize
-  }
-]

package/lib/llm-events/google-genai/utils.js

@@ -1,32 +0,0 @@
-/*
- * Copyright 2025 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-'use strict'
-
-const { setTokensInResponse } = require('../utils')
-
-function setUsageTokens(response, context) {
-  // prompt and completion token counts must available in order to add all usage attributes to response
-  // if total tokens is not available, we can manually add it up (from input and output token count)
-  if (tokenUsageAttributesExist(response) === false) {
-    return
-  }
-
-  const promptTokens = Number(response?.usageMetadata?.promptTokenCount)
-  const completionTokens = Number(response?.usageMetadata?.candidatesTokenCount)
-  const totalTokens = Number(response?.usageMetadata?.totalTokenCount)
-
-  setTokensInResponse(context, { promptTokens, completionTokens, totalTokens })
-}
-
-function tokenUsageAttributesExist(response) {
-  const tokens = response?.usageMetadata?.promptTokenCount && response?.usageMetadata?.candidatesTokenCount
-
-  return tokens !== undefined
-}
-module.exports = {
-  tokenUsageAttributesExist,
-  setUsageTokens
-}

package/lib/llm-events/openai/utils.js

@@ -1,34 +0,0 @@
-/*
- * Copyright 2024 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-'use strict'
-
-const { setTokensInResponse } = require('../utils')
-
-function setUsageTokens(response, context) {
-  // input and output token counts must available in order to add all usage attributes to response
-  // if total tokens is not available, we can manually add it up (from input and output token count)
-  if (tokenUsageAttributesExist(response) === false) {
-    return
-  }
-
-  const promptTokens = Number(response?.usage?.prompt_tokens || response?.usage?.input_tokens)
-  const completionTokens = Number(response?.usage?.completion_tokens || response?.usage?.output_tokens)
-  const totalTokens = Number(response?.usage?.total_tokens || response?.usage?.totalTokens)
-
-  setTokensInResponse(context, { promptTokens, completionTokens, totalTokens })
-}
-
-function tokenUsageAttributesExist(response) {
-  const tokensA = response?.usage?.prompt_tokens && response?.usage?.completion_tokens
-  const tokensB = response?.usage?.input_tokens && response?.usage?.output_tokens
-
-  return tokensA !== undefined || tokensB !== undefined
-}
-
-module.exports = {
-  tokenUsageAttributesExist,
-  setUsageTokens
-}

package/lib/llm-events/utils.js

@@ -1,110 +0,0 @@
-/*
- * Copyright 2025 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-'use strict'
-
-/**
- * Determines if the provided token count is valid.
- * A valid token count is greater than 0 and not null.
- * @param {number} tokenCount The token count obtained from the token callback
- * @returns {boolean} Whether the token count is valid
- */
-function validCallbackTokenCount(tokenCount) {
-  return tokenCount !== null && tokenCount > 0
-}
-
-/**
- * Calculates the total token count from the prompt tokens and completion tokens
- * set in the context.
- * @param {LlmEvent} context The context object containing token counts
- * @returns {number} The total token count
- */
-function getTotalTokenCount(context) {
-  return Number(context['response.usage.prompt_tokens']) + Number(context['response.usage.completion_tokens'])
-}
-
-/**
- * Sets the provided tokens counts on the LLM event.
- * @param {LlmChatCompletionMessage} context The context object to set token usage counts on.
- * @param {object} tokens The object contains the token prompt, completion and total counts.
- */
-function setTokensInResponse(context, tokens) {
-  context['response.usage.prompt_tokens'] = tokens.promptTokens
-  context['response.usage.completion_tokens'] = tokens.completionTokens
-  context['response.usage.total_tokens'] = tokens.totalTokens || getTotalTokenCount(context)
-}
-
-/**
- * Calculates prompt and completion token counts using the provided callback and models.
- * If both counts are valid, sets context.token_count to 0.
- *
- * @param {object} options - The params object.
- * @param {LlmChatCompletionMessage} options.context - The context object to set token count on.
- * @param {Function} options.tokenCB - The token counting callback function.
- * @param {string} options.reqModel - The model used for the prompt.
- * @param {string} options.resModel - The model used for the completion.
- * @param {string} options.promptContent - The prompt content to count tokens for.
- * @param {string} options.completionContent - The completion content to count tokens for.
- * @returns {void}
- */
-function setTokenFromCallback({ context, tokenCB, reqModel, resModel, promptContent, completionContent }) {
-  const promptToken = calculateCallbackTokens(tokenCB, reqModel, promptContent)
-  const completionToken = calculateCallbackTokens(tokenCB, resModel, completionContent)
-
-  const hasValidCallbackCounts =
-    validCallbackTokenCount(promptToken) && validCallbackTokenCount(completionToken)
-
-  if (hasValidCallbackCounts) {
-    context.token_count = 0
-  }
-}
-
-/**
- * Calculates prompt and completion token counts using the provided callback and models.
- * If both counts are valid, sets token prompt, completion and total counts on the context.
- *
- * @param {object} options - The params object.
- * @param {LlmEvent} options.context - The context object (llm summary or llm embedding) to set token count on.
- * @param {Function} options.tokenCB - The token counting callback function.
- * @param {string} options.reqModel - The model used for the prompt.
- * @param {string} options.resModel - The model used for the completion.
- * @param {string} options.promptContent - The prompt content to count tokens for.
- * @param {string} options.completionContent - The completion content to count tokens for.
- * @returns {void}
- */
-function setTokenUsageFromCallback({ context, tokenCB, reqModel, resModel, promptContent, completionContent }) {
-  const promptTokens = calculateCallbackTokens(tokenCB, reqModel, promptContent)
-  const completionTokens = calculateCallbackTokens(tokenCB, resModel, completionContent)
-
-  const hasValidCallbackCounts =
-    validCallbackTokenCount(promptTokens) && validCallbackTokenCount(completionTokens)
-
-  if (hasValidCallbackCounts) {
-    setTokensInResponse(context, { promptTokens, completionTokens, totalTokens: promptTokens + completionTokens })
-  }
-}
-
-/**
- * Calculate the token counts using the provided callback.
- * @param {Function} tokenCB - The token count callback function.
- * @param {string} model - The model.
- * @param {string} content - The content to calculate tokens for, such as prompt or completion response.
- * @returns {number|undefined} - The calculated token count or undefined if callback is not a function.
- */
-function calculateCallbackTokens(tokenCB, model, content) {
-  if (typeof tokenCB === 'function') {
-    return tokenCB(model, content)
-  }
-  return undefined
-}
-
-module.exports = {
-  validCallbackTokenCount,
-  getTotalTokenCount,
-  setTokensInResponse,
-  setTokenFromCallback,
-  setTokenUsageFromCallback,
-  calculateCallbackTokens
-}