newrelic 9.7.0 → 9.7.2

package/lib/util/code-level-metrics.js

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2022 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+const logger = require('../logger').child({ component: 'code-level-metrics' })
+const { isValidLength } = require('./byte-limit')
+const symbols = require('../symbols')
+
+/**
+ * Uses function name if truthy
+ * otherwise it defaults to (anonymous)
+ *
+ * @param {string} name name of function
+ * @returns {string} function name or (anonymous)
+ */
+function setFunctionName(name) {
+  return name || '(anonymous)'
+}
+
+/**
+ * Helper used to assign Code Level Metrics(CLM)
+ * to an active segment.
+ *
+ * spec states if function or filepath are > 255, do not assign
+ * CLM attrs
+ *
+ * @param {Function} fn function reference
+ * @param {TraceSegment} segment active segment to attach code.* attrs
+ */
+module.exports = function addCLMAttributes(fn, segment) {
+  if (!fn[symbols.clm]) {
+    return
+  }
+
+  try {
+    const { funcInfo } = require('@contrast/fn-inspect')
+    const { lineNumber, method, file: filePath, column } = funcInfo(fn)
+    const fnName = setFunctionName(method)
+
+    if (isValidLength(fnName, 255) && isValidLength(filePath, 255)) {
+      segment.addAttribute('code.filepath', filePath)
+      segment.addAttribute('code.function', fnName)
+      // both line numbers and columns start at 0 in v8, add 1 to reflect js code
+      // See: https://v8.github.io/api/head/classv8_1_1Function.html#a87bc63f97a9a39f83051570519fc63c2
+      segment.addAttribute('code.lineno', lineNumber + 1)
+      segment.addAttribute('code.column', column + 1)
+    }
+  } catch (err) {
+    logger.infoOnce({ err }, 'Not using v8 function inspector, falling back to function name')
+    const fnName = setFunctionName(fn.name)
+
+    if (isValidLength(fnName, 255)) {
+      segment.addAttribute('code.function', fnName)
+    }
+  }
+}

package/lib/util/deep-equal.js

@@ -5,152 +5,19 @@
 
 'use strict'
 
-/* eslint sonarjs/cognitive-complexity: ["error", 35] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
+const util = require('util')
 
-function isArguments(object) {
-  return Object.prototype.toString.call(object) === '[object Arguments]'
-}
-
-function slice(args) {
-  // Array.prototype.slice on arguments array-like is expensive
-  const l = args.length
-  const a = []
-  let i
-  for (i = 0; i < l; i++) {
-    a[i] = args[i]
-  }
-  return a
-}
-
-/**
- * This is a node-specific version of deepEquals, modeled on bits and pieces
- * of loads of other implementations of this algorithm, most notably the
- * one in the Node.js source and Underscore's. It doesn't throw and handles
- * cycles.
- *
- * Everybody who writes one of these functions puts the documentation
- * inline, which makes it incredibly hard to follow. Here's what this version
- * of the algorithm does, in order:
- *
- * 1. === only tests objects and and functions by reference. Null is an object.
- *    Any pair of identical entities failing this test are therefore objects
- *    (including null), which need a recursive compare by attribute.
- * 2. Since the only matching entities to get to this test must be objects, if
- *    a or b is not an object, they're clearly not the same. All unfiltered a
- *    and b getting are objects (including null).
- * 3. null is an object, but null === null. All unfiltered a and b are non-null
- *    objects.
- * 4. Buffers need to be special-cased because they live partially on the wrong
- *    side of the C++ / JavaScript barrier. Still, calling this on structures
- *    that can contain Buffers is a bad idea, because they can contain
- *    multiple megabytes of data and comparing them byte-by-byte is very
- *    expensive. buffertools is a better solution here, but this version of
- *    this code is dependency free.
- * 5. It's much faster to compare dates by numeric value than by lexical value.
- * 6. Same goes for Regexps.
- * 7. The parts of an arguments list most people care about are the arguments
- *    themselves, not the callee, which you shouldn't be looking at anyway.
- * 8. Objects are more complex:
- *    a. ensure that a and b are on the same constructor chain
- *    b. ensure that a and b have the same number of own properties (which is
- *       what Object.keys returns).
- *    c. ensure that cyclical references don't blow up the stack.
- *    d. ensure that all the key names match (faster)
- *    e. ensure that all of the associated values match, recursively (slower)
- *
- * (SOMEWHAT UNTESTED) ASSUMPTIONS:
- *
- * o Functions are only considered identical if they unify to the same
- *   reference. To anything else is to invite the wrath of the halting problem.
- * o V8 is smart enough to optimize treating an Array like any other kind of
- *   object.
- * o Users of this function are cool with mutually recursive data structures
- *   that are otherwise identical being treated as the same.
- *
- * @param a
- * @param b
- * @param ca
- * @param cb
- */
-function deeper(a, b, ca, cb) {
-  if (a === b) {
-    return true
-  } else if (typeof a !== 'object' || typeof b !== 'object') {
-    return false
-  } else if (a === null || b === null) {
-    return false
-  } else if (Buffer.isBuffer(a) && Buffer.isBuffer(b)) {
-    if (a.length !== b.length) {
-      return false
-    }
-
-    // potentially incredibly expensive
-    for (let i = 0; i < a.length; i++) {
-      if (a[i] !== b[i]) {
-        return false
-      }
-    }
-
-    return true
-  } else if (a instanceof Date && b instanceof Date) {
-    return a.getTime() === b.getTime()
-  } else if (a instanceof RegExp && b instanceof RegExp) {
-    return (
-      a.source === b.source &&
-      a.global === b.global &&
-      a.multiline === b.multiline &&
-      a.lastIndex === b.lastIndex &&
-      a.ignoreCase === b.ignoreCase
-    )
-  } else if (isArguments(a) || isArguments(b)) {
-    if (!(isArguments(a) && isArguments(b))) {
-      return false
-    }
-
-    return deeper(slice(a), slice(b), ca, cb)
-  }
-
-  if (a.constructor !== b.constructor) {
-    return false
-  }
-
-  const ka = Object.keys(a)
-  const kb = Object.keys(b)
-  if (ka.length !== kb.length) {
+module.exports = function exports(a, b) {
+  /*
+   * NaN is a special case, util.isDeepStrictEqual will return true for comparing two NaNs,
+   * but comparing a NaN to itself like this returns false (yay for weird JS stuff)
+   *
+   * Added this special check because the original implementation of this
+   * did not consider two NaNs as equal, so preserving existing functionality
+   */
+  if (a !== a && b !== b) {
     return false
   }
 
-  let cal = ca.length
-  while (cal--) {
-    if (ca[cal] === a) {
-      return cb[cal] === b
-    }
-  }
-  ca.push(a)
-  cb.push(b)
-
-  ka.sort()
-  kb.sort()
-  for (let j = ka.length - 1; j >= 0; j--) {
-    if (ka[j] !== kb[j]) {
-      return false
-    }
-  }
-
-  let key
-  for (let k = ka.length - 1; k >= 0; k--) {
-    key = ka[k]
-    if (!deeper(a[key], b[key], ca, cb)) {
-      return false
-    }
-  }
-
-  ca.pop()
-  cb.pop()
-
-  return true
-}
-
-module.exports = function exports(a, b) {
-  return deeper(a, b, [], [])
+  return util.isDeepStrictEqual(a, b)
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "9.7.0",
+  "version": "9.7.2",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "license": "Apache-2.0",
   "contributors": [
@@ -178,8 +178,8 @@
     "newrelic-naming-rules": "./bin/test-naming-rules.js"
   },
   "dependencies": {
-    "@grpc/grpc-js": "^1.5.5",
-    "@grpc/proto-loader": "^0.6.13",
+    "@grpc/grpc-js": "^1.7.3",
+    "@grpc/proto-loader": "^0.7.3",
     "@newrelic/aws-sdk": "^5.0.0",
     "@newrelic/koa": "^7.0.0",
     "@newrelic/superagent": "^6.0.0",
@@ -192,7 +192,8 @@
     "winston-transport": "^4.5.0"
   },
   "optionalDependencies": {
-    "@newrelic/native-metrics": "^9.0.0"
+    "@newrelic/native-metrics": "^9.0.0",
+    "@contrast/fn-inspect": "^3.3.0"
   },
   "devDependencies": {
     "@newrelic/eslint-config": "^0.2.0",