newrelic 7.0.2 → 7.1.3

package/bin/github.js

@@ -0,0 +1,144 @@
+'use strict'
+
+const { Octokit } = require("@octokit/rest")
+
+if (!process.env.GITHUB_TOKEN) {
+  console.log('GITHUB_TOKEN recommended to be set in ENV')
+}
+
+const octokit = new Octokit({
+  auth: process.env.GITHUB_TOKEN,
+})
+
+class Github {
+  constructor(repoOwner = 'newrelic', repository = 'node-newrelic') {
+    this.repoOwner = repoOwner
+    this.repository = repository
+  }
+
+  async getLatestRelease() {
+    const result = await octokit.repos.getLatestRelease({
+      owner: this.repoOwner,
+      repo: this.repository
+    })
+
+    return result.data
+  }
+
+  async createRelease(tag, name, body) {
+    const result = await octokit.repos.createRelease({
+      owner: this.repoOwner,
+      repo: this.repository,
+      tag_name: tag,
+      name: name,
+      body: body
+    })
+
+    return result.data
+  }
+
+  async getTagByName(name) {
+    const perPage = 100
+
+    let pageNum = 1
+
+    let result = null
+    do {
+      result = await octokit.repos.listTags({
+        owner: this.repoOwner,
+        repo: this.repository,
+        per_page: perPage,
+        page: pageNum
+      })
+
+      const found = result.data.find((tag) => {
+        return tag.name === name
+      })
+
+      if (found) {
+        return found
+      }
+
+      pageNum++
+    } while (result.data.length === perPage) // there *might* be more data
+
+    return null
+  }
+
+  async getCommit(sha) {
+    const result = await octokit.repos.getCommit({
+      owner: this.repoOwner,
+      repo: this.repository,
+      ref: sha
+    })
+
+    return result.data
+  }
+
+  async getMergedPullRequestsSince(date) {
+    const perPage = 50
+
+    const comparisonDate = new Date(date)
+
+    let pageNum = 1
+    const mergedPullRequests = []
+    let result = null
+    let hadData = false
+
+    do {
+      result = await octokit.pulls.list({
+        owner: this.repoOwner,
+        repo: this.repository,
+        state: 'closed',
+        sort: 'updated',
+        direction: 'desc',
+        per_page: perPage,
+        page: pageNum
+      })
+
+      const mergedPrs = result.data.filter((pr) => {
+        return pr.merged_at && new Date(pr.merged_at) > comparisonDate
+      })
+
+      mergedPullRequests.push(...mergedPrs)
+      // Since we are going by 'updated' on query but merged on filter,
+      // there's a chance some boundaries are off. While in super extreme
+      // cases we could still miss some it is unlikely given we are grabbing
+      // large pages.
+      hadData = mergedPrs.length > 0
+
+      pageNum++
+    } while (result.data.length === perPage && hadData) // might be more in next batch
+
+    return mergedPullRequests
+  }
+
+  async getLatestWorkflowRun(nameOrId, branch) {
+    // Appears to return in latest order.
+    const runs = await octokit.actions.listWorkflowRuns({
+      owner: this.repoOwner,
+      repo: this.repository,
+      workflow_id: nameOrId,
+      branch: branch,
+      per_page: 5
+    })
+
+    return runs.data.workflow_runs[0]
+  }
+
+  async createPR(options) {
+    const {head, base, title, body, draft} = options
+
+    await octokit.pulls.create({
+      owner: this.repoOwner,
+      repo: this.repository,
+      head: head,
+      base: base,
+      title: title,
+      body: body,
+      draft: draft
+    })
+  }
+}
+
+module.exports = Github

package/bin/npm-commands.js

@@ -0,0 +1,31 @@
+'use strict'
+
+const { exec } = require('child_process')
+
+async function version(typeOrVersion, shouldCommitAndTag) {
+  let command = `npm version ${typeOrVersion}`
+
+  command += shouldCommitAndTag ? '' : ' --no-git-tag-version'
+
+  await execAsPromise(command)
+}
+
+function execAsPromise(command) {
+  const promise = new Promise((resolve, reject) => {
+    console.log(`Executing: '${command}'`)
+
+    exec(command, (err, stdout) => {
+      if (err) {
+        return reject(err)
+      }
+
+      resolve(stdout)
+    })
+  })
+
+  return promise
+}
+
+module.exports = {
+  version
+}

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

@@ -51,13 +51,13 @@ function initialize() {
     // TODO: Update this check when Node v10 is deprecated.
     if (psemver.satisfies('<10.0.0')) {
       message = 'New Relic for Node.js requires a version of Node equal to or\n' +
-                'greater than 8.0.0. Not starting!'
+                'greater than 10.0.0. Not starting!'
 
       logger.error(message)
       throw new Error(message)
 
       // TODO: Update this check when Node v16 support is added
-    } else if (!psemver.satisfies(pkgJSON.engines.node) || psemver.satisfies('>=15.0.0')) { 
+    } else if (!psemver.satisfies(pkgJSON.engines.node) || psemver.satisfies('>=15.0.0')) {
       logger.warn(
         'New Relic for Node.js %s has not been tested on Node.js %s. Please ' +
         'update the agent or downgrade your version of Node.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

@@ -293,8 +293,11 @@ Agent.prototype.forceHarvestAll = function forceHarvestAll(callback) {
   promises.push(metricPromise)
 
   // TODO: plumb config through to aggregators so they can do their own checking.
-  if (agent.config.distributed_tracing.enabled &&
-      agent.config.span_events.enabled) {
+  if (
+    agent.config.distributed_tracing.enabled &&
+    agent.config.span_events.enabled &&
+    !agent.spanEventAggregator.isStream // Not valid to send on streaming aggregator
+  ) {
     const spanPromise = new Promise((resolve) => {
       agent.spanEventAggregator.once(
         'finished span_event_data data send.',
@@ -455,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()
+  }
 }
 
 /**