newrelic 7.1.2 → 7.1.3

package/bin/prepare-release.js

@@ -0,0 +1,359 @@
+'use strict'
+
+const fs = require('fs')
+
+const {program, Option} = require('commander')
+
+const Github = require('./github')
+const git = require('./git-commands')
+const npm = require('./npm-commands')
+
+const FILE_NAME = 'NEWS.md'
+const PROPOSED_NOTES_HEADER = 'Proposed Release Notes'
+
+const FORCE_RUN_DEAFULT_REMOTE = 'origin'
+
+// Add command line options
+program.addOption(
+  new Option('--release-type <releaseType>', 'release type')
+  .choices(['patch', 'minor', 'major'])
+  .makeOptionMandatory()
+)
+program.option('--major-release', 'create a major release. (release-type option must be set to \'major\')')
+program.option('--remote <remote>', 'remote to push branch to', 'origin')
+program.option('--branch <branch>', 'branch to generate notes from', 'main')
+program.option('--repo-owner <repoOwner>', 'repository owner', 'newrelic')
+program.option('--dry-run', 'generate notes without creating a branch or PR')
+program.option('--no-pr', 'generate notes and branch but do not create PR')
+program.option('-f --force', 'bypass validation')
+
+function stopOnError(err) {
+  if (err) {
+    console.error(err)
+  }
+
+  console.log('Halting execution with exit code: 1')
+  process.exit(1)
+}
+
+function logStep(step) {
+  console.log(`\n ----- [Step]: ${step} -----\n`)
+}
+
+async function prepareReleaseNotes() {
+  // Parse commandline options inputs
+  program.parse()
+
+  const options = program.opts()
+
+  console.log('Script running with following options: ', JSON.stringify(options))
+
+  logStep('Validation')
+
+  if (options.force) {
+    console.log('--force set. Skipping validation logic')
+  }
+
+  const startingBranch = options.branch.replace('refs/heads/', '')
+
+  const isValid = options.force || (
+    await validateReleaseType(options.releaseType, options.majorRelease) &&
+    await validateRemote(options.remote) &&
+    await validateLocalChanges() &&
+    await validateCurrentBranch(startingBranch)
+  )
+
+  if (!isValid) {
+    console.log('Invalid configuration. Halting script.')
+    stopOnError()
+  }
+
+  const remote = options.remote || FORCE_RUN_DEAFULT_REMOTE
+  console.log('Using remote: ', remote)
+
+  try {
+    logStep('Increment Version')
+
+    await npm.version(options.releaseType, false)
+
+    const packagePath = '../package.json'
+    console.log('Extracting new version from package.json here: ', )
+    const packageInfo = require(packagePath)
+
+    const version = `v${packageInfo.version}`
+    console.log('New version is: ', version)
+
+    logStep('Branch Creation')
+
+    const newBranchName = `release/${version}`
+
+    if (options.dryRun) {
+      console.log('Dry run indicated (--dry-run), not creating branch.')
+    } else {
+      console.log('Creating and checking out new branch: ', newBranchName)
+      await git.checkoutNewBranch(newBranchName)
+    }
+
+    logStep('Commit Package Files')
+
+    if (options.dryRun) {
+      console.log('Dry run indicated (--dry-run), not committing package files.')
+    } else {
+      console.log('Adding and committing package files.')
+      await git.addAllFiles()
+      await git.commit(`Setting version to ${version}.`)
+    }
+
+    logStep('Create Release Notes')
+
+    const releaseData = await generateReleaseNotes()
+    await updateReleaseNotesFile(FILE_NAME, version, releaseData.notes)
+
+    if (options.dryRun) {
+      console.log('\nDry run indicated (--dry-run), skipping remaining steps.')
+      return
+    }
+
+    logStep('Commit Release Notes')
+
+    console.log('Adding and committing release notes.')
+    await git.addAllFiles()
+    await git.commit('Adds auto-generated release notes.')
+
+    logStep('Push Branch')
+
+    console.log('Pushing branch to remote: ', remote)
+    await git.pushToRemote(remote, newBranchName)
+
+    logStep('Create Pull Request')
+    if (!options.pr) {
+      console.log('No PR creation indicated (--no-pr), skipping remaining steps.')
+      return
+    }
+
+    if (!process.env.GITHUB_TOKEN) {
+      console.log('GITHUB_TOKEN required to create a pull request (PR)')
+      stopOnError()
+    }
+
+    console.log('Creating draft PR with new release notes for repo owner: ', options.repoOwner)
+    const remoteApi = new Github(options.repoOwner)
+    const title = 'Updates release notes for next release'
+    const body = getFormattedPrBody(releaseData)
+    const prOptions = {
+      head: newBranchName,
+      base: 'main',
+      title,
+      body,
+      draft: true
+    }
+
+    await remoteApi.createPR(prOptions)
+
+    console.log('*** Full Run Successful ***')
+  } catch (err) {
+    stopOnError(err)
+  }
+}
+
+async function validateReleaseType(releaseType, majorFlag) {
+  if (releaseType === 'major' && !majorFlag) {
+    console.log('WARNING: you must set the \'-m\' flag to create a major release.')
+    return false
+  }
+
+  if (majorFlag && releaseType !== 'major') {
+    console.log(`WARNING: ignoring \'-m, --major-release\' option as release type set to ${options.rel}.`)
+    return false
+  }
+
+  return true
+}
+
+async function validateRemote(remote) {
+  try {
+    const remotes = await git.getPushRemotes()
+
+    if (!remote) {
+      console.log('No remote configured. Please execute with --remote.')
+      console.log('Available remotes are: ', remotes)
+      return false
+    }
+
+    if (!remotes[remote]) {
+      console.log(`Configured remote (${remote}) not found in ${JSON.stringify(remotes)}`)
+      return false
+    }
+
+    return true
+  } catch (err) {
+    console.error(err)
+    return false
+  }
+}
+
+async function validateLocalChanges() {
+  try {
+    const localChanges = await git.getLocalChanges()
+    if (localChanges.length > 0) {
+      console.log('Local changes detected: ', localChanges)
+      console.log('Please commit to a feature branch or stash changes and then try again.')
+      return false
+    }
+
+    return true
+  } catch (err) {
+    console.error(err)
+    return false
+  }
+}
+
+async function validateCurrentBranch(branch) {
+  try {
+    const currentBranch = await git.getCurrentBranch()
+
+    if (branch != currentBranch) {
+      console.log(
+        'Current checked-out branch (%s) does not match expected (%s)',
+        currentBranch,
+        branch
+      )
+      return false
+    }
+
+    return true
+  } catch (err) {
+    console.error(err)
+    return false
+  }
+}
+
+async function generateReleaseNotes() {
+  const github = new Github()
+  const latestRelease = await github.getLatestRelease()
+  console.log(`The latest release is: ${latestRelease.name} published: ${latestRelease.published_at}`)
+  console.log(`Tag: ${latestRelease.tag_name}, Target: ${latestRelease.target_commitish}`)
+
+  const tag = await github.getTagByName(latestRelease.tag_name)
+  console.log('The tag commit sha is: ', tag.commit.sha)
+
+  const commit = await github.getCommit(tag.commit.sha)
+  const commitDate = commit.commit.committer.date
+
+  console.log(`Finding merged pull requests since: ${commitDate}`)
+
+  const mergedPullRequests = await github.getMergedPullRequestsSince(commitDate)
+  console.log(`Found ${mergedPullRequests.length}`)
+
+  const releaseNoteData = mergedPullRequests.map((pr) => {
+    const parts = pr.body.split(/(?:^|\n)##\s*/g)
+
+    // If only has one part, not in appropriate format.
+    if (parts.length === 1) {
+      return {
+        notes: generateUnformattedNotes(pr.body),
+        url: pr.html_url
+      }
+    }
+
+    const {1: proposedReleaseNotes} = parts
+
+    const titleRemoved = proposedReleaseNotes.replace(PROPOSED_NOTES_HEADER, '')
+    return {
+      notes: titleRemoved,
+      url: pr.html_url
+    }
+  })
+
+  const finalData = releaseNoteData.reduce((result, currentValue) => {
+    const trimmedNotes = currentValue.notes.trim()
+    if (trimmedNotes) { // avoid adding lines for empty notes
+      result.notes += '\n\n' + trimmedNotes
+    }
+    result.links += `\n* PR: ${currentValue.url}`
+    return result
+  }, {
+    notes: '',
+    links: ''
+  })
+
+  return finalData
+}
+
+function generateUnformattedNotes(originalNotes) {
+  let unformattedNotes = originalNotes
+
+  // Drop extra snyk details and just keep high-level summary.
+  if (originalNotes.indexOf('snyk:metadata') >= 0) {
+    const snykParts = originalNotes.split('<hr/>')
+    const {0: snykDescription} = snykParts
+
+    unformattedNotes = snykDescription.trim()
+  }
+
+  const needsReviewNotes = [
+    '--- NOTES NEEDS REVIEW ---',
+    unformattedNotes,
+    '--------------------------'
+  ].join('\n')
+
+  return needsReviewNotes
+}
+
+function updateReleaseNotesFile(file, version, newNotes) {
+  const promise = new Promise((resolve, reject) => {
+    fs.readFile(file, 'utf8', function (err, data) {
+      if (err) {
+        return reject(err)
+      }
+
+      if (data.startsWith(`### ${version}`)) {
+        const errMessage = [
+          `${file} already contains '${version}'`,
+          `Delete existing ${version} release notes (if desired) and run again`
+        ].join('\n')
+
+        return reject(new Error(errMessage))
+      }
+
+      // toISOString() will always return UTC time
+      const todayFormatted = new Date().toISOString().split('T')[0]
+      const newVersionHeader = `### ${version} (${todayFormatted})`
+
+      const newContent = [
+        newVersionHeader,
+        newNotes,
+        '\n\n',
+        data
+      ].join('')
+
+      fs.writeFile(file, newContent, 'utf8', function (err) {
+        if (err) {
+          return reject(err)
+        }
+
+        console.log(`Added new release notes to ${file} under ${newVersionHeader}`)
+
+        resolve()
+      })
+    })
+  })
+
+  return promise
+}
+
+function getFormattedPrBody(data) {
+  const body = [
+    '## Proposed Release Notes',
+    data.notes,
+    '## Links',
+    data.links,
+    '',
+    '## Details',
+    ''
+  ].join('\n')
+
+  return body
+}
+
+prepareReleaseNotes()

package/bin/run-versioned-tests.sh

@@ -9,9 +9,6 @@ VERSIONED_MODE="${VERSIONED_MODE:---major}"
 if [[ $TRAVIS_BRANCH == `git describe --tags --always HEAD` ]]; then
   VERSIONED_MODE=--minor
 fi
-# if [[ $TRAVIS_BRANCH == "master" ]]; then
-#   VERSIONED_MODE=--minor
-# fi
 
 set -f
 directories=()
@@ -24,9 +21,4 @@ fi
 
 export AGENT_PATH=`pwd`
 
-# Don't run the aws-sdk tests if we don't have the keys set
-if [[ -z "$AWS_ACCESS_KEY_ID" ]]; then
-  time ./node_modules/.bin/versioned-tests $VERSIONED_MODE -i 2 -s aws-sdk ${directories[@]}
-else
-  time ./node_modules/.bin/versioned-tests $VERSIONED_MODE -i 2 ${directories[@]}
-fi
+time ./node_modules/.bin/versioned-tests $VERSIONED_MODE -i 2 ${directories[@]}

package/index.js

@@ -76,8 +76,10 @@ function initialize() {
     // just pipes to stdout.
     logger = require('./lib/logger')
 
-    if (!config || !config.agent_enabled) {
-      logger.info('Module not enabled in configuration; not starting.')
+    if (!config) {
+      logger.info('No configuration detected. Not starting.')
+    } else if (!config.agent_enabled) {
+      logger.info('Module disabled in configuration. Not starting.')
     } else {
       agent = createAgent(config)
       addStartupSupportabilities(agent)

package/lib/agent.js

@@ -458,6 +458,10 @@ Agent.prototype.onConnect = function onConnect() {
   this.spanEventAggregator.reconfigure(this.config)
   this.transactionEventAggregator.reconfigure(this.config)
   this.customEventAggregator.reconfigure(this.config)
+
+  if (this.config.certificates && this.config.certificates.length > 0) {
+    this.metrics.getOrCreateMetric(NAMES.FEATURES.CERTIFICATES).incrementCallCount()
+  }
 }
 
 /**

package/lib/collector/api.js

@@ -12,6 +12,8 @@ const RemoteMethod = require('./remote-method')
 
 const NAMES = require('../metrics/names')
 
+const DEFAULT_PORT = 443
+
 // just to make clear what's going on
 const TO_MILLIS = 1e3
 
@@ -54,22 +56,41 @@ function CollectorAPI(agent) {
   this._agent = agent
   this._reqHeadersMap = null
 
+  const initialEndpoint = {
+    host: agent.config.host,
+    port: agent.config.port
+  }
+
   /* RemoteMethods can be reused and have little per-object state, so why not
    * save some GC time?
    */
   this._methods = {
-    redirect: new RemoteMethod('preconnect', agent.config),
-    handshake: new RemoteMethod('connect', agent.config),
-    settings: new RemoteMethod('agent_settings', agent.config),
-    errors: new RemoteMethod('error_data', agent.config),
-    metrics: new RemoteMethod('metric_data', agent.config),
-    traces: new RemoteMethod('transaction_sample_data', agent.config),
-    shutdown: new RemoteMethod('shutdown', agent.config),
-    events: new RemoteMethod('analytic_event_data', agent.config),
-    customEvents: new RemoteMethod('custom_event_data', agent.config),
-    queryData: new RemoteMethod('sql_trace_data', agent.config),
-    errorEvents: new RemoteMethod('error_event_data', agent.config),
-    spanEvents: new RemoteMethod('span_event_data', agent.config)
+    preconnect: new RemoteMethod('preconnect', agent.config, initialEndpoint),
+    connect: new RemoteMethod('connect', agent.config, initialEndpoint),
+    settings: new RemoteMethod('agent_settings', agent.config, initialEndpoint),
+    errors: new RemoteMethod('error_data', agent.config, initialEndpoint),
+    metrics: new RemoteMethod('metric_data', agent.config, initialEndpoint),
+    traces: new RemoteMethod('transaction_sample_data', agent.config, initialEndpoint),
+    shutdown: new RemoteMethod('shutdown', agent.config, initialEndpoint),
+    events: new RemoteMethod('analytic_event_data', agent.config, initialEndpoint),
+    customEvents: new RemoteMethod('custom_event_data', agent.config, initialEndpoint),
+    queryData: new RemoteMethod('sql_trace_data', agent.config, initialEndpoint),
+    errorEvents: new RemoteMethod('error_event_data', agent.config, initialEndpoint),
+    spanEvents: new RemoteMethod('span_event_data', agent.config, initialEndpoint)
+  }
+}
+
+/**
+ * Updates all methods except preconnect w/ new host/port pairs sent down from server
+ * during preconnect (via redirect_host). Preconnect does not update.
+ */
+CollectorAPI.prototype._updateEndpoints = function _updateEndpoints(endpoint) {
+  logger.trace('Updating endpoints to: ', endpoint)
+  for (const [key, remoteMethod] of Object.entries(this._methods)) {
+    // Preconnect should always use configured options, not updates from server.
+    if (key !== 'preconnect') {
+      remoteMethod.updateEndpoint(endpoint)
+    }
   }
 }
 
@@ -160,7 +181,7 @@ CollectorAPI.prototype._login = function _login(callback) {
 
   const payload = [preconnectData]
 
-  methods.redirect.invoke(payload, onPreConnect)
+  methods.preconnect.invoke(payload, onPreConnect)
 
   function onPreConnect(error, response) {
     if (error || !SUCCESS.has(response.status)) {
@@ -188,8 +209,13 @@ CollectorAPI.prototype._login = function _login(callback) {
           res.redirect_host
         )
 
-        agent.config.host = parts[0]
-        agent.config.port = parts[1] || 443
+        const [host, port] = parts
+        const newEndpoint = {
+          host: host,
+          port: port || DEFAULT_PORT
+        }
+
+        self._updateEndpoints(newEndpoint)
       }
     }
 
@@ -226,7 +252,7 @@ CollectorAPI.prototype._connect = function _connect(env, callback) {
   const methods = this._methods
   const agent = this._agent
 
-  methods.handshake.invoke(env, onConnect)
+  methods.connect.invoke(env, onConnect)
 
   function onConnect(error, res) {
     if (error || !SUCCESS.has(res.status)) {
@@ -239,10 +265,11 @@ CollectorAPI.prototype._connect = function _connect(env, callback) {
     }
 
     agent.setState('connected')
+
     logger.info(
       'Connected to %s:%d with agent run ID %s.',
-      agent.config.host,
-      agent.config.port,
+      methods.connect.endpoint.host,
+      methods.connect.endpoint.port,
       config.agent_run_id
     )
 

package/lib/collector/remote-method.js

@@ -29,15 +29,24 @@ const USER_AGENT_FORMAT = 'NewRelic-NodeAgent/%s (nodejs %s %s-%s)'
 const ENCODING_HEADER = 'CONTENT-ENCODING'
 const DEFAULT_ENCODING = 'identity'
 
-function RemoteMethod(name, config) {
+function RemoteMethod(name, config, endpoint) {
   if (!name) {
     throw new TypeError('Must include name of method to invoke on collector.')
   }
 
   this.name = name
   this._config = config
-
   this._protocolVersion = 17
+
+  this.endpoint = endpoint
+}
+
+RemoteMethod.prototype.updateEndpoint = function updateEndpoint(endpoint) {
+  if (!endpoint) {
+    return
+  }
+
+  this.endpoint = endpoint
 }
 
 RemoteMethod.prototype.serialize = function serialize(payload, callback) {
@@ -88,8 +97,8 @@ RemoteMethod.prototype.invoke = function invoke(payload, nrHeaders, callback) {
 RemoteMethod.prototype._post = function _post(data, nrHeaders, callback) {
   var method = this
   var options = {
-    port: this._config.port,
-    host: this._config.host,
+    port: this.endpoint.port,
+    host: this.endpoint.host,
     compressed: this._shouldCompress(data),
     path: this._path(),
     onError: callback,
@@ -317,7 +326,7 @@ RemoteMethod.prototype._headers = function _headers(options) {
 
   var headers = {
     // select the virtual host on the server end
-    'Host': this._config.host,
+    'Host': this.endpoint.host,
     'User-Agent': agent,
     'Connection': 'Keep-Alive',
     'Content-Length': byteLength(options.body),

package/lib/config/index.js

@@ -1188,6 +1188,20 @@ Config.prototype._DTManuallySet = function _DTManuallySet(inputConfig) {
  */
 Config.prototype._enforceServerless = function _enforceServerless(inputConfig) {
   if (this.serverless_mode.enabled) {
+    // Application name is not currently leveraged by our Lambda product (March 2021).
+    // Defaulting the name removes burden on customers to set while avoiding
+    // breaking should it be used in the future.
+    if (!this.app_name || this.app_name.length === 0) {
+      const namingSource = process.env.AWS_LAMBDA_FUNCTION_NAME
+        ? 'process.env.AWS_LAMBDA_FUNCTION_NAME'
+        : 'DEFAULT'
+
+      const name = process.env.AWS_LAMBDA_FUNCTION_NAME || 'Serverless Application'
+      this.app_name = [name]
+
+      logger.info('Auto-naming serverless application to [\'%s\'] from: %s', name, namingSource)
+    }
+
     // Explicitly disable old CAT in serverless_mode
     if (this.cross_application_tracer.enabled) {
       this.cross_application_tracer.enabled = false
@@ -1667,17 +1681,20 @@ function _noConfigFile() {
 
   let locations = mainpath
   if (mainpath !== altpath) {
-    locations += ' or\n' + altpath
+    locations += ' or ' + altpath
   }
 
-  /* eslint-disable no-console */
-  console.error([
+  const errorMessage = [
     'Unable to find New Relic module configuration. A base configuration file',
     `can be copied from ${BASE_CONFIG_PATH}`,
     `and put at ${locations}.`,
     'If you are not using file-based configuration, please set the environment',
     'variable `NEW_RELIC_NO_CONFIG_FILE=true`.'
-  ].join('\n'))
+  ].join(' ')
+
+  logger.error(errorMessage)
+  /* eslint-disable no-console */
+  console.error(errorMessage)
   /* eslint-enable no-console */
 }
 

package/lib/instrumentation/core/timers.js

@@ -61,7 +61,12 @@ function initialize(agent, timers, moduleName, shim) {
 
   function wrapSetImmediate(shim, fn) {
     return function wrappedSetImmediate() {
-      const args = shim.argsToArray.apply(shim, arguments)
+      const segment = shim.getActiveSegment()
+      if (!segment) {
+        return fn.apply(this, arguments)
+      }
+
+      const args = shim.argsToArray.apply(shim, arguments, segment)
       shim.bindSegment(args, shim.FIRST)
 
       return fn.apply(this, args)

package/lib/metrics/names.js

@@ -22,7 +22,8 @@ const SUPPORTABILITY = {
   NODEJS: 'Supportability/Nodejs',
   REGISTRATION: 'Supportability/Registration',
   EVENT_HARVEST: 'Supportability/EventHarvest',
-  INFINITE_TRACING: 'Supportability/InfiniteTracing'
+  INFINITE_TRACING: 'Supportability/InfiniteTracing',
+  FEATURES: 'Supportability/Features'
 }
 
 const ERRORS = {
@@ -249,6 +250,10 @@ const INFINITE_TRACING = {
   DRAIN_DURATION: SUPPORTABILITY.INFINITE_TRACING + '/Drain/Duration',
 }
 
+const FEATURES = {
+  CERTIFICATES: SUPPORTABILITY.FEATURES + '/Certificates'
+}
+
 module.exports = {
   ACTION_DELIMITER: '/',
   ALL: ALL,
@@ -266,6 +271,7 @@ module.exports = {
   EVENT_HARVEST: EVENT_HARVEST,
   EXPRESS: EXPRESS,
   EXTERNAL: EXTERNAL,
+  FEATURES,
   FS: FS,
   FUNCTION: FUNCTION,
   GC: GC,

package/lib/transaction/index.js

@@ -879,6 +879,13 @@ Transaction.prototype.getIntrinsicAttributes = function getIntrinsicAttributes()
  */
 Transaction.prototype.acceptDistributedTraceHeaders = acceptDistributedTraceHeaders
 function acceptDistributedTraceHeaders(transportType, headers) {
+  if (headers == null || typeof headers !== 'object') {
+    logger.trace(
+      'Ignoring distributed trace headers for transaction %s. Headers not passed in as object.',
+      this.id)
+    return
+  }
+
   const transport = TRANSPORT_TYPES_SET[transportType] ? transportType : TRANSPORT_TYPES.UNKNOWN
 
   // assumes header keys already lowercase

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "7.1.2",
+  "version": "7.1.3",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "license": "Apache-2.0",
   "contributors": [
@@ -137,14 +137,13 @@
     "update-cross-agent-tests": "./bin/update-cats.sh",
     "versioned-tests": "./bin/run-versioned-tests.sh",
     "update-changelog-version": "node ./bin/update-changelog-version",
-    "versioned": "npm run prepare-test && time ./bin/run-versioned-tests.sh",
-    "version": "npm run update-changelog-version && git add ./NEWS.md"
+    "versioned": "npm run prepare-test && time ./bin/run-versioned-tests.sh"
   },
   "bin": {
     "newrelic-naming-rules": "./bin/test-naming-rules.js"
   },
   "dependencies": {
-    "@grpc/grpc-js": "^1.2.5",
+    "@grpc/grpc-js": "^1.2.7",
     "@grpc/proto-loader": "^0.5.5",
     "@newrelic/aws-sdk": "^3.1.0",
     "@newrelic/koa": "^5.0.0",