newrelic 9.10.2 → 9.11.0

package/NEWS.md

@@ -1,6 +1,21 @@
+### v9.11.0 (2023-03-08)
+ * Added instrumentation for Prisma(`@prisma/client`).
+   * Miniumum supported version of `@prisma/client` is 4.0.0.
+   * Captures spans for queries. 
+     * It names them based on the model and action.(i.e. Datastore/statement/Prisma/user/create)
+     * For statements and queries using the `$queryRaw`, `$executeRaw`, `$queryRawUnsafe`, and `$executeRawUnsafe` the names will be aligned with the raw SQL.(i.e. Datastore/statement/Prisma/User/select)
+   * Captures database metrics for all statements and queries.
+   * Captures SQL Traces.
+   * Provides connection between application and database server via service maps. 
+
+Huge shoutout to @osmanmrtacar for the original contribution 🙏🏻
+
+ * Updated `@grpc/protoloader` from 0.7.4 to 0.7.5.
+ * Updated `@grpc/grpc-js` from 1.8.7 to 1.8.8. 
+
 ### v9.10.2 (2023-02-21)
 
-* fix: Replaced `request.aborted` with `response.close` in HTTP instrumentation.
+* Replaced `request.aborted` with `response.close` in HTTP instrumentation.
 * Fixed issue where setting `NEW_RELIC_GRPC_IGNORE_STATUS_CODES` was not properly parsing the codes as integers, thus not ignoring reporting errors of certain status codes.
 * Upgraded `@grpc/grpc-js` from 1.8.4 to 1.8.7.
 

package/lib/instrumentation/@prisma/client.js

@@ -0,0 +1,208 @@
+/*
+ * Copyright 2023 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const { prismaConnection, prismaModelCall } = require('../../symbols')
+const { URL } = require('url')
+const logger = require('../../logger').child({ component: 'prisma' })
+const parseSql = require('../../db/query-parsers/sql')
+// Note: runCommandRaw is another raw command but it is mongo which we cannot parse as sql
+const RAW_COMMANDS = ['executeRaw', 'queryRaw']
+
+const semver = require('semver')
+
+/**
+ * Extracts the connection url from env var or the .value prop
+ * Very similar to this helper: https://github.com/prisma/prisma/blob/main/packages/internals/src/utils/parseEnvValue.ts
+ *
+ * @param {string} datasource object from prisma config { url, fromEnvVar }
+ * @returns {string} connection string
+ */
+function extractConnectionString(datasource = {}) {
+  return process.env[datasource.fromEnvVar] || datasource.value
+}
+/**
+ * Parses a connection string. Most database engines in prisma are SQL and all
+ * have similar engine strings.
+ *
+ * **Note**: This will not parse ms sql server, instead will log a warning
+ *
+ * @param {string} provider prisma provider(i.e. mysql, postgres, mongodb)
+ * @param {string} datasource object from prisma config { url, fromEnvVar }
+ * @returns {object} { host, port, dbName }
+ */
+function parseConnectionString(provider, datasource) {
+  const connectionUrl = extractConnectionString(datasource)
+
+  let parameters = {}
+  try {
+    const parsedUrl = new URL(connectionUrl)
+    parameters = {
+      host: parsedUrl.hostname,
+      port: parsedUrl.port,
+      dbName: parsedUrl.pathname && decodeURIComponent(parsedUrl.pathname.split('/')[1])
+    }
+  } catch (err) {
+    logger.warn('Failed to parse connection string for %s: %s', provider, err.message)
+  }
+  return parameters
+}
+
+/**
+ * Extracts the raw query string from the appropriate location within the function args.
+ * In 4.11.0 prisma refactored code and args are an array on .args, whereas before they
+ * were an object on .args.
+ *
+ * @param {Array} args args passed to the prisma function
+ * @param {string} pkgVersion prisma version
+ * @returns {string} raw query string
+ */
+function extractQueryArgs(args, pkgVersion) {
+  let query = ''
+  try {
+    if (semver.gte(pkgVersion, '4.11.0')) {
+      query = args[0].args[0]
+      if (Array.isArray(query)) {
+        // RawUnsafe pass in a string, but plain Raw methods pass in an
+        // array containing a prepared SQL statement and the SQL parameters
+        query = query[0]
+      }
+    } else {
+      query = args[0].args.query
+    }
+  } catch (err) {
+    logger.error('Failed to extract query from raw query: %s', err.message)
+  }
+
+  return query
+}
+
+/**
+ * Extracts either the raw query or the client method.
+ *
+ * @param {Array} args arguments to a prisma operation
+ * @param {string} pkgVersion prisma version
+ * @returns {string} query raw query string or model call <collection>.<operation>
+ */
+function retrieveQuery(args, pkgVersion) {
+  if (Array.isArray(args)) {
+    const action = args[0].action
+    if (RAW_COMMANDS.includes(action)) {
+      return extractQueryArgs(args, pkgVersion)
+    }
+
+    // cast to string obj to attach symbol
+    // this is done to tell query parser that we need to split string
+    // to extract contents
+    const clientMethod = new String(args[0].clientMethod)
+    clientMethod[prismaModelCall] = true
+    return clientMethod
+  }
+}
+
+/**
+ * Parses formatted string to extract the collection and operation.
+ * In case of executeRaw the string is created above in `retrieveQuery`
+ *
+ * @param {string} query raw query string or model call <collection>.<operation>
+ * @returns {object} { collection, operation, query }
+ */
+function queryParser(query) {
+  if (query[prismaModelCall]) {
+    const [collection, operation] = query.split('.')
+    return {
+      collection,
+      operation,
+      // this is a String object, need to parse to string literal
+      query: query.toString()
+    }
+  }
+  return parseSql(query)
+}
+
+/**
+ * Extracts the prisma connection information from the engine. In pre 4.11.0 this existed
+ * on a different object and was also a promise.
+ *
+ * @param {object} client prisma client instance
+ * @param {string} pkgVersion prisma version
+ * @returns {Promise} returns prisma connection configuration
+ */
+function extractPrismaConfig(client, pkgVersion) {
+  if (semver.gte(pkgVersion, '4.11.0')) {
+    // wait for the library promise to resolve before getting the config
+    return client._engine.libraryInstantiationPromise.then(() => {
+      return client._engine.library.getConfig({
+        datamodel: client._engine.datamodel,
+        ignoreEnvVarErrors: true
+      })
+    })
+  }
+  return client._engine.getConfig()
+}
+
+/**
+ * Instruments the `@prisma/client` module, function that is
+ * passed to `onRequire` when instantiating instrumentation.
+ *
+ * @param {object} _agent New Relic agent
+ * @param {object} prisma resolved module
+ * @param {string} _moduleName string representation of require/import path
+ * @param {object} shim New Relic shim
+ */
+module.exports = async function initialize(_agent, prisma, _moduleName, shim) {
+  const pkgVersion = shim.require('./package.json').version
+  if (semver.lt(pkgVersion, '4.0.0')) {
+    logger.warn(
+      'Skipping instrumentation of @prisma/client.  Minimum supported version of library is 4.0.0, actual version %s',
+      pkgVersion
+    )
+    return
+  }
+
+  shim.setDatastore(shim.PRISMA)
+  shim.setParser(queryParser)
+
+  shim.recordQuery(
+    prisma.PrismaClient.prototype,
+    '_executeRequest',
+    function wrapExecuteRequest(shim, _executeRequest, _fnName, args) {
+      const client = this
+
+      return {
+        promise: true,
+        query: retrieveQuery(args, pkgVersion),
+        /**
+         * Adds the relevant host, port, database_name parameters
+         * to the active segment
+         */
+        inContext: async function inContext() {
+          if (!client[prismaConnection]) {
+            try {
+              const prismaConfig = await extractPrismaConfig(client, pkgVersion)
+              const activeDatasource = prismaConfig?.datasources[0]
+              const dbParams = parseConnectionString(
+                activeDatasource?.provider,
+                activeDatasource?.url
+              )
+              shim.captureInstanceAttributes(dbParams.host, dbParams.port, dbParams.dbName)
+              client[prismaConnection] = dbParams
+            } catch (err) {
+              logger.error('Failed to retrieve prisma config in %s: %s', pkgVersion, err.message)
+              client[prismaConnection] = {}
+            }
+          } else {
+            shim.captureInstanceAttributes(
+              client[prismaConnection].host,
+              client[prismaConnection].port,
+              client[prismaConnection].dbName
+            )
+          }
+        }
+      }
+    }
+  )
+}

package/lib/instrumentations.js

@@ -51,7 +51,7 @@ module.exports = function instrumentations() {
     'loglevel': { type: MODULE_TYPE.TRACKING },
     'npmlog': { type: MODULE_TYPE.TRACKING },
     'fancy-log': { type: MODULE_TYPE.TRACKING },
-    '@prisma/client': { type: MODULE_TYPE.TRACKING },
+    '@prisma/client': { type: MODULE_TYPE.DATASTORE },
     '@nestjs/core': { type: MODULE_TYPE.TRACKING },
     'knex': { type: MODULE_TYPE.TRACKING }
   }

package/lib/metrics/names.js

@@ -12,6 +12,7 @@ const NODEJS = {
 const ALL = 'all'
 const POSTGRES_LITERAL = 'Postgres'
 const CASSANDRA_LITERAL = 'Cassandra'
+const PRISMA_LITERAL = 'Prisma'
 const EXPRESS_LITERAL = 'Expressjs'
 const OTHER_TRANSACTION_MESSAGE = 'OtherTransaction/Message'
 
@@ -150,6 +151,13 @@ const CASSANDRA = {
   ALL: DB.PREFIX + `${CASSANDRA_LITERAL}/` + ALL
 }
 
+const PRISMA = {
+  PREFIX: PRISMA_LITERAL,
+  STATEMENT: `${DB.STATEMENT}/${PRISMA_LITERAL}/`,
+  OPERATION: `${DB.OPERATION}/${PRISMA_LITERAL}/`,
+  INSTANCE: `${DB.INSTANCE}/${PRISMA_LITERAL}/`
+}
+
 const EXPRESS = {
   PREFIX: `${EXPRESS_LITERAL}/`,
   MIDDLEWARE: MIDDLEWARE.PREFIX + `${EXPRESS_LITERAL}/`,
@@ -345,5 +353,6 @@ module.exports = {
   URI: 'Uri',
   UTILIZATION: UTILIZATION,
   VIEW: VIEW,
-  WEB: WEB
+  WEB: WEB,
+  PRISMA: PRISMA
 }

package/lib/metrics/normalizer.js

@@ -5,8 +5,6 @@
 
 'use strict'
 
-/* eslint sonarjs/cognitive-complexity: ["error", 24] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
-
 const EventEmitter = require('events').EventEmitter
 const util = require('util')
 const logger = require('../logger').child({ component: 'metric_normalizer' })
@@ -112,45 +110,53 @@ MetricNormalizer.prototype.load = function load(json) {
   }
 }
 
+/**
+ *  Helper for loadFromConfig
+ *
+ * @param rule {object} from this.config.rules
+ * @param ctx {object} context from the calling function
+ */
+function processNameRule(rule, ctx) {
+  if (!rule.pattern) {
+    return logger.error({ rule: rule }, 'Simple naming rules require a pattern.')
+  }
+  if (!rule.name) {
+    return logger.error({ rule: rule }, 'Simple naming rules require a replacement name.')
+  }
+
+  const precedence = rule.precedence
+  const terminal = rule.terminate_chain
+  const json = {
+    match_expression: rule.pattern,
+    eval_order: typeof precedence === 'number' ? precedence : 500,
+    terminate_chain: typeof terminal === 'boolean' ? terminal : true,
+    replace_all: rule.replace_all,
+    replacement: rule.name,
+    ignore: false
+  }
+
+  // Find where the rule should be inserted and do so.
+  const reverse = ctx.config.feature_flag.reverse_naming_rules
+  const insert = ctx.rules.findIndex(function findRule(r) {
+    return reverse ? r.precedence >= json.eval_order : r.precedence > json.eval_order
+  })
+  if (insert === -1) {
+    ctx.rules.push(new NormalizerRule(json))
+  } else {
+    ctx.rules.splice(insert, 0, new NormalizerRule(json))
+  }
+}
 /**
  * Load any rules found in the configuration into a metric normalizer.
  *
  * Operates via side effects.
  */
 MetricNormalizer.prototype.loadFromConfig = function loadFromConfig() {
+  const ctx = this
   const rules = this.config.rules
 
   if (rules && rules.name && rules.name.length > 0) {
-    rules.name.forEach((rule) => {
-      if (!rule.pattern) {
-        return logger.error({ rule: rule }, 'Simple naming rules require a pattern.')
-      }
-      if (!rule.name) {
-        return logger.error({ rule: rule }, 'Simple naming rules require a replacement name.')
-      }
-
-      const precedence = rule.precedence
-      const terminal = rule.terminate_chain
-      const json = {
-        match_expression: rule.pattern,
-        eval_order: typeof precedence === 'number' ? precedence : 500,
-        terminate_chain: typeof terminal === 'boolean' ? terminal : true,
-        replace_all: rule.replace_all,
-        replacement: rule.name,
-        ignore: false
-      }
-
-      // Find where the rule should be inserted and do so.
-      const reverse = this.config.feature_flag.reverse_naming_rules
-      const insert = this.rules.findIndex(function findRule(r) {
-        return reverse ? r.precedence >= json.eval_order : r.precedence > json.eval_order
-      })
-      if (insert === -1) {
-        this.rules.push(new NormalizerRule(json))
-      } else {
-        this.rules.splice(insert, 0, new NormalizerRule(json))
-      }
-    })
+    rules.name.forEach((name) => processNameRule(name, ctx))
   }
 
   if (rules && rules.ignore && rules.ignore.length > 0) {

package/lib/shim/datastore-shim.js

@@ -5,7 +5,7 @@
 
 'use strict'
 
-/* eslint sonarjs/cognitive-complexity: ["error", 52] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
+/* eslint sonarjs/cognitive-complexity: ["error", 57] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
 
 const dbutil = require('../db/utils')
 const hasOwnProperty = require('../util/properties').hasOwn
@@ -37,7 +37,8 @@ const DATASTORE_NAMES = {
   MYSQL: 'MySQL',
   NEPTUNE: 'Neptune',
   POSTGRES: 'Postgres',
-  REDIS: 'Redis'
+  REDIS: 'Redis',
+  PRISMA: 'Prisma'
 }
 
 /**
@@ -182,14 +183,14 @@ DatastoreShim.prototype.getDatabaseNameFromUseQuery = getDatabaseNameFromUseQuer
  *  used instead.
  * @property {DatastoreParameters} [parameters]
  *  Extra parameters to be set on the metric for the operation.
- * @property {bool} [record=true]
+ * @property {boolean} [record=true]
  *  Indicates if the operation should be recorded as a metric. A segment will be
  *  created even if this is `false`.
  * @property {number|CallbackBindFunction} [callback]
  *  If a number, it is the offset in the arguments array for the operation's
  *  callback argument. If it is a function, it should perform the segment
  *  binding to the callback.
- * @property {bool} [promise=false]
+ * @property {boolean} [promise=false]
  *  If `true`, the return value will be wrapped as a Promise.
  * @see DatastoreShim#recordOperation
  * @see QuerySpec
@@ -202,7 +203,7 @@ DatastoreShim.prototype.getDatabaseNameFromUseQuery = getDatabaseNameFromUseQuer
  * @description
  *  Describes the interface for a query function. Extends {@link OperationSpec}
  *  with query-specific parameters.
- * @property {bool} [stream=false]
+ * @property {boolean} [stream=false]
  *  If `true`, the return value will be wrapped as a stream.
  * @property {number|string|QueryFunction} query
  *  If a number, it is the offset in the arguments array for the query string
@@ -693,6 +694,7 @@ function _recordQuery(suffix, nodule, properties, querySpec) {
       promise: 'promise' in queryDesc ? queryDesc.promise : null,
       internal: 'internal' in queryDesc ? queryDesc.internal : true,
       opaque: 'opaque' in queryDesc ? queryDesc.opaque : false,
+      inContext: 'inContext' in queryDesc ? queryDesc.inContext : null,
       recorder: function queryRecorder(segment, scope) {
         if (segment) {
           parsed.recordMetrics(segment, scope)

package/lib/shim/shim.js

@@ -1443,7 +1443,7 @@ function isFunction(obj) {
  * @returns {bool} True if the object is a string, else false.
  */
 function isString(obj) {
-  return typeof obj === 'string'
+  return typeof obj === 'string' || obj instanceof String
 }
 
 /**

package/lib/symbols.js

@@ -18,6 +18,8 @@ module.exports = {
   onceExecuted: Symbol('onceExecuted'),
   offTheRecord: Symbol('offTheRecord'),
   original: Symbol('original'),
+  prismaConnection: Symbol('prismaConnection'),
+  prismaModelCall: Symbol('modelCall'),
   segment: Symbol('segment'),
   shim: Symbol('shim'),
   storeDatabase: Symbol('storeDatabase'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "9.10.2",
+  "version": "9.11.0",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "license": "Apache-2.0",
   "contributors": [
@@ -179,8 +179,8 @@
     "newrelic-naming-rules": "./bin/test-naming-rules.js"
   },
   "dependencies": {
-    "@grpc/grpc-js": "^1.8.7",
-    "@grpc/proto-loader": "^0.7.4",
+    "@grpc/grpc-js": "^1.8.8",
+    "@grpc/proto-loader": "^0.7.5",
     "@newrelic/aws-sdk": "^5.0.2",
     "@newrelic/koa": "^7.1.1",
     "@newrelic/superagent": "^6.0.0",