newrelic 13.2.0 → 13.3.0

package/lib/util/urltils.js

@@ -5,9 +5,17 @@
 
 'use strict'
 
-const url = require('url')
 const logger = require('../logger').child({ component: 'urltils' })
+/**
+ * Utility functions for enforcing New Relic naming conditions on URLs,
+ * and extracting and setting parameters on traces / web trace segments.
+ */
 
+/**
+ * Dictionary whose keys are all synonyms for localhost.
+ *
+ * @constant
+ */
 const LOCALHOST_NAMES = {
   localhost: true,
   '127.0.0.1': true,
@@ -19,214 +27,161 @@ const LOCALHOST_NAMES = {
 }
 
 /**
- * Utility functions for enforcing New Relic naming conditions on URLs,
- * and extracting and setting parameters on traces / web trace segments.
+ * Checks if the given name is in the dictionary of localhost names.
+ *
+ * @param {string} host - The hostname to lookup.
+ * @returns {boolean} - True if the given hostname is a synonym for localhost.
  */
-module.exports = {
-  /**
-   * Dictionary whose keys are all synonyms for localhost.
-   *
-   * @constant
-   */
-  LOCALHOST_NAMES,
+function isLocalhost(host) {
+  return LOCALHOST_NAMES[host] != null
+}
 
-  /**
-   * Checks if the given name is in the dictionary of localhost names.
-   *
-   * @param {string} host - The hostname to lookup.
-   * @returns {boolean} - True if the given hostname is a synonym for localhost.
-   */
-  isLocalhost: function isLocahost(host) {
-    return LOCALHOST_NAMES[host] != null
-  },
-
-  /**
-   * This was handed down from the prototype as the canonical list of status
-   * codes that short-circuit naming and normalization. The agent can be
-   * configured to mark HTTP status codes as not being errors.
-   *
-   * @param {Config} config The configuration containing the error list.
-   * @param {string} code   The HTTP status code to check.
-   * @returns {boolean} Whether the status code should be ignored.
-   */
-  isError: function isError(config, code) {
-    return code >= 400 && !isIgnoredStatusCodeForErrors(config, code)
-  },
-
-  /**
-   * Returns true if the status code is an HTTP error, and it is configured to be ignored.
-   *
-   * @param {Config} config The configuration containing the error list.
-   * @param {string} code   The HTTP status code to check.
-   * @returns {boolean} Whether the status code should be ignored.
-   */
-  isIgnoredError: function isIgnoredError(config, code) {
-    return code >= 400 && isIgnoredStatusCodeForErrors(config, code)
-  },
-
-  /**
-   * Returns true if the status code is configured to be expected
-   *
-   * @param {Config} config The configuration containing the error list.
-   * @param {string} code   The HTTP status code to check.
-   * @returns {boolean} Whether the status code is expected.
-   */
-  isExpectedError: function isExpectedError(config, code) {
-    return isExpectedStatusCodeForErrors(config, code)
-  },
-
-  /**
-   * Get back the pieces of the URL that New Relic cares about. Apply these
-   * restrictions, in order:
-   *
-   * 1. Ensure that after parsing the URL, there's at least '/'
-   * 2. Strip off session trackers after ';' (a New Relic convention)
-   * 3. Remove trailing slash.
-   *
-   * @param {string|url.URL} requestURL The URL fragment to be scrubbed.
-   * @returns {string} The cleaned URL.
-   */
-  scrub: function scrub(requestURL) {
-    if (typeof requestURL === 'string') {
-      requestURL = url.parse(requestURL)
-    }
+/**
+ * This was handed down from the prototype as the canonical list of status
+ * codes that short-circuit naming and normalization. The agent can be
+ * configured to mark HTTP status codes as not being errors.
+ *
+ * @param {Config} config The configuration containing the error list.
+ * @param {string} code   The HTTP status code to check.
+ * @returns {boolean} Whether the status code should be ignored.
+ */
+function isError(config, code) {
+  return code >= 400 && !isIgnoredStatusCodeForErrors(config, code)
+}
+
+/**
+ * Returns true if the status code is an HTTP error, and it is configured to be ignored.
+ *
+ * @param {Config} config The configuration containing the error list.
+ * @param {string} code   The HTTP status code to check.
+ * @returns {boolean} Whether the status code should be ignored.
+ */
+function isIgnoredError(config, code) {
+  return code >= 400 && isIgnoredStatusCodeForErrors(config, code)
+}
+
+/**
+ * Returns true if the status code is configured to be expected
+ *
+ * @param {Config} config The configuration containing the error list.
+ * @param {string} code   The HTTP status code to check.
+ * @returns {boolean} Whether the status code is expected.
+ */
+function isExpectedError(config, code) {
+  return isExpectedStatusCodeForErrors(config, code)
+}
 
-    let path = requestURL.pathname
+/**
+ * Get back the pieces of the URL that New Relic cares about. Apply these
+ * restrictions, in order:
+ *
+ * 1. Ensure that after parsing the URL, there's at least '/'
+ * 2. Strip off session trackers after ';' (a New Relic convention)
+ * 3. Remove trailing slash.
+ *
+ * @param {url.URL} requestURL The URL fragment to be scrubbed.
+ * @returns {string} The cleaned URL.
+ * @private
+ */
+function scrub(requestURL) {
+  let path = requestURL.pathname
 
-    if (path) {
-      path = path.split(';')[0]
+  if (path) {
+    path = path.split(';')[0]
 
-      if (path !== '/' && path.charAt(path.length - 1) === '/') {
-        path = path.substring(0, path.length - 1)
-      }
-    } else {
-      path = '/'
+    if (path !== '/' && path.charAt(path.length - 1) === '/') {
+      path = path.substring(0, path.length - 1)
     }
+  } else {
+    path = '/'
+  }
 
-    return path
-  },
-
-  /**
-   * Extract query parameters, dealing with bare parameters and parameters with
-   * no value as appropriate:
-   *
-   * 'var1&var2=value' is not necessarily the same as 'var1=&var2=value'
-   *
-   * In my world, one is an assertion of presence, and the other is an empty
-   * variable. Some web frameworks behave this way as well, so don't lose
-   * information.
-   *
-   * @param {string|url.URL} requestURL The URL to be parsed.
-   * @returns {object} The parameters parsed from the request
-   */
-  parseParameters: function parseParameters(requestURL) {
-    let parsed = requestURL
-    const parameters = Object.create(null)
-
-    function addParam(key, value, raw) {
-      if (value === '' && raw.indexOf(key + '=') === -1) {
+  return path
+}
+
+/**
+ * Extract query parameters, dealing with bare parameters and parameters with
+ * no value as appropriate:
+ *
+ * 'var1&var2=value' is not necessarily the same as 'var1=&var2=value'
+ *
+ * In my world, one is an assertion of presence, and the other is an empty
+ * variable. Some web frameworks behave this way as well, so don't lose
+ * information.
+ *
+ * @param {url.URL} requestURL The URL to be parsed.
+ * @returns {object} The parameters parsed from the request
+ * @private
+ */
+function parseParameters(requestURL) {
+  const parsed = requestURL
+  const parameters = Object.create(null)
+
+  if (parsed.searchParams) {
+    for (const [key, value] of parsed.searchParams) {
+      if (value === '' && parsed.search.indexOf(`?${key}=`) === -1 && parsed.search.indexOf(`&${key}=`) === -1) {
         parameters[key] = true
       } else {
         parameters[key] = value
       }
     }
+  }
 
-    if (typeof requestURL === 'string') {
-      parsed = url.parse(requestURL, true)
-    }
+  return parameters
+}
 
-    if (parsed.query) {
-      for (const key of Object.keys(parsed.query)) {
-        addParam(key, parsed.query[key], parsed.path || '')
-      }
-    }
+/**
+ * Performs the logic of `scrub` and `parseParameters` with
+ * only a single parse of the given URL.
+ *
+ * @param {url.URL} requestURL - The URL to scrub and extra parameters from.
+ * @returns {object} An object containing the scrubbed url at `.path` and the
+ *  parsed parameters at `.parameters` and `.protocol`.
+ */
+function scrubAndParseParameters(requestURL) {
+  return {
+    protocol: requestURL.protocol,
+    path: scrub(requestURL),
+    parameters: parseParameters(requestURL)
+  }
+}
 
-    if (parsed.searchParams) {
-      for (const [key, value] of parsed.searchParams) {
-        addParam(key, value, parsed.pathname || '')
-      }
-    }
+/**
+ * Obfuscates path parameters with regex from config
+ *
+ * @param {Config} config The configuration containing the regex
+ * @param {string} path The path to be obfuscated
+ * @returns {string} The obfuscated path or the original path
+ */
+function obfuscatePath(config, path) {
+  const { enabled, regex } = config.url_obfuscation
+  if (typeof path !== 'string' || !enabled || !regex) {
+    return path
+  }
 
-    return parameters
-  },
-
-  /**
-   * Performs the logic of `urltils.scrub` and `urltils.parseParameters` with
-   * only a single parse of the given URL.
-   *
-   * @param {string|url.URL} requestURL - The URL to scrub and extra parameters from.
-   * @returns {object} An object containing the scrubbed url at `.path` and the
-   *  parsed parameters at `.parameters`.
-   */
-  scrubAndParseParameters: function scrubAndParseParameters(requestURL) {
-    if (typeof requestURL === 'string') {
-      requestURL = url.parse(requestURL, true)
-    }
-    return {
-      protocol: requestURL.protocol,
-      path: this.scrub(requestURL),
-      parameters: this.parseParameters(requestURL)
-    }
-  },
-
-  /**
-   * Obfuscates path parameters with regex from config
-   *
-   * @param {Config} config The configuration containing the regex
-   * @param {string} path The path to be obfuscated
-   * @returns {string} The obfuscated path or the original path
-   */
-  obfuscatePath: function obfuscatePath(config, path) {
-    const { enabled, regex } = config.url_obfuscation
-    if (typeof path !== 'string' || !enabled || !regex) {
-      return path
-    }
+  const { pattern, flags = '', replacement = '' } = regex
+  try {
+    const regexPattern = new RegExp(pattern, flags)
+    return path.replace(regexPattern, replacement)
+  } catch {
+    logger.warn('Invalid regular expression for url_obfuscation.regex.pattern', pattern)
+    return path
+  }
+}
 
-    const { pattern, flags = '', replacement = '' } = regex
-    try {
-      const regexPattern = new RegExp(pattern, flags)
-      return path.replace(regexPattern, replacement)
-    } catch {
-      logger.warn('Invalid regular expression for url_obfuscation.regex.pattern', pattern)
-      return path
-    }
-  },
-
-  /**
-   * Copy a set of request parameters from one object to another,
-   * but do not overwrite any existing parameters in destination,
-   * including parameters set to null or undefined.
-   *
-   * @param {object} source      Parameters to be copied (not changed).
-   * @param {object} destination Dictionary to which parameters are copied
-   *                             (mutated in place).
-   */
-  copyParameters: function copyParameters(source, destination) {
-    if (source && destination) {
-      const keys = Object.keys(source)
-      for (let i = 0; i < keys.length; i++) {
-        const key = keys[i]
-        if (!(key in destination)) {
-          destination[key] = source[key]
-        }
-      }
-    }
-  },
-
-  /**
-   * Copy a set of request parameters from one object to another.
-   * Existing attributes on the `destination` will be overwritten.
-   *
-   * @param {object} source      Parameters to be copied (not changed).
-   * @param {object} destination Dictionary to which parameters are copied
-   *                             (mutated in place).
-   */
-  overwriteParameters: function overwriteParameters(source, destination) {
-    const keys = Object.keys(source)
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i]
-      destination[key] = source[key]
-    }
+/**
+ * Copy a set of request parameters from one object to another.
+ * Existing attributes on the `destination` will be overwritten.
+ *
+ * @param {object} source      Parameters to be copied (not changed).
+ * @param {object} destination Dictionary to which parameters are copied
+ *                             (mutated in place).
+ */
+function overwriteParameters(source, destination) {
+  const keys = Object.keys(source)
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i]
+    destination[key] = source[key]
   }
 }
 
@@ -245,3 +200,14 @@ function isExpectedStatusCodeForErrors(config, code) {
   }
   return codes.indexOf(parseInt(code, 10)) >= 0
 }
+
+module.exports = {
+  LOCALHOST_NAMES,
+  isLocalhost,
+  isError,
+  isIgnoredError,
+  isExpectedError,
+  scrubAndParseParameters,
+  obfuscatePath,
+  overwriteParameters
+}

package/lib/utilization/common.js

@@ -10,7 +10,6 @@ const http = require('http')
 const logger = require('../logger').child({ component: 'utilization-request' })
 const fs = require('../util/unwrapped-core').fs
 const properties = require('../util/properties')
-const url = require('url')
 
 exports.checkValueString = checkValueString
 function checkValueString(str) {
@@ -65,11 +64,6 @@ exports.getKeys = function getKeys(data, keys, allValuesMustBeValid = true) {
 
 exports.request = function request(opts, agent, cb) {
   // Add default timeout of a second to the request
-
-  if (typeof opts === 'string') {
-    opts = url.parse(opts)
-  }
-
   opts.timeout = opts.timeout || 1000
 
   // This can make more that GET requests if you pass in an object

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "13.2.0",
+  "version": "13.3.0",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "license": "Apache-2.0",
   "contributors": [
@@ -201,7 +201,7 @@
     "#test/assert": "./test/lib/custom-assertions/index.js"
   },
   "dependencies": {
-    "@apm-js-collab/code-transformer": "^0.6.0",
+    "@apm-js-collab/tracing-hooks": "^0.1.0",
     "@grpc/grpc-js": "^1.13.2",
     "@grpc/proto-loader": "^0.7.5",
     "@newrelic/security-agent": "^2.4.2",
@@ -272,8 +272,7 @@
     "self-cert": "^2.0.0",
     "should": "*",
     "sinon": "^5.1.1",
-    "superagent": "^9.0.1",
-    "testdouble": "^3.20.2"
+    "superagent": "^9.0.1"
   },
   "repository": {
     "type": "git",