newrelic 8.0.0 → 8.4.0

package/lib/util/cat.js

@@ -5,59 +5,296 @@
 
 'use strict'
 
+const cat = module.exports
 const hashes = require('./hashes')
-const logger = require('../logger').child({component: 'cat'})
+const logger = require('../logger').child({ component: 'cat' })
+const NAMES = require('../metrics/names')
 
-module.exports.handleCatHeaders = handleCatHeaders
-module.exports.parsedHeadersToTrans = parsedHeadersToTrans
+const HTTP_CAT_ID_HEADER = 'X-NewRelic-Id'
+const MQ_CAT_ID_HEADER = 'NewRelicID'
+const MATCH_CAT_ID_HEADER = new RegExp(
+  '^(?:' + HTTP_CAT_ID_HEADER + '|' + MQ_CAT_ID_HEADER + ')$',
+  'i'
+)
+const HTTP_CAT_TRANSACTION_HEADER = 'X-NewRelic-Transaction'
+const MQ_CAT_TRANSACTION_HEADER = 'NewRelicTransaction'
+const MATCH_CAT_TRANSACTION_HEADER = new RegExp(
+  '^(?:' + HTTP_CAT_TRANSACTION_HEADER + '|' + MQ_CAT_TRANSACTION_HEADER + ')$',
+  'i'
+)
+const HTTP_CAT_APP_DATA_HEADER = 'X-NewRelic-App-Data'
+const MQ_CAT_APP_DATA_HEADER = 'NewRelicAppData'
+const MATCH_CAT_APP_DATA_HEADER = new RegExp(
+  '^(?:' + HTTP_CAT_APP_DATA_HEADER + '|' + MQ_CAT_APP_DATA_HEADER + ')$',
+  'i'
+)
 
-function handleCatHeaders(incomingCatId, obfTransaction, encKey, transaction) {
-  var parsedCatId = null
-  if (incomingCatId) {
-    parsedCatId = hashes.deobfuscateNameUsingKey(
-      incomingCatId,
-      encKey
-    )
+/**
+ * Decodes the CAT id and transaction headers from incoming request
+ *
+ * @param {Object} headers incoming headers
+ * @param {string} encKey config.encoding_key used to decode CAT headers
+ * @param {Object} { externalId, externalTransaction }
+ */
+cat.parseCatData = function parseCatData(id, transactionId, encKey) {
+  if (!encKey) {
+    logger.warn('Missing encoding key, not extract CAT headers!')
+    return {}
+  }
+
+  let externalId = null
+
+  if (id) {
+    externalId = hashes.deobfuscateNameUsingKey(id, encKey)
   }
 
-  var externalTrans = null
-  if (obfTransaction) {
+  let externalTransaction = null
+  if (transactionId) {
     try {
-      externalTrans = JSON.parse(
-        hashes.deobfuscateNameUsingKey(obfTransaction, encKey)
-      )
+      externalTransaction = JSON.parse(hashes.deobfuscateNameUsingKey(transactionId, encKey))
     } catch (e) {
-      logger.trace(
-        'Got an unparsable CAT header x-newrelic-transaction: %s',
-        obfTransaction
-      )
+      logger.trace(`Got an unparsable CAT header ${HTTP_CAT_ID_HEADER} %s`, transactionId)
     }
   }
 
-  parsedHeadersToTrans(parsedCatId, externalTrans, transaction)
+  return { externalId, externalTransaction }
 }
 
-function parsedHeadersToTrans(parsedCatId, externalTrans, transaction) {
-  if (typeof parsedCatId === 'string') {
-    transaction.incomingCatId = parsedCatId
+/**
+ * Adds the appropriate keys to transaction based on the incoming parsed CAT data
+ *
+ * @param {string} externalId decoded CAT id
+ * @param {Array} externalTransaction CAT transaction
+ * @param {Transaction} transaction active transaction
+ */
+cat.assignCatToTransaction = function assignCatToTransaction(
+  externalId,
+  externalTransaction,
+  transaction
+) {
+  if (typeof externalId === 'string') {
+    transaction.incomingCatId = externalId
   }
 
-  if (Array.isArray(externalTrans)) {
-    transaction.referringTransactionGuid = externalTrans[0]
-    if (typeof externalTrans[2] === 'string') {
-      transaction.tripId = externalTrans[2]
-    } else if (externalTrans[2]) {
+  if (Array.isArray(externalTransaction)) {
+    const [referringGuid, , tripId, referringPathHash] = externalTransaction
+    transaction.referringTransactionGuid = referringGuid
+
+    if (typeof tripId === 'string') {
+      transaction.tripId = tripId
+    } else if (tripId) {
       transaction.invalidIncomingExternalTransaction = true
     }
 
-    if (_isValidReferringHash(externalTrans[3])) {
-      transaction.referringPathHash = externalTrans[3]
-    } else if (externalTrans[3]) {
+    if (typeof referringPathHash === 'string') {
+      transaction.referringPathHash = referringPathHash
+    } else if (referringPathHash) {
       transaction.invalidIncomingExternalTransaction = true
     }
   }
+
+  if (transaction.incomingCatId) {
+    logger.trace(
+      'Got inbound CAT headers in transaction %s from %s',
+      transaction.id,
+      transaction.incomingCatId
+    )
+  }
+}
+
+/**
+ * Encodes the data to be set on the CAT app data header
+ * for incoming requests
+ *
+ * @param {Object} config agent config
+ * @param {Transaction} transaction
+ * @param {string} contentLength
+ * @param {Boolean} useMqHeaders flag to return proper headers for MQ compliance
+ * @return {Object} { key, data} to add as header
+ */
+cat.encodeAppData = function encodeAppData(config, transaction, contentLength, useMqHeaders) {
+  let appData = null
+  const transactionName = transaction.getFullName() || ''
+
+  try {
+    appData = JSON.stringify([
+      config.cross_process_id, // cross_process_id
+      transactionName, // transaction name
+      transaction.queueTime / 1000, // queue time (s)
+      transaction.catResponseTime / 1000, // response time (s)
+      contentLength, // content length (if content-length header is also being sent)
+      transaction.id, // TransactionGuid
+      false // force a transaction trace to be recorded
+    ])
+  } catch (err) {
+    logger.trace(
+      err,
+      'Failed to serialize transaction: %s - not adding CAT response headers',
+      transactionName
+    )
+    return
+  }
+
+  const encKey = config.encoding_key
+  const obfAppData = hashes.obfuscateNameUsingKey(appData, encKey)
+  const key = useMqHeaders ? MQ_CAT_APP_DATA_HEADER : HTTP_CAT_APP_DATA_HEADER
+  return { key, data: obfAppData }
+}
+
+/**
+ * Adds CAT headers to outbound request.
+ *
+ * @param {Object} config agent config
+ * @param {Transaction} transaction
+ * @param {Object} headers object that contains headers the agent is adding to client request
+ * @param {Boolean} useMqHeaders flag to return proper headers for MQ compliance
+ */
+cat.addCatHeaders = function addCatHeaders(config, transaction, headers, useMqHeaders) {
+  if (!config.encoding_key) {
+    logger.warn('Missing encoding key, not adding CAT headers!')
+    return
+  }
+
+  const idHeader = useMqHeaders ? MQ_CAT_ID_HEADER : HTTP_CAT_ID_HEADER
+  const transactionHeader = useMqHeaders ? MQ_CAT_TRANSACTION_HEADER : HTTP_CAT_TRANSACTION_HEADER
+
+  // Add in the application ID
+  if (config.obfuscatedId) {
+    headers[idHeader] = config.obfuscatedId
+  }
+
+  const transactionName = transaction.getFullName() || ''
+
+  const pathHash = hashes.calculatePathHash(
+    config.applications()[0],
+    transactionName,
+    transaction.referringPathHash
+  )
+  transaction.pushPathHash(pathHash)
+
+  try {
+    const transactionData = hashes.obfuscateNameUsingKey(
+      JSON.stringify([transaction.id, false, transaction.tripId || transaction.id, pathHash]),
+      config.encoding_key
+    )
+    headers[transactionHeader] = transactionData
+
+    logger.trace('Added outbound request CAT headers in transaction %s', transaction.id)
+  } catch (err) {
+    logger.trace(err, 'Failed to create CAT payload')
+  }
 }
 
-function _isValidReferringHash(hash) {
-  return (typeof hash === 'string')
+/**
+ * Find the CAT id, transaction, app data headers
+ * from the headers of either HTTP or MQ request
+ *
+ * @param {Object} headers
+ * @return {Object} { id, transactionId, appData }
+ */
+cat.extractCatHeaders = function extractCatHeaders(headers) {
+  // Hunt down the CAT headers.
+  let id = null
+  let transactionId = null
+  let appData = null
+  // eslint-disable-next-line guard-for-in
+  for (const key in headers) {
+    if (MATCH_CAT_ID_HEADER.test(key)) {
+      id = headers[key]
+    } else if (MATCH_CAT_TRANSACTION_HEADER.test(key)) {
+      transactionId = headers[key]
+    } else if (MATCH_CAT_APP_DATA_HEADER.test(key)) {
+      appData = headers[key]
+    }
+    if (id && transactionId && appData) {
+      break
+    }
+  }
+
+  return { id, transactionId, appData }
+}
+
+/**
+ * Extracts the account Id from CAT data and verifies if it is
+ * a trusted account id
+ *
+ * @param {Object} CAT data
+ * @param {Array} trustedAccounts from config
+ * @return {Boolean}
+ */
+cat.isTrustedAccountId = function isTrustedAccountId(data, trustedAccounts) {
+  const accountId = parseInt(data.split('#')[0], 10)
+  const trusted = trustedAccounts.includes(accountId)
+  if (!trusted) {
+    logger.trace('Response from untrusted CAT header account id: %s', accountId)
+  }
+  return trusted
+}
+
+/**
+ * Decodes the CAT App Data header and extracts the downstream
+ * CAT id, transaction id
+ *
+ * @param {Object} config agent config
+ * @param {string} obfAppData encoded app data to parse and use
+ * @param {Array} decoded app data header
+ */
+cat.parseAppData = function parseAppData(config, obfAppData) {
+  if (!config.encoding_key) {
+    logger.trace('config.encoding_key is not set - not parsing response CAT headers')
+    return
+  }
+
+  if (!config.trusted_account_ids) {
+    logger.trace('config.trusted_account_ids is not set - not parsing response CAT headers')
+    return
+  }
+
+  let appData = null
+  try {
+    appData = JSON.parse(hashes.deobfuscateNameUsingKey(obfAppData, config.encoding_key))
+  } catch (e) {
+    logger.warn(`Got an unparsable CAT header ${HTTP_CAT_APP_DATA_HEADER}: %s`, obfAppData)
+    return
+  }
+
+  // Make sure it is a trusted account
+  if (!cat.isTrustedAccountId(appData && appData[0], config.trusted_account_ids)) {
+    return
+  }
+
+  return appData
+}
+
+/**
+ * Assigns the CAT id, transaction to segment and adds `transaction_guid` when it exists.
+ * It also renames the segment name based on the newly decoded app data when host is present
+ *
+ * @param {Array} appData decodes CAT app data
+ * @param {TraceSegment} segment
+ * @param {string} [host] if host is present it will rename segment with app data and host
+ */
+cat.assignCatToSegment = function assignCatToSegment(appData, segment, host) {
+  if (!Array.isArray(appData) || typeof appData[0] !== 'string') {
+    logger.trace(`Unknown format for CAT header ${HTTP_CAT_APP_DATA_HEADER}.`)
+    return
+  }
+
+  segment.catId = appData[0]
+  segment.catTransaction = appData[1]
+
+  if (host) {
+    segment.name = `${NAMES.EXTERNAL.TRANSACTION}${host}/${segment.catId}/${segment.catTransaction}`
+  }
+
+  let transactionGuid
+  if (appData.length >= 6) {
+    transactionGuid = appData[5]
+    segment.addAttribute('transaction_guid', transactionGuid)
+  }
+  logger.trace(
+    'Got inbound response CAT headers in transaction %s from %s',
+    segment.transaction.id,
+    transactionGuid
+  )
 }

package/lib/util/codec.js

@@ -5,8 +5,8 @@
 
 'use strict'
 
-var stringify = require('json-stringify-safe')
-var zlib = require('zlib')
+const stringify = require('json-stringify-safe')
+const zlib = require('zlib')
 
 module.exports = {
   /**
@@ -23,8 +23,10 @@ module.exports = {
    */
   encode: function encode(data, callback) {
     try {
-      zlib.deflate(stringify(data), function cb_deflate(err, raw) {
-        if (err) return callback(err)
+      zlib.deflate(stringify(data), function cbDeflate(err, raw) {
+        if (err) {
+          return callback(err)
+        }
 
         return callback(null, raw.toString('base64'))
       })
@@ -47,8 +49,10 @@ module.exports = {
    *  decoding, and the second parameter is the decoded data object.
    */
   decode: function decode(encoded, callback) {
-    zlib.inflate(Buffer.from(encoded, 'base64'), function cb_inflate(err, raw) {
-      if (err) return callback(err)
+    zlib.inflate(Buffer.from(encoded, 'base64'), function cbInflate(err, raw) {
+      if (err) {
+        return callback(err)
+      }
 
       let json
       try {

package/lib/util/copy.js

@@ -5,7 +5,7 @@
 
 'use strict'
 
-var hasOwnProperty = require('./properties').hasOwn
+const hasOwnProperty = require('./properties').hasOwn
 
 exports.shallow = shallowCopy
 
@@ -19,7 +19,7 @@ exports.shallow = shallowCopy
  */
 function shallowCopy(source, dest) {
   dest = dest || Object.create(null)
-  for (var k in source) {
+  for (const k in source) {
     if (hasOwnProperty(source, k)) {
       dest[k] = source[k]
     }

package/lib/util/deep-equal.js

@@ -11,7 +11,9 @@ function isArguments(object) {
 
 function slice(args) {
   // Array.prototype.slice on arguments array-like is expensive
-  var l = args.length, a = [], i
+  const l = args.length
+  const a = []
+  let i
   for (i = 0; i < l; i++) {
     a[i] = args[i]
   }
@@ -71,45 +73,73 @@ function deeper(a, b, ca, cb) {
   } else if (a === null || b === null) {
     return false
   } else if (Buffer.isBuffer(a) && Buffer.isBuffer(b)) {
-    if (a.length !== b.length) return false
+    if (a.length !== b.length) {
+      return false
+    }
 
     // potentially incredibly expensive
-    for (var i = 0; i < a.length; i++) if (a[i] !== b[i]) return false
+    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
+    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
+    if (!(isArguments(a) && isArguments(b))) {
+      return false
+    }
 
     return deeper(slice(a), slice(b), ca, cb)
   }
 
-  if (a.constructor !== b.constructor) return false
+  if (a.constructor !== b.constructor) {
+    return false
+  }
 
-  var ka = Object.keys(a), kb = Object.keys(b)
-  if (ka.length !== kb.length) return false
+  const ka = Object.keys(a)
+  const kb = Object.keys(b)
+  if (ka.length !== kb.length) {
+    return false
+  }
 
-  var cal = ca.length
-  while (cal--) if (ca[cal] === a) return cb[cal] === b
-  ca.push(a); cb.push(b)
+  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 (var j = ka.length - 1; j >= 0; j--) if (ka[j] !== kb[j]) return false
+  ka.sort()
+  kb.sort()
+  for (let j = ka.length - 1; j >= 0; j--) {
+    if (ka[j] !== kb[j]) {
+      return false
+    }
+  }
 
-  var key
-  for (var k = ka.length - 1; k >= 0; k--) {
+  let key
+  for (let k = ka.length - 1; k >= 0; k--) {
     key = ka[k]
-    if (!deeper(a[key], b[key], ca, cb)) return false
+    if (!deeper(a[key], b[key], ca, cb)) {
+      return false
+    }
   }
 
-  ca.pop(); cb.pop()
+  ca.pop()
+  cb.pop()
 
   return true
 }

package/lib/util/flatten.js

@@ -25,13 +25,16 @@ function flatten(result, prefix, obj, seen) {
   seen = seen || []
   seen.push(obj)
 
-  for (var key in obj) {
+  for (const key in obj) {
     if (seen.indexOf(obj[key]) > -1) {
       continue
     }
 
-    if (obj[key] instanceof Object) flatten(result, prefix + key + '.', obj[key], seen)
-    else result[prefix + key] = obj[key]
+    if (obj[key] instanceof Object) {
+      flatten(result, prefix + key + '.', obj[key], seen)
+    } else {
+      result[prefix + key] = obj[key]
+    }
   }
 
   return result
@@ -49,15 +52,15 @@ function flatten(result, prefix, obj, seen) {
  * @return {array.<string>} An array of keys names.
  */
 function flatKeys(obj, prefix, arrayIdxs) {
-  var keys = []
-  var seen = []
+  const keys = []
+  const seen = []
   recurse(prefix || '', obj)
   return keys
 
   function recurse(p, o) {
     seen.push(o)
 
-    for (var key in o) {
+    for (const key in o) {
       if (seen.indexOf(o[key]) !== -1) {
         continue
       }

package/lib/util/hashes.js

@@ -8,7 +8,7 @@
 const crypto = require('crypto')
 
 function encode(bytes, keyBytes) {
-  for (var i = 0; i < bytes.length; i++) {
+  for (let i = 0; i < bytes.length; i++) {
     // This is really dense but happens commonly so I'm in-lining some of what
     // could be tossed into variables. It takes the current byte of bytes, then
     // XORs it with the current byte of the key (which uses modulo to make sure
@@ -19,37 +19,37 @@ function encode(bytes, keyBytes) {
 }
 
 function obfuscateNameUsingKey(name, key) {
-  var encodedBytes = Buffer.from(name, 'utf-8')
-  var keyBytes = Buffer.from(key)
+  const encodedBytes = Buffer.from(name, 'utf-8')
+  const keyBytes = Buffer.from(key)
   return encode(encodedBytes, keyBytes).toString('base64')
 }
 
 function deobfuscateNameUsingKey(name, key) {
-  var bytes = Buffer.from(name, 'base64')
-  var keyBytes = Buffer.from(key)
+  const bytes = Buffer.from(name, 'base64')
+  const keyBytes = Buffer.from(key)
 
-  return encode(bytes, keyBytes).toString("utf-8")
+  return encode(bytes, keyBytes).toString('utf-8')
 }
 
 function calculatePathHash(appName, pathName, referingPathHash) {
   if (typeof referingPathHash === 'string') {
     referingPathHash = parseInt(referingPathHash, 16)
   }
-  var rotated = ((referingPathHash << 1) | (referingPathHash >>> 31)) >>> 0
-  var hash = getHash(appName, pathName)
+  const rotated = ((referingPathHash << 1) | (referingPathHash >>> 31)) >>> 0
+  const hash = getHash(appName, pathName)
 
-  var result = (rotated ^ hash) >>> 0
+  const result = (rotated ^ hash) >>> 0
 
   // This is a trick to pad it out to 8 chars regardless of length.
-  var retval = ('00000000' + result.toString(16)).substr(-8)
+  const retval = ('00000000' + result.toString(16)).substr(-8)
 
   return retval
 }
 
 function getHash(appName, txName) {
-  var md5sum = crypto.createHash('md5')
+  const md5sum = crypto.createHash('md5')
   md5sum.update(appName + ';' + txName, 'utf8')
-  var buf = md5sum.digest()
+  let buf = md5sum.digest()
   if (!(buf instanceof Buffer)) {
     buf = Buffer.from(buf)
   }
@@ -66,10 +66,10 @@ function randInt32() {
 
 function int32ToByteArray(int32) {
   // we want to represent the input as a 4-bytes array
-  let byteArray = new Uint8Array(4)
+  const byteArray = new Uint8Array(4)
 
   for (let i = 0; i < byteArray.length; i++) {
-    let byte = int32 & 0xff
+    const byte = int32 & 0xff
     byteArray[i] = byte
     int32 = (int32 - byte) / 256
   }
@@ -87,7 +87,7 @@ function makeId(length = 16) {
   // length is number of hex characters, which multiplied by 4 is the number of
   // bits, then divided by 8 is number of bytes. Or just divide by 2
   const numBytes = Math.ceil(length / 2)
-  let randBytes = new Uint8Array(numBytes)
+  const randBytes = new Uint8Array(numBytes)
 
   // Generate random bytes one 32-bit integer at a time
   const numInts = Math.ceil(numBytes / 4) // 32 bit integers are 4 bytes
@@ -98,7 +98,7 @@ function makeId(length = 16) {
       // This could "overflow" since we're iterating over the number of ints, which could
       // be more data than needed. But out-of-bound index assignment on typed arrays are
       // discarded
-      randBytes[(i * 4) + j] = bytes[j]
+      randBytes[i * 4 + j] = bytes[j]
     }
   }