newrelic 8.3.0 → 8.5.2

package/lib/util/cat.js

@@ -5,51 +5,296 @@
 
 'use strict'
 
+const cat = module.exports
 const hashes = require('./hashes')
 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 = {
   /**

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,9 +11,9 @@ function isArguments(object) {
 
 function slice(args) {
   // Array.prototype.slice on arguments array-like is expensive
-  var l = args.length
-  var a = []
-  var i
+  const l = args.length
+  const a = []
+  let i
   for (i = 0; i < l; i++) {
     a[i] = args[i]
   }
@@ -78,7 +78,7 @@ function deeper(a, b, ca, cb) {
     }
 
     // potentially incredibly expensive
-    for (var i = 0; i < a.length; i++) {
+    for (let i = 0; i < a.length; i++) {
       if (a[i] !== b[i]) {
         return false
       }
@@ -107,13 +107,13 @@ function deeper(a, b, ca, cb) {
     return false
   }
 
-  var ka = Object.keys(a)
-  var kb = Object.keys(b)
+  const ka = Object.keys(a)
+  const kb = Object.keys(b)
   if (ka.length !== kb.length) {
     return false
   }
 
-  var cal = ca.length
+  let cal = ca.length
   while (cal--) {
     if (ca[cal] === a) {
       return cb[cal] === b
@@ -124,14 +124,14 @@ function deeper(a, b, ca, cb) {
 
   ka.sort()
   kb.sort()
-  for (var j = ka.length - 1; j >= 0; j--) {
+  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

package/lib/util/flatten.js

@@ -25,7 +25,7 @@ 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
     }
@@ -52,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,14 +19,14 @@ 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')
 }
@@ -35,21 +35,21 @@ 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

package/lib/util/label-parser.js

@@ -10,12 +10,12 @@ module.exports.fromString = fromString
 module.exports.fromMap = fromMap
 
 // this creates a copy of trim that can be used with map
-var trim = Function.prototype.call.bind(String.prototype.trim)
-var logger = require('../logger').child({ component: 'label-parser' })
-var stringify = require('json-stringify-safe')
+const trim = Function.prototype.call.bind(String.prototype.trim)
+const logger = require('../logger').child({ component: 'label-parser' })
+const stringify = require('json-stringify-safe')
 
 function parse(labels) {
-  var results
+  let results
 
   if (!labels) {
     return []
@@ -33,14 +33,14 @@ function parse(labels) {
 }
 
 function fromString(raw) {
-  var map = Object.create(null)
+  const map = Object.create(null)
 
   if (!raw) {
     return { labels: [], warnings: [] }
   }
 
-  var pairs = raw.split(';').map(trim)
-  var parts
+  const pairs = raw.split(';').map(trim)
+  let parts
 
   while (!pairs[pairs.length - 1]) {
     pairs.pop()
@@ -50,7 +50,7 @@ function fromString(raw) {
     pairs.shift()
   }
 
-  for (var i = 0, l = pairs.length; i < l; ++i) {
+  for (let i = 0, l = pairs.length; i < l; ++i) {
     parts = pairs[i].split(':').map(trim)
 
     if (parts.length !== 2) {
@@ -72,11 +72,11 @@ function fromString(raw) {
 }
 
 function fromMap(map) {
-  var warnings = []
-  var labels = []
+  const warnings = []
+  let labels = []
 
   Object.keys(map).forEach(function processKeys(key) {
-    var type = truncate(key, 255)
+    const type = truncate(key, 255)
 
     if (!map[key] || typeof map[key] !== 'string') {
       return warnings.push(
@@ -84,7 +84,7 @@ function fromMap(map) {
       )
     }
 
-    var value = truncate(map[key], 255)
+    const value = truncate(map[key], 255)
 
     if (type !== key) {
       warnings.push('Label key too long: ' + type)
@@ -114,11 +114,11 @@ function fromMap(map) {
 }
 
 function truncate(str, max) {
-  var len = 0
-  var chr
-  for (var i = 0, l = str.length; i < l; ++i) {
-    chr = str.charCodeAt(i)
-    if (chr >= 0xd800 && chr <= 0xdbff && i !== l) {
+  let len = 0
+  let i
+  for (i = 0; i < str.length; ++i) {
+    const chr = str.charCodeAt(i)
+    if (chr >= 0xd800 && chr <= 0xdbff && i !== str.length) {
       i += 1
     }