newrelic 13.0.0 → 13.2.0

package/lib/config/index.js

@@ -44,28 +44,24 @@ const exists = fs.existsSync
 let logger = null // Lazy-loaded in `initialize`.
 let _configInstance = null
 
-const getConfigFileNames = () =>
-  [process.env.NEW_RELIC_CONFIG_FILENAME, 'newrelic.js', 'newrelic.cjs', 'newrelic.mjs'].filter(
-    Boolean
-  )
-
-const getConfigFileLocations = () =>
-  [
-    process.env.NEW_RELIC_HOME,
-    process.cwd(),
-    process.env.HOME,
-    path.join(__dirname, '../../../..'), // above node_modules
-    // the REPL has no main module
-    process.mainModule && process.mainModule.filename
-      ? path.dirname(process.mainModule.filename)
-      : undefined
-  ].filter(Boolean)
+const getConfigFileNames = () => [process.env.NEW_RELIC_CONFIG_FILENAME, 'newrelic.js', 'newrelic.cjs', 'newrelic.mjs'].filter(
+  Boolean
+)
+
+const getConfigFileLocations = () => [
+  process.env.NEW_RELIC_HOME,
+  process.cwd(),
+  process.env.HOME,
+  path.join(__dirname, '../../../..'), // above node_modules
+  // the REPL has no main module
+  process.mainModule && process.mainModule.filename
+    ? path.dirname(process.mainModule.filename)
+    : undefined
+].filter(Boolean)
 
 function _findConfigFile() {
   const configFileCandidates = getConfigFileLocations().reduce((files, configPath) => {
-    const configFiles = getConfigFileNames().map((filename) =>
-      path.join(path.resolve(configPath), filename)
-    )
+    const configFiles = getConfigFileNames().map((filename) => path.join(path.resolve(configPath), filename))
 
     return files.concat(configFiles)
   }, [])

package/lib/context-manager/context.js

@@ -6,9 +6,10 @@
 'use strict'
 
 module.exports = class Context {
-  constructor(transaction, segment) {
+  constructor({ transaction, segment, extras = {} } = {}) {
     this._transaction = transaction
     this._segment = segment
+    this._extras = extras
   }
 
   get segment() {
@@ -19,6 +20,14 @@ module.exports = class Context {
     return this._transaction
   }
 
+  get extras() {
+    return this._extras
+  }
+
+  set extras(extras) {
+    this._extras = { ...this._extras, ...extras }
+  }
+
   /**
    * Constructs a new context from segment about to be bound to context manager
    * along with the current transaction.
@@ -28,8 +37,8 @@ module.exports = class Context {
    * @param {Transaction} params.transaction active transaction
    * @returns {Context} a newly constructed context
    */
-  enterSegment({ segment, transaction = this._transaction }) {
-    return new this.constructor(transaction, segment)
+  enterSegment({ segment, transaction = this.transaction }) {
+    return new this.constructor({ transaction, segment, extras: this.extras })
   }
 
   /**
@@ -40,6 +49,6 @@ module.exports = class Context {
    * @returns {Context} a newly constructed context
    */
   enterTransaction(transaction) {
-    return new this.constructor(transaction, transaction?.trace?.root)
+    return new this.constructor({ transaction, segment: transaction?.trace?.root, extras: this.extras })
   }
 }

package/lib/harvester.js

@@ -34,20 +34,18 @@ module.exports = class Harvester {
    */
   clear(callback) {
     Promise.all(
-      this.aggregators.map((aggregator) => {
-        return new Promise((resolve) => {
-          if (aggregator.enabled) {
-            aggregator.once(`finished_data_send-${aggregator.method}`, function finish() {
-              resolve()
-            })
-
-            aggregator.send()
-          } else {
-            // No data to flush because aggregator is not enabled
+      this.aggregators.map((aggregator) => new Promise((resolve) => {
+        if (aggregator.enabled) {
+          aggregator.once(`finished_data_send-${aggregator.method}`, function finish() {
             resolve()
-          }
-        })
-      })
+          })
+
+          aggregator.send()
+        } else {
+          // No data to flush because aggregator is not enabled
+          resolve()
+        }
+      }))
     ).then(() => {
       // Get out of the promise so callback errors aren't treated as
       // promise rejections.

package/lib/instrumentation/@google/genai.js

@@ -196,7 +196,9 @@ module.exports = function initialize(agent, googleGenAi, moduleName, shim) {
 
   // Instruments chat completion creation
   // and creates the LLM events
-  shim.record(models.prototype, 'generateContentInternal',
+  shim.record(
+    models.prototype,
+    'generateContentInternal',
     function wrapGenerateContent(shim, func, name, args) {
       const [request] = args
 
@@ -222,7 +224,9 @@ module.exports = function initialize(agent, googleGenAi, moduleName, shim) {
 
   // Instruments chat completion streaming
   // and creates the LLM events
-  shim.record(models.prototype, 'generateContentStreamInternal',
+  shim.record(
+    models.prototype,
+    'generateContentStreamInternal',
     function wrapGenerateContentStream(shim, func, name, args) {
       if (!agent.config.ai_monitoring.streaming.enabled) {
         shim.logger.warn(
@@ -241,7 +245,8 @@ module.exports = function initialize(agent, googleGenAi, moduleName, shim) {
           addLlmMeta({ agent, transaction })
         }
       })
-    })
+    }
+  )
 
   // Instruments embedding creation
   // and creates LlmEmbedding event

package/lib/instrumentation/@hapi/hapi.js

@@ -204,12 +204,10 @@ function wrapPreHandlers(shim, container, path) {
 }
 
 function wrapPreHandler(shim, container, path) {
-  return shim.record(container, (shim) => {
-    return new SegmentSpec({
-      name: [shim.HAPI, ' pre handler: ', '(', path, ')'].join(''),
-      recorder: record
-    })
-  })
+  return shim.record(container, (shim) => new SegmentSpec({
+    name: [shim.HAPI, ' pre handler: ', '(', path, ')'].join(''),
+    recorder: record
+  }))
 }
 
 function wrapRouteHandler(shim, handler, path) {

package/lib/instrumentation/@nestjs/core.js

@@ -18,20 +18,18 @@ module.exports = function initialize(agent, core, moduleName, shim) {
     return
   }
 
-  shim.wrap(core.BaseExceptionFilter.prototype, 'handleUnknownError', (shim, original) => {
-    return function wrappedHandleUnknownError(exception) {
-      const transaction = shim.tracer.getTransaction()
-      if (transaction) {
-        shim.agent.errors.add(transaction, exception)
-        logger.trace(exception, 'Captured error handled by Nest.js exception filter.')
-      } else {
-        logger.trace(
-          exception,
-          'Ignoring error handled by Nest.js exception filter: not in a transaction'
-        )
-      }
-
-      return original.apply(this, arguments)
+  shim.wrap(core.BaseExceptionFilter.prototype, 'handleUnknownError', (shim, original) => function wrappedHandleUnknownError(exception) {
+    const transaction = shim.tracer.getTransaction()
+    if (transaction) {
+      shim.agent.errors.add(transaction, exception)
+      logger.trace(exception, 'Captured error handled by Nest.js exception filter.')
+    } else {
+      logger.trace(
+        exception,
+        'Ignoring error handled by Nest.js exception filter: not in a transaction'
+      )
     }
+
+    return original.apply(this, arguments)
   })
 }

package/lib/instrumentation/aws-sdk/v3/bedrock.js

@@ -204,7 +204,7 @@ function recordEmbeddingMessage({
     return
   }
 
-  const embeddings = bedrockCommand.prompt.map(prompt => new LlmEmbedding({
+  const embeddings = bedrockCommand.prompt.map((prompt) => new LlmEmbedding({
     agent,
     segment,
     transaction,
@@ -214,7 +214,7 @@ function recordEmbeddingMessage({
     isError: err !== null
   }))
 
-  embeddings.forEach(embedding => {
+  embeddings.forEach((embedding) => {
     recordEvent({ agent, type: 'LlmEmbedding', msg: embedding })
   })
 

package/lib/instrumentation/core/http-outbound.js

@@ -11,7 +11,6 @@ const urltils = require('../../util/urltils')
 const logger = require('../../logger').child({ component: 'outbound' })
 const shimmer = require('../../shimmer')
 const url = require('url')
-const copy = require('../../util/copy')
 const symbols = require('../../symbols')
 const synthetics = require('../../synthetics')
 const { URL } = require('node:url')
@@ -57,24 +56,6 @@ function getDefaultHostName(opts) {
   return opts.hostname || opts.host || DEFAULT_HOST
 }
 
-/**
- * Parses http opts to an object
- * If string will call url.parse, otherwise it will
- * do a shallow copy
- *
- * @param {string|object} opts a url string or HTTP request options
- * @returns {object} parsed http opts
- */
-function parseOpts(opts) {
-  if (typeof opts === 'string') {
-    opts = url.parse(opts)
-  } else {
-    opts = copy.shallow(opts)
-  }
-
-  return opts
-}
-
 /**
  * Extracts host, hostname, port from http request options
  *
@@ -122,8 +103,6 @@ function extractHostPortViaProxy(opts) {
  * @returns {object} The instrumented outbound HTTP request.
  */
 module.exports = function instrumentOutbound(agent, opts, makeRequest) {
-  opts = parseOpts(opts)
-
   const viaProxy = extractHostPortViaProxy(opts)
   const { host, hostname, port } = viaProxy ? viaProxy : extractHostPort(opts)
 
@@ -265,23 +244,29 @@ function assignOutgoingHeaders(currentHeaders, outboundHeaders) {
 function applySegment({ opts, makeRequest, host, port, hostname, segment, config }) {
   segment.start()
   const request = makeRequest(opts)
-  const parsed = urltils.scrubAndParseParameters(request.path)
-  parsed.path = urltils.obfuscatePath(config, parsed.path)
+
+  // Attempt to parse into new URL.
+  // If no href, revert to url.parse.
+  // Rarely, the href doesn't contain the
+  // path, so we have to use url.parse to get the path.
+  const urlObject = (opts?.href?.includes(request.path)) ? new URL(opts.href) : url.parse(request.path, true)
+  const parsed = urltils.scrubAndParseParameters(urlObject)
+  const obfuscatedPath = urltils.obfuscatePath(config, parsed.path)
+
   const proto = parsed.protocol || opts.protocol || 'http:'
-  segment.name += parsed.path
+  segment.name += obfuscatedPath
   segment.captureExternalAttributes({
     protocol: proto,
     hostname,
     host,
     method: opts.method,
     port,
-    path: parsed.path,
+    path: obfuscatedPath,
     queryParams: parsed.parameters
   })
   request[symbols.segment] = segment
   return request
 }
-
 /**
  * Wrap the emit method. We're doing a special wrapper instead of using
  * `tracer.bindEmitter` because we want to do some logic based on certain

package/lib/instrumentation/kafkajs/producer.js

@@ -42,15 +42,13 @@ function nrSend(shim, fn, name, args) {
     promise: true,
     destinationName: data.topic,
     destinationType: shim.TOPIC,
-    messageHeaders: (inject) => {
-      return data.messages.map((msg) => {
-        if (msg.headers) {
-          return inject(msg.headers)
-        }
-        msg.headers = {}
+    messageHeaders: (inject) => data.messages.map((msg) => {
+      if (msg.headers) {
         return inject(msg.headers)
-      })
-    }
+      }
+      msg.headers = {}
+      return inject(msg.headers)
+    })
   })
 }
 
@@ -74,16 +72,12 @@ function nrSendBatch(shim, fn, name, args) {
     promise: true,
     destinationName: data.topicMessages[0].topic,
     destinationType: shim.TOPIC,
-    messageHeaders: (inject) => {
-      return data.topicMessages.map((tm) => {
-        return tm.messages.map((m) => {
-          if (m.headers) {
-            return inject(m.headers)
-          }
-          m.headers = {}
-          return inject(m.headers)
-        })
-      })
-    }
+    messageHeaders: (inject) => data.topicMessages.map((tm) => tm.messages.map((m) => {
+      if (m.headers) {
+        return inject(m.headers)
+      }
+      m.headers = {}
+      return inject(m.headers)
+    }))
   })
 }

package/lib/instrumentation/openai.js

@@ -64,13 +64,13 @@ function getMessagesFromRequest(request, shim) {
 
   if (Array.isArray(request?.input)) {
     // Handle array of input messages
-    messages = request.input.filter(msg => msg?.content && msg?.role)
+    messages = request.input.filter((msg) => msg?.content && msg?.role)
   } else if (typeof request?.input === 'string') {
     // Handle single string input as a user message
     messages = [{ content: request.input, role: 'user' }]
   } else if (Array.isArray(request?.messages)) {
     // Handle array of messages
-    messages = request.messages.filter(msg => msg?.content && msg?.role)
+    messages = request.messages.filter((msg) => msg?.content && msg?.role)
   } else {
     shim.logger.warn('No valid messages found in OpenAI request object.')
   }

package/lib/instrumentation/undici.js

@@ -9,7 +9,6 @@ const cat = require('../util/cat')
 const recordExternal = require('../metrics/recorders/http_external')
 const logger = require('../logger').child({ component: 'undici' })
 const NAMES = require('../metrics/names')
-const symbols = require('../symbols')
 // eslint-disable-next-line n/no-unsupported-features/node-builtins
 const diagnosticsChannel = require('diagnostics_channel')
 const synthetics = require('../synthetics')
@@ -27,13 +26,10 @@ const channels = [
  * See: https://github.com/nodejs/undici/blob/main/docs/api/DiagnosticsChannel.md
  *
  * @param agent
- * @param _undici
- * @param _modName
- * @param shim
  */
-module.exports = function addUndiciChannels(agent, _undici, _modName, shim) {
+module.exports = function addUndiciChannels(agent) {
   channels.forEach(({ channel, hook }, index) => {
-    const boundHook = hook.bind(null, shim)
+    const boundHook = hook.bind(null, agent)
     diagnosticsChannel.subscribe(channel, boundHook)
     // store the bound hook for unsubscription later
     channels[index].boundHook = boundHook
@@ -75,18 +71,25 @@ function addDTHeaders({ transaction, config, request }) {
  * Creates the external segment with url, procedure and request.parameters attributes
  *
  * @param {object} params object to fn
- * @param {Shim} params.shim instance of shim
- * @param {object} params.request undici request object
- * @param {TraceSegment} params.segment current active, about to be parent of external segment
+ * @param {Agent} params.agent NR agent instance
+ * @param {object} params.context active context
+ * @param params.request
  */
-function createExternalSegment({ shim, request, segment }) {
+function createExternalSegment({ agent, request, context }) {
   const url = new URL(request.origin + request.path)
-  const obfuscatedPath = urltils.obfuscatePath(shim.agent.config, url.pathname)
+  const obfuscatedPath = urltils.obfuscatePath(agent.config, url.pathname)
   const name = NAMES.EXTERNAL.PREFIX + url.host + obfuscatedPath
+  const transaction = context?.transaction
+  const parent = context?.extras?.undiciParent
   // Metrics for `External/<host>` will have a suffix of undici
   // We will have to see if this matters for people only using fetch
   // It's undici under the hood so ¯\_(ツ)_/¯
-  const externalSegment = shim.createSegment(name, recordExternal(url.host, 'undici'), segment)
+  const externalSegment = agent.tracer.createSegment({
+    name,
+    recorder: recordExternal(url.host, 'undici'),
+    parent,
+    transaction
+  })
 
   // the captureExternalAttributes expects queryParams to be an object, do conversion
   // to object see:  https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams
@@ -94,7 +97,11 @@ function createExternalSegment({ shim, request, segment }) {
 
   if (externalSegment) {
     externalSegment.start()
-    shim.setActiveSegment(externalSegment)
+    // storing the undici external segment in the context extras
+    // this has to be done because the various hook points produce different segments
+    // and we need to be able to access the segment later
+    context.extras = { undiciSegment: externalSegment }
+    agent.tracer.setSegment({ segment: externalSegment, transaction })
     externalSegment.captureExternalAttributes({
       protocol: url.protocol,
       hostname: url.hostname,
@@ -104,8 +111,6 @@ function createExternalSegment({ shim, request, segment }) {
       path: obfuscatedPath,
       queryParams
     })
-
-    request[symbols.segment] = externalSegment
   }
 }
 
@@ -115,15 +120,18 @@ function createExternalSegment({ shim, request, segment }) {
  * external segment with the standard url/procedure/request.parameters
  * attributes.  We will also attach relevant DT headers to outgoing http request.
  *
- * @param {Shim} shim instance of shim
+ * @param {Agent} agent NR agent instance
  * @param {object} params object from undici hook
  * @param {object} params.request undici request object
  */
-function requestCreateHook(shim, { request }) {
-  const { config } = shim.agent
-  const { transaction, segment } = shim.tracer.getContext()
-  request[symbols.parentSegment] = segment
-  request[symbols.transaction] = transaction
+function requestCreateHook(agent, { request }) {
+  const { config } = agent
+  const context = agent.tracer.getContext()
+  const { segment, transaction } = context
+  // storing the parent of the undici external segment in the context extras
+  // this has to be done because the various hook points produce different segments
+  // and we need to be able to access the segment later
+  context.extras = { undiciParent: segment }
   if (!(segment || transaction) || segment?.opaque) {
     logger.trace(
       'Not capturing data for outbound request (%s) because parent segment opaque (%s)',
@@ -135,7 +143,7 @@ function requestCreateHook(shim, { request }) {
   }
 
   try {
-    createExternalSegment({ shim, request, segment })
+    createExternalSegment({ agent, request, context })
     addDTHeaders({ transaction, config, request })
   } catch (err) {
     logger.warn(err, 'Unable to create external segment')
@@ -147,15 +155,15 @@ function requestCreateHook(shim, { request }) {
  * We will add the relevant http response attributes to active segment.
  * Also add CAT specific keys to active segment.
  *
- * @param {Shim} shim instance of shim
+ * @param {object} agent
  * @param {object} params object from undici hook
- * @param {object} params.request undici request object
  * @param {object} params.response { statusCode, headers, statusText }
  */
-function requestHeadersHook(shim, { request, response }) {
-  const { config } = shim.agent
-  const activeSegment = request[symbols.segment]
-  const transaction = request[symbols.transaction]
+function requestHeadersHook(agent, { response }) {
+  const { config } = agent
+  const context = agent.tracer.getContext()
+  const activeSegment = context?.extras?.undiciSegment
+  const transaction = context?.transaction
   if (!activeSegment) {
     return
   }
@@ -185,37 +193,37 @@ function requestHeadersHook(shim, { request, response }) {
  * Gets the active segment, parent segment and transaction from given ctx(request, client connector)
  * and ends segment and sets the previous parent segment as the active segment.  If an error exists it will add the error to the transaction
  *
- * @param {Shim} shim instance of shim
+ * @param {Agent} agent NR agent instance
  * @param {object} params object from undici hook
- * @param {object} params.request or client connector
  * @param {Error} params.error error from undici request
  */
-function endAndRestoreSegment(shim, { request, error }) {
-  const { config } = shim.agent
-  const activeSegment = request[symbols.segment]
-  const parentSegment = request[symbols.parentSegment]
-  const tx = request[symbols.transaction]
+function endAndRestoreSegment(agent, { error }) {
+  const { config } = agent
+  const context = agent.tracer.getContext()
+  const activeSegment = context?.extras?.undiciSegment
+  const parentSegment = context?.extras?.undiciParent
+  const tx = context?.transaction
   if (activeSegment) {
     activeSegment.end()
   }
 
   if (error && tx && config.feature_flag.undici_error_tracking === true) {
-    handleError(shim, tx, error)
+    handleError(agent, tx, error)
   }
 
   if (parentSegment) {
-    shim.setActiveSegment(parentSegment)
+    agent.tracer.setSegment({ segment: parentSegment, transaction: tx })
   }
 }
 
 /**
  * Adds the error to the active transaction
  *
- * @param {Shim} shim instance of shim
+ * @param {Agent} agent NR agent instance
  * @param {Transaction} tx active transaction
  * @param {Error} error error from undici request
  */
-function handleError(shim, tx, error) {
+function handleError(agent, tx, error) {
   logger.trace(error, 'Captured outbound error on behalf of the user.')
-  shim.agent.errors.add(tx, error)
+  agent.errors.add(tx, error)
 }

package/lib/instrumentations.js

@@ -11,8 +11,6 @@ const InstrumentationDescriptor = require('./instrumentation-descriptor')
 module.exports = function instrumentations() {
   return {
     '@azure/functions': { type: InstrumentationDescriptor.TYPE_GENERIC },
-    '@elastic/elasticsearch': { type: InstrumentationDescriptor.TYPE_DATASTORE },
-    '@opensearch-project/opensearch': { type: InstrumentationDescriptor.TYPE_DATASTORE },
     '@google/genai': { type: InstrumentationDescriptor.TYPE_GENERIC },
     '@grpc/grpc-js': { module: './instrumentation/grpc-js' },
     '@hapi/hapi': { type: InstrumentationDescriptor.TYPE_WEB_FRAMEWORK },
@@ -30,7 +28,6 @@ module.exports = function instrumentations() {
     express: { type: InstrumentationDescriptor.TYPE_WEB_FRAMEWORK },
     fastify: { type: InstrumentationDescriptor.TYPE_WEB_FRAMEWORK },
     'generic-pool': { type: InstrumentationDescriptor.TYPE_GENERIC },
-    ioredis: { type: InstrumentationDescriptor.TYPE_DATASTORE },
     kafkajs: { type: InstrumentationDescriptor.TYPE_MESSAGE },
     koa: { module: './instrumentation/koa' },
     langchain: { module: './instrumentation/langchain' },
@@ -40,7 +37,6 @@ module.exports = function instrumentations() {
     next: { module: './instrumentation/nextjs' },
     openai: { type: InstrumentationDescriptor.TYPE_GENERIC },
     pg: { type: InstrumentationDescriptor.TYPE_DATASTORE },
-    pino: { module: './instrumentation/pino' },
     q: { type: null },
     redis: { type: InstrumentationDescriptor.TYPE_DATASTORE },
     restify: { type: InstrumentationDescriptor.TYPE_WEB_FRAMEWORK },
@@ -62,6 +58,19 @@ module.exports = function instrumentations() {
     'fancy-log': { type: InstrumentationDescriptor.TYPE_TRACKING },
     knex: { type: InstrumentationDescriptor.TYPE_TRACKING },
     loglevel: { type: InstrumentationDescriptor.TYPE_TRACKING },
-    npmlog: { type: InstrumentationDescriptor.TYPE_TRACKING }
+    npmlog: { type: InstrumentationDescriptor.TYPE_TRACKING },
+
+    /**
+     * The modules below are listed here is a temporary solution to maintaining
+     * the Supportability/Features/onRequire/<module> metrics for libraries
+     * that have been migrated to use tracing chanel instrumentation.
+     * Once orchestrion can emit the package version, these can be removed.
+     * {@link https://github.com/newrelic/node-newrelic/issues/3308 Github Issue}
+     */
+    '@elastic/elasticsearch': { type: InstrumentationDescriptor.TYPE_TRACKING },
+    '@modelcontextprotocol/sdk/client/index.js': { type: InstrumentationDescriptor.TYPE_TRACKING },
+    '@opensearch-project/opensearch': { type: InstrumentationDescriptor.TYPE_TRACKING },
+    ioredis: { type: InstrumentationDescriptor.TYPE_TRACKING },
+    pino: { type: InstrumentationDescriptor.TYPE_TRACKING }
   }
 }

package/lib/llm-events/aws-bedrock/utils.js

@@ -56,7 +56,7 @@ function stringifyConverseChunkedMessage(chunks) {
       return `<tool_result>${
           stringifyConverseChunkedMessage(
             (chunk.toolResult.content ?? [])
-              .filter(subChunk => !('toolUse' in subChunk || 'toolResult' in subChunk))
+              .filter((subChunk) => !('toolUse' in subChunk || 'toolResult' in subChunk))
             )
         }</tool_result>`
     } else if ('guardContent' in chunk) {

package/lib/metrics/names.js

@@ -199,6 +199,13 @@ AI.LANGCHAIN = {
   VECTORSTORE: `${AI.VECTORSTORE}/Langchain`
 }
 
+const MCP = {
+  TRACKING_PREFIX: `${AI.TRACKING_PREFIX}/MCP`,
+  TOOL: `${AI.TOOL}/MCP`,
+  RESOURCE: 'Llm/resource/MCP',
+  PROMPT: 'Llm/prompt/MCP'
+}
+
 const RESTIFY = {
   PREFIX: 'Restify/'
 }
@@ -380,6 +387,7 @@ module.exports = {
   KAFKA,
   LOOP,
   LOGGING,
+  MCP,
   MEMCACHE,
   MEMORY,
   MESSAGE_TRANSACTION,

package/lib/metrics/normalizer.js

@@ -109,9 +109,7 @@ MetricNormalizer.prototype.load = function load(json) {
     /* I (FLN) always forget this, so making a note: JS sort is always
      * IN-PLACE, even though it returns the sorted array.
      */
-    this.rules.sort((a, b) => {
-      return a.precedence - b.precedence
-    })
+    this.rules.sort((a, b) => a.precedence - b.precedence)
 
     logger.debug('Loaded %s %s normalization rule(s).', this.rules.length, this.type)
   }