newrelic 2.0.0 → 2.2.0

package/lib/system-info.js

@@ -1,12 +1,12 @@
 'use strict'
 
 var exec = require('child_process').exec
-var fetchAWSInfo = require('./aws-info')
-var fs = require('fs')
+var readProc = require('./utilization/common').readProc
+var getBootId = require('./utilization/docker-info').getBootId
+var utilization = require('./utilization')
 var logger = require('./logger.js').child({component: 'system-info'})
 var os = require('os')
 var parseCpuInfo = require('./parse-proc-cpuinfo')
-var parseDockerInfo = require('./parse-dockerinfo')
 var parseMemInfo = require('./parse-proc-meminfo')
 var platform = os.platform()
 
@@ -71,7 +71,9 @@ function fetchSystemInfo(agent, callback) {
   var tasksDone = 0
   var numTasks = 5
   function finishedResponse() {
-    if (++tasksDone === numTasks) return callback(systemInfo)
+    if (++tasksDone === numTasks) {
+      callback(systemInfo)
+    }
   }
 
   module.exports._getProcessorStats(function getProcessCB(processorStats) {
@@ -88,16 +90,16 @@ function fetchSystemInfo(agent, callback) {
     systemInfo.kernelVersion = kernelVersion
     finishedResponse()
   })
-  module.exports._getDockerContainerId(agent, function getContainerId(containerId) {
-    if (containerId) {
-      systemInfo.docker = {
-        id: containerId
-      }
+  utilization.getVendors(agent, function getVendorInfo(err, vendors) {
+    if (vendors) {
+      systemInfo.vendors = vendors
     }
     finishedResponse()
   })
-  fetchAWSInfo(agent, function getAWSInfo(aws) {
-    systemInfo.aws = aws
+  getBootId(agent, function reportBootId(err, bootId) {
+    if (bootId) {
+      systemInfo.bootId = bootId
+    }
     finishedResponse()
   })
 }
@@ -136,11 +138,11 @@ module.exports._getProcessorStats = function getProcessorStats(callback) {
       callback(processorStats)
     })
   } else if (platform.match(/linux/i)) {
-    readProc('/proc/cpuinfo', function parseProc(data) {
+    readProc('/proc/cpuinfo', function parseProc(err, data) {
       callback(parseCpuInfo(data))
     })
   } else {
-    logger.debug('Unknown platform: ' + platform + ', could not retrieve processor info')
+    logger.debug('Unknown platform: %s; could not retrieve processor info', platform)
     callback(processorStats)
   }
 }
@@ -156,11 +158,11 @@ module.exports._getMemoryStats = function getMemoryStats(callback) {
       callback(parseInt(memory, 10) / (1024 * 1024))
     })
   } else if (platform.match(/linux/i)) {
-    readProc('/proc/meminfo', function parseProc(data) {
+    readProc('/proc/meminfo', function parseProc(err, data) {
       callback(parseMemInfo(data))
     })
   } else {
-    logger.debug('Unknown platform: ' + platform + ', could not retrieve memory info')
+    logger.debug('Unknown platform: %s; could not retrieve memory info', platform)
     callback(null)
   }
 }
@@ -175,27 +177,15 @@ function getKernelVersion(callback) {
       callback(version)
     })
   } else if (platform.match(/linux/i)) {
-    readProc('/proc/version', function parseProc(data) {
+    readProc('/proc/version', function parseProc(err, data) {
       callback(data)
     })
   } else {
-    logger.debug('Unknown platform' + platform + ', could not read kernel version')
+    logger.debug('Unknown platform: %s; could not read kernel version', platform)
     callback(null)
   }
 }
 
-module.exports._getDockerContainerId = function getDockerContainerId(agent, callback) {
-  if (!platform.match(/linux/i)) {
-    logger.debug('Platform is not a flavor of linux, omitting docker info')
-    callback(null)
-  } else {
-    readProc('/proc/self/cgroup', function getCGroup(data) {
-      if (!data) callback(null)
-      else callback(parseDockerInfo(agent, data))
-    })
-  }
-}
-
 function getSysctlValue(names, callback) {
   if (!names) return callback(null)
   var returned = false
@@ -206,7 +196,7 @@ function getSysctlValue(names, callback) {
     function respond(err, stdout, stderr) {
       if (returned) return
       if (err) {
-        logger.debug('Error when trying to run: sysctl -n ' + name + ': %s', err.message)
+        logger.debug('Error when trying to run: sysctl -n %s: %s', name, err.message)
         callback(null)
         returned = true
       } else if (!stderr) {
@@ -214,20 +204,9 @@ function getSysctlValue(names, callback) {
         returned = true
       }
       if (++ran === names.length && !returned) {
-        logger.debug('No sysctl info found for names: ' + names.toString())
+        logger.debug('No sysctl info found for names: %j', names)
         callback(null)
       }
     }
   })
 }
-
-function readProc(path, callback) {
-  fs.readFile(path, function readProcFile(err, data) {
-    if (err) {
-      logger.error('Error when trying to read ' + path, err)
-      callback(null)
-    } else {
-      callback(data.toString())
-    }
-  })
-}

package/lib/transaction/handle.js

@@ -13,10 +13,21 @@ module.exports.stub = {
   }
 }
 
+/**
+ * A light representation of a transaction instance, returned by calling
+ * {@link API#getTransaction}.
+ *
+ * @constructor
+ */
 function TransactionHandle(transaction) {
   this._transaction = transaction
 }
 
+/**
+ * End the transaction.
+ *
+ * @param  {Function} callback
+ */
 TransactionHandle.prototype.end = function handleEnd(callback) {
   if (!this._transaction.name) {
     this._transaction.finalizeName(null) // Use existing partial name.
@@ -27,6 +38,9 @@ TransactionHandle.prototype.end = function handleEnd(callback) {
   this._transaction.end(callback)
 }
 
+/**
+ * Mark the transaction to be ignored.
+ */
 TransactionHandle.prototype.ignore = function handleIgnore() {
   this._transaction.setForceIgnore(true)
 }

package/lib/transaction/index.js

@@ -53,7 +53,8 @@ function Transaction(agent) {
     agent.metricNameNormalizer
   )
 
-  agent.activeTransactions++
+  ++agent.activeTransactions
+  ++agent.transactionCreatedInHarvest
 
   this.numSegments = 0
 
@@ -144,8 +145,9 @@ Transaction.prototype.end = function end(done) {
     )
   }
 
-  var transaction = this
+  this.agent.recordSupportability('Transactions/Segments', this.numSegments)
 
+  var transaction = this
   transaction.trace.end()
   process.nextTick(function nextTickedEnd() {
     // recorders must be run before the trace is collected
@@ -404,6 +406,12 @@ function finalizeNameFromUri(requestURL, statusCode) {
  *  the current partial name is used.
  */
 Transaction.prototype.finalizeName = function finalizeName(name) {
+  // If no name is given, and this is a web transaction with a url, then
+  // finalize the name using the stored url.
+  if (name == null && this.type === 'web' && this.url) {
+    return this.finalizeNameFromUri(this.url, this.statusCode)
+  }
+
   this._partialName = name || this._partialName
 
   var fullName = TYPE_METRICS[this.type] + '/' + this._partialName

package/lib/transaction/tracer/index.js

@@ -100,6 +100,7 @@ function transactionProxy(handler) {
         transaction: {id: segment.transaction.id, name: segment.transaction.getName()},
         segment: segment.name
       }, 'Active transaction when creating non-nested transaction')
+      tracer.agent.recordSupportability('Transactions/Nested')
       return handler.apply(this, arguments)
     }
     var transaction = new Transaction(tracer.agent)

package/lib/util/hashes.js

@@ -1,9 +1,16 @@
 'use strict'
 
 var crypto = require('crypto')
+var semver = require('semver')
 
 // TODO: Just use Buffer.from once Node <5.10.0 is deprecated.
-var makeBuffer = Buffer.from || function makeBuffer(v, enc) {
+var makeBuffer = Buffer.from
+
+if (semver.satisfies(process.version, '<5.10.0')) {
+  makeBuffer = bufferFactory
+}
+
+function bufferFactory(v, enc) {
   return new Buffer(v, enc)
 }
 

package/lib/util/logger.js

@@ -129,12 +129,12 @@ Logger.prototype.child = function child(extra) {
   var parent = this
   childLogger.options = parent.options
 
-  childLogger.write = function write(level, args, extra) {
-    extra = getPropertiesToLog(extra)
+  childLogger.write = function write(level, args, _extra) {
+    _extra = getPropertiesToLog(_extra)
     var selfExtra = util._extend({}, this.extra)
 
-    extra = util._extend(selfExtra, extra)
-    return parent.write(level, args, extra)
+    _extra = util._extend(selfExtra, _extra)
+    return parent.write(level, args, _extra)
   }
 
   childLogger.setEnabled = Logger.prototype.setEnabled

package/lib/util/sql/obfuscate.js

@@ -13,7 +13,7 @@ var hex = /0x[0-9a-f]+/
 var boolean = /true|false|null/
 var number = /\b-?(?:[0-9]+\.)?[0-9]+([eE][+-]?[0-9]+)?/
 
-var dialects = {}
+var dialects = obfuscate.dialects = {}
 
 dialects.mysql = [
   replacer(join(
@@ -28,7 +28,7 @@ dialects.postgres = [
     [dollarQuote, singleQuote, comment, multilineComment, uuid, boolean, number],
     'gi'
   )),
-  unmatchedPairs(/'|\/\*|\*\/|\$/)
+  unmatchedPairs(/'|\/\*|\*\/|(?:\$(?!\?))/)
 ]
 
 dialects.cassandra = [
@@ -72,13 +72,19 @@ function toPart(expressions) {
 }
 
 function replacer(regex) {
-  return function replace(sql) {
+  function replace(sql) {
     return sql.replace(regex, '?')
   }
+  replace.regex = regex
+
+  return replace
 }
 
 function unmatchedPairs(regex) {
-  return function check(sql) {
+  function check(sql) {
     return regex.test(sql) ? '?' : sql
   }
+  check.regex = regex
+
+  return check
 }

package/lib/utilization/aws-info.js

@@ -0,0 +1,46 @@
+'use strict'
+
+var logger = require('../logger.js').child({component: 'aws-info'})
+var common = require('./common')
+var NAMES = require('../metrics/names.js')
+
+module.exports = fetchAWSInfo
+module.exports.clearCache = function clearAWSCache() {
+  results = null
+}
+
+var results = null
+
+function fetchAWSInfo(agent, callback) {
+  if (!agent.config.utilization || !agent.config.utilization.detect_aws) {
+    return setImmediate(callback, null)
+  }
+
+  if (results) {
+    return setImmediate(callback, null, results)
+  }
+
+  var instanceHost = '169.254.169.254'
+  var apiVersion = '2016-09-02'
+  var endpoint = 'dynamic/instance-identity/document'
+  var url = 'http://' + instanceHost + '/' + apiVersion + '/' + endpoint
+  common.request(url, agent, function getMetadata(err, data) {
+    if (err) {
+      return callback(err)
+    }
+
+    try {
+      data = JSON.parse(data)
+    } catch (e) {
+      logger.debug(e, 'Failed to parse AWS metadata.')
+      data = null
+    }
+
+    results = common.getKeys(data, ['availabilityZone', 'instanceId', 'instanceType'])
+    if (results == null) {
+      logger.debug('AWS metadata was invalid.')
+      agent.metrics.getOrCreateMetric(NAMES.UTILIZATION.AWS_ERROR).incrementCallCount()
+    }
+    callback(null, results)
+  })
+}

package/lib/utilization/azure-info.js

@@ -0,0 +1,54 @@
+'use strict'
+
+var common = require('./common')
+var logger = require('../logger.js').child({component: 'azure-info'})
+var NAMES = require('../metrics/names.js')
+
+
+module.exports = fetchAzureInfo
+module.exports.clearCache = function clearAzureCache() {
+  results = null
+}
+
+var results = null
+
+function fetchAzureInfo(agent, callback) {
+  if (!agent.config.utilization || !agent.config.utilization.detect_azure) {
+    return setImmediate(callback, null, null)
+  }
+
+  if (results) {
+    return setImmediate(callback, null, results)
+  }
+
+  var instanceHost = '169.254.169.254'
+  var apiVersion = '2017-03-01'
+  var endpoint = '/metadata/instance/compute'
+  common.request({
+    host: instanceHost,
+    path: endpoint + '?api-version=' + apiVersion,
+    headers: {Metadata: 'true'}
+  }, agent, function getMetadata(err, data) {
+    if (err) {
+      return callback(err)
+    }
+
+    // Hopefully the data is parsable as JSON.
+    try {
+      data = JSON.parse(data)
+    } catch (e) {
+      logger.debug(e, 'Failed to parse Azure metadata.')
+      data = null
+    }
+
+    // Get out just the keys we care about.
+    results = common.getKeys(data, ['location', 'name', 'vmId', 'vmSize'])
+    if (results == null) {
+      logger.debug('Azure metadata was invalid.')
+      agent.metrics.getOrCreateMetric(NAMES.UTILIZATION.AZURE_ERROR).incrementCallCount()
+    }
+
+    // Call back!
+    callback(null, results)
+  })
+}

package/lib/utilization/common.js

@@ -0,0 +1,106 @@
+'use strict'
+
+var concat = require('concat-stream')
+var http = require('http')
+var logger = require('../logger').child({component: 'utilization-request'})
+var fs = require('fs')
+var properties = require('../util/properties')
+
+
+exports.checkValueString = checkValueString
+function checkValueString(str) {
+  if (!str || !str.length || Buffer.byteLength(str) > 255) {
+    return false
+  }
+
+  var len = str.length
+  var validCharacters = /[0-9a-zA-Z_ ./-]/
+  for (var i = 0; i < len; ++i) {
+    if (str.charCodeAt(i) < 128 && !validCharacters.test(str[i])) {
+      return false
+    }
+  }
+  return true
+}
+
+exports.getKeys = function getKeys(data, keys) {
+  if (!data) {
+    return null
+  }
+
+  var results = {}
+  for (var i = 0; i < keys.length; ++i) {
+    var key = keys[i]
+    if (!properties.hasOwn(data, key) || !data[key]) {
+      logger.debug('Key %s missing from metadata', key)
+      return null
+    }
+    var value = data[key]
+    if (typeof value === 'number') {
+      value = value.toString()
+    }
+
+    // If any value is invalid, the whole thing must be trashed.
+    if (!checkValueString(value)) {
+      logger.debug('Invalid metadata value found: %s -> %s', key, value)
+      return null
+    }
+    results[key] = value
+  }
+
+  return results
+}
+
+exports.request = function request(opts, agent, cb) {
+  var req = http.get(opts, function awsRequest(res) {
+    res.pipe(concat(respond))
+    function respond(data) {
+      agent.removeListener('errored', abortRequest)
+      agent.removeListener('stopped', abortRequest)
+
+      if (res.statusCode !== 200) {
+        logger.debug(
+          'Got %d %s from metadata request %j',
+          res.statusCode, res.statusMessage || '<n/a>', opts
+        )
+        return cb(new Error('Request for metadata failed.'))
+      } else if (!data) {
+        logger.debug('Got no response data?')
+        return cb(new Error('No reponse data received.'))
+      }
+
+      cb(null, data.toString('utf8'))
+    }
+  })
+
+  req.setTimeout(1000, function requestTimeout() {
+    logger.debug('Request for metadata %j timed out', opts)
+    cb(new Error('Timeout'))
+  })
+  req.on('error', function requestError(err) {
+    logger.debug('Message for metadata %j: %s', opts, err.message)
+    cb(err)
+  })
+
+  agent.once('errored', abortRequest)
+  agent.once('stopped', abortRequest)
+
+  function abortRequest() {
+    logger.debug('Aborting request for metadata at %j', opts)
+    req.abort()
+    agent.removeListener('errored', abortRequest)
+    agent.removeListener('stopped', abortRequest)
+  }
+}
+
+exports.readProc = readProc
+function readProc(path, callback) {
+  fs.readFile(path, function readProcFile(err, data) {
+    if (err) {
+      logger.error(err, 'Error when trying to read %s', path)
+      callback(err, null)
+    } else {
+      callback(null, data.toString())
+    }
+  })
+}

package/lib/utilization/docker-info.js

@@ -0,0 +1,100 @@
+'use strict'
+
+var logger = require('../logger').child({component: 'docker-info'})
+var common = require('./common')
+var NAMES = require('../metrics/names')
+var os = require('os')
+
+module.exports.getVendorInfo = fetchDockerVendorInfo
+module.exports.clearVendorCache = function clearDockerVendorCache() {
+  vendorInfo = null
+}
+
+module.exports.getBootId = function getBootId(agent, callback) {
+  if (!/linux/i.test(os.platform())) {
+    logger.debug('Platform is not a flavor of linux, omitting boot info')
+    return setImmediate(callback, null, null)
+  }
+
+  common.readProc('/proc/sys/kernel/random/boot_id', function readProcBootId(err, data) {
+    if (!data) {
+      bootIdError()
+      return callback(null, null)
+    }
+
+    data = data.trim()
+    var asciiData = (new Buffer(data, 'ascii')).toString()
+
+    if (data !== asciiData) {
+      bootIdError()
+      return callback(null, null)
+    }
+
+    if (data.length !== 36) {
+      bootIdError()
+      if (data.length > 128) {
+        data = data.substr(0, 128)
+      }
+    }
+
+    return callback(null, data)
+  })
+
+  function bootIdError() {
+    agent.metrics.getOrCreateMetric(NAMES.UTILIZATION.BOOT_ID_ERROR)
+      .incrementCallCount()
+  }
+}
+
+var vendorInfo = null
+
+function fetchDockerVendorInfo(agent, callback) {
+  if (!agent.config.utilization || !agent.config.utilization.detect_docker) {
+    return callback(null, null)
+  }
+
+  if (vendorInfo) {
+    return callback(null, vendorInfo)
+  }
+
+  if (!os.platform().match(/linux/i)) {
+    logger.debug('Platform is not a flavor of linux, omitting docker info')
+    return callback(null)
+  }
+
+  common.readProc('/proc/self/cgroup', function getCGroup(err, data) {
+    if (!data) {
+      return callback(null)
+    }
+
+    var id = null
+    findCGroups(data, 'cpu', function forEachCpuGroup(cpuGroup) {
+      var match = /(?:^|[^0-9a-f])([0-9a-f]{64})(?:[^0-9a-f]|$)/.exec(cpuGroup)
+      if (match) {
+        id = match[1]
+        return false
+      }
+
+      return true
+    })
+
+    if (id) {
+      vendorInfo = {id: id}
+      callback(null, vendorInfo)
+    } else {
+      logger.debug('No matching cpu group found.')
+      callback(null, null)
+    }
+  })
+}
+
+function findCGroups(info, cgroup, eachCb) {
+  var target = new RegExp('^\\d+:[^:]*?\\b' + cgroup + '\\b[^:]*:')
+  var lines = info.split('\n')
+  for (var i = 0; i < lines.length; ++i) {
+    var line = lines[i]
+    if (target.test(line) && !eachCb(line.split(':')[2])) {
+      break
+    }
+  }
+}

package/lib/utilization/gcp-info.js

@@ -0,0 +1,56 @@
+'use strict'
+
+var logger = require('../logger.js').child({component: 'gcp-info'})
+var common = require('./common')
+var NAMES = require('../metrics/names.js')
+
+module.exports = fetchGCPInfo
+module.exports.clearCache = function clearGCPCache() {
+  resultDict = null
+}
+
+var resultDict
+
+function fetchGCPInfo(agent, callback) {
+  if (!agent.config.utilization || !agent.config.utilization.detect_gcp) {
+    return setImmediate(callback, null)
+  }
+
+  if (resultDict) {
+    return setImmediate(callback, null, resultDict)
+  }
+
+  common.request({
+    host: 'metadata.google.internal',
+    path: '/computeMetadata/v1/instance/?recursive=true',
+    headers: {
+      'Metadata-Flavor': 'Google'
+    }
+  }, agent, function getMetadata(err, data) {
+    if (err) {
+      return callback(err)
+    }
+
+    try {
+      data = JSON.parse(data)
+    } catch (e) {
+      logger.debug(e, 'Failed to parse GCP metadata.')
+      data = null
+    }
+
+    var results = common.getKeys(data, ['id', 'machineType', 'name', 'zone'])
+    if (results == null) {
+      logger.debug('GCP metadata was invalid.')
+      agent.metrics.getOrCreateMetric(NAMES.UTILIZATION.GCP_ERROR).incrementCallCount()
+    } else {
+      // normalize
+      results.machineType =
+        results.machineType.substr(results.machineType.lastIndexOf('/') + 1)
+      results.zone =
+        results.zone.substr(results.zone.lastIndexOf('/') + 1)
+
+      resultDict = results
+    }
+    callback(null, results)
+  })
+}

package/lib/utilization/index.js

@@ -0,0 +1,28 @@
+'use strict'
+
+module.exports.getVendors = getVendors
+function getVendors(agent, callback) {
+  var vendorMethods = {
+    aws: require('./aws-info'),
+    pcf: require('./pcf-info'),
+    azure: require('./azure-info'),
+    gcp: require('./gcp-info'),
+    docker: require('./docker-info').getVendorInfo
+  }
+
+  var done = 0
+  var vendors = null
+  var vendorNames = Object.keys(vendorMethods)
+  vendorNames.forEach(function getVendorInfo(vendor) {
+    vendorMethods[vendor](agent, function getInfo(err, result) {
+      if (result) {
+        vendors = vendors || {}
+        vendors[vendor] = result
+      }
+
+      if (++done === vendorNames.length) {
+        callback(null, vendors)
+      }
+    })
+  })
+}