@netlify/build 27.18.5-rc → 27.18.5

package/src/error/handle.js

@@ -0,0 +1,57 @@
+import { cwd as getCwd } from 'process'
+
+import { pathExists } from 'path-exists'
+
+import { logBuildError } from '../log/messages/core.js'
+import { logOldCliVersionError } from '../log/old_version.js'
+
+import { removeErrorColors } from './colors.js'
+import { getErrorInfo } from './info.js'
+import { reportBuildError } from './monitor/report.js'
+import { parseErrorInfo } from './parse/parse.js'
+
+// Logs and reports a build failure
+export const handleBuildError = async function (
+  error,
+  { errorMonitor, netlifyConfig, childEnv, mode, logs, debug, testOpts },
+) {
+  const basicErrorInfo = parseErrorInfo(error)
+
+  if (await isCancelCrash(error)) {
+    return basicErrorInfo
+  }
+
+  removeErrorColors(error)
+  // Some errors, such as telemetry ones, should not be logged
+  if (basicErrorInfo.showInBuildLog) {
+    logBuildError({ error, netlifyConfig, mode, logs, debug, testOpts })
+  }
+  logOldCliVersionError({ mode, testOpts })
+  await reportBuildError({ error, errorMonitor, childEnv, logs, testOpts })
+
+  return basicErrorInfo
+}
+
+// When builds are canceled, the whole filesystem is being deleted.
+// However, the process (and build) keeps going. Because no files exist anymore,
+// the build eventually crashes with a randomly odd error. Those should not be
+// logged nor reported.
+// However builds canceled with `utils.build.cancelBuild()` should still show
+// "Build canceled by ..."
+const isCancelCrash = async function (error) {
+  const [{ type }] = getErrorInfo(error)
+  if (type === 'cancelBuild') {
+    return false
+  }
+
+  try {
+    // TODO: find a better way to detect that the build is being cancelled.
+    // Otherwise bugs due to (for example) the build command removing
+    // `process.cwd` are currently not logged/reported.
+    const cwd = getCwd()
+    return !(await pathExists(cwd))
+    // `process.cwd()` fails when the current directory does not exist
+  } catch {
+    return true
+  }
+}

package/src/error/info.js

@@ -0,0 +1,46 @@
+// Add information related to an error without colliding with existing properties
+export const addDefaultErrorInfo = function (error, info) {
+  if (!canHaveErrorInfo(error)) {
+    return
+  }
+
+  error[CUSTOM_ERROR_KEY] = { ...info, ...error[CUSTOM_ERROR_KEY] }
+}
+
+// Retrieve error information added by our system
+export const addErrorInfo = function (error, info) {
+  if (!canHaveErrorInfo(error)) {
+    return
+  }
+
+  error[CUSTOM_ERROR_KEY] = { ...error[CUSTOM_ERROR_KEY], ...info }
+}
+
+export const getErrorInfo = function (error) {
+  if (!isBuildError(error)) {
+    return [{}, error]
+  }
+
+  const { [CUSTOM_ERROR_KEY]: errorInfo, ...errorA } = error
+  return [errorInfo, errorA]
+}
+
+// Change error type from one to another
+export const changeErrorType = function (error, oldType, newType) {
+  const [{ type }] = getErrorInfo(error)
+  if (type === oldType) {
+    addErrorInfo(error, { type: newType })
+  }
+}
+
+export const isBuildError = function (error) {
+  return canHaveErrorInfo(error) && error[CUSTOM_ERROR_KEY] !== undefined
+}
+
+// Exceptions that are not objects (including `Error` instances) cannot have an
+// `CUSTOM_ERROR_KEY` property
+const canHaveErrorInfo = function (error) {
+  return error != null
+}
+
+export const CUSTOM_ERROR_KEY = 'customErrorInfo'

package/src/error/monitor/location.js

@@ -0,0 +1,21 @@
+// Retrieve plugin's location and build logs
+export const getLocationMetadata = function (location, envMetadata) {
+  const buildLogs = getBuildLogs(envMetadata)
+
+  if (buildLogs === undefined && location === undefined) {
+    return
+  }
+
+  return { buildLogs, ...location }
+}
+
+// Retrieve the URL to the build logs
+const getBuildLogs = function ({ SITE_NAME, DEPLOY_ID }) {
+  if (SITE_NAME === undefined || DEPLOY_ID === undefined) {
+    return
+  }
+
+  return `${NETLIFY_ORIGIN}/sites/${SITE_NAME}/deploys/${DEPLOY_ID}`
+}
+
+const NETLIFY_ORIGIN = 'https://app.netlify.com'

package/src/error/monitor/normalize.js

@@ -0,0 +1,96 @@
+// We group errors by `error.message`. However some `error.message` contain
+// unique IDs, etc. which defeats that grouping. So we normalize those to make
+// them consistent
+export const normalizeGroupingMessage = function (message, type) {
+  const messageA = removeDependenciesLogs(message, type)
+  const messageB = NORMALIZE_REGEXPS.reduce(normalizeMessage, messageA)
+
+  // If this is a functions bundling error, we'll use additional normalization
+  // rules to group errors more aggressively.
+  if (type === 'functionsBundling') {
+    return FUNCTIONS_BUNDLING_REGEXPS.reduce(normalizeMessage, messageB)
+  }
+
+  return messageB
+}
+
+// Discard debug/info installation information
+const removeDependenciesLogs = function (message, type) {
+  if (type !== 'dependencies') {
+    return message
+  }
+
+  return message.split('\n').filter(isErrorLine).join('\n')
+}
+
+const isErrorLine = function (line) {
+  return ERROR_LINES.some((errorLine) => line.startsWith(errorLine))
+}
+
+const ERROR_LINES = [
+  // Prefix for npm
+  'npm ERR!',
+  // Prefix for Yarn
+  'error',
+]
+
+const normalizeMessage = function (message, [regExp, replacement]) {
+  return message.replace(regExp, replacement)
+}
+
+const NORMALIZE_REGEXPS = [
+  // Base64 URL
+  [/(data:[^;]+;base64),[\w+/-=]+/g, 'dataURI'],
+  // File paths
+  [/(["'`, ]|^)([^"'`, \n]*[/\\][^"'`, \n]*)(?=["'`, ]|$)/gm, '$1/file/path'],
+  // Semantic versions
+  [/\d+\.\d+\.\d+(-\d+)?/g, '1.0.0'],
+  [/version "[^"]+"/g, 'version "1.0.0"'],
+  // Cypress plugin prints the user's platform
+  [/^Platform: .*/gm, ''],
+  // URLs
+  [/https?:[\w.+~!$&'()*,;=:@/?#]+/g, 'https://domain.com'],
+  // Numbers, e.g. number of issues/problems
+  [/\d+/g, '0'],
+  // Hexadecimal strings
+  [/[\da-fA-F-]{6,}/g, 'hex'],
+  // On unknown inputs, we print the inputs
+  [/(does not accept any inputs but you specified: ).*/, '$1'],
+  [/(Unknown inputs for plugin).*/, '$1'],
+  [/(Plugin inputs should be one of: ).*/, '$1'],
+  // On required inputs, we print the inputs
+  [/^Plugin inputs[^]*/gm, ''],
+  [/(Required inputs for plugin).*/gm, '$1'],
+  // Netlify Functions validation check
+  [/(should target a directory, not a regular file):.*/, '$1'],
+  // zip-it-and-ship-it error when there is an `import()` but dependencies
+  // were not installed
+  [/(Cannot find module) '([^']+)'/g, "$1 'moduleName'"],
+  [/(A Netlify Function is using) "[^"]+"/g, '$1 "moduleName"'],
+  // Deploy upload errors include the filename
+  [/(Upload cancelled).*/g, '$1'],
+  [/(aborting upload of file).*/g, '$1'],
+  // netlify-plugin-inline-critical-css errors prints a list of file paths
+  [/Searched in: .*/g, ''],
+  // netlify-plugin-subfont prints font name in errors
+  [/(is not supported yet): .*/, '$1'],
+  // netlify-plugin-subfont prints generic information in every error that
+  // is highly build-specific
+  [/^(vers?ions|Plugin configuration|Subfont called with): {[^}]+}/gm, ''],
+  [/^Resolved entry points: \[[^\]]+]/gm, ''],
+  // netlify-plugin-minify-html parse error
+  [/(Parse Error):[^]*/, '$1'],
+  // Multiple empty lines
+  [/^\s*$/gm, ''],
+]
+
+const FUNCTIONS_BUNDLING_REGEXPS = [
+  // String literals and identifiers
+  [/"([^"]+)"/g, '""'],
+  [/'([^']+)'/g, "''"],
+  [/`([^`]+)`/g, '``'],
+
+  // Rust crates
+  [/(?:Downloaded \S+ v[\d.]+\s*)+/gm, 'Downloaded crates'],
+  [/(?:Compiling \S+ v[\d.]+\s*)+/gm, 'Compiled crates'],
+]

package/src/error/monitor/print.js

@@ -0,0 +1,42 @@
+import { log } from '../../log/logger.js'
+
+// Print event payload instead of sending actual request during tests
+export const printEventForTest = function (
+  { name: errorClass, message: errorMessage },
+  {
+    context,
+    groupingHash,
+    severity,
+    unhandled,
+    _metadata: {
+      location,
+      plugin: { packageName, homepage } = {},
+      pluginPackageJson,
+      tsConfig,
+      env: { BUILD_ID } = {},
+      other,
+    },
+  },
+  logs,
+) {
+  const eventString = JSON.stringify(
+    {
+      errorClass,
+      errorMessage,
+      context,
+      groupingHash,
+      severity,
+      unhandled,
+      location,
+      packageName,
+      pluginPackageJson: pluginPackageJson !== undefined,
+      homepage,
+      tsConfig,
+      BUILD_ID,
+      other,
+    },
+    null,
+    2,
+  )
+  log(logs, `\nError monitoring payload:\n${eventString}`)
+}

package/src/error/monitor/report.js

@@ -0,0 +1,138 @@
+import { type as osType, freemem, totalmem } from 'os'
+import { promisify } from 'util'
+
+import osName from 'os-name'
+
+import { getEnvMetadata } from '../../env/metadata.js'
+import { log } from '../../log/logger.js'
+import { parseErrorInfo } from '../parse/parse.js'
+import { getHomepage } from '../parse/plugin.js'
+
+import { getLocationMetadata } from './location.js'
+import { normalizeGroupingMessage } from './normalize.js'
+import { printEventForTest } from './print.js'
+
+// Report a build failure for monitoring purpose
+export const reportBuildError = async function ({ error, errorMonitor, childEnv, logs, testOpts }) {
+  if (errorMonitor === undefined) {
+    return
+  }
+
+  const { errorInfo, type, severity, title, group = title } = parseErrorInfo(error)
+  const severityA = getSeverity(severity, errorInfo)
+  const groupA = getGroup(group, errorInfo)
+  const groupingHash = getGroupingHash(groupA, error, type, errorInfo)
+  const metadata = getMetadata(errorInfo, childEnv, groupingHash)
+  const app = getApp()
+  const eventProps = getEventProps({ severity: severityA, group: groupA, groupingHash, metadata, app })
+
+  const errorName = updateErrorName(error, type)
+  try {
+    await reportError({ errorMonitor, error, logs, testOpts, eventProps })
+  } finally {
+    error.name = errorName
+  }
+}
+
+// Plugin authors test their plugins as local plugins. Errors there are more
+// like development errors, and should be reported as `info` only.
+const getSeverity = function (severity, { location: { loadedFrom } = {} }) {
+  if (loadedFrom === 'local' || severity === 'none') {
+    return 'info'
+  }
+
+  return severity
+}
+
+const getGroup = function (group, errorInfo) {
+  if (typeof group !== 'function') {
+    return group
+  }
+
+  return group(errorInfo)
+}
+
+const getGroupingHash = function (group, error, type, errorInfo = {}) {
+  // If the error has a `normalizedMessage`, we use it as the grouping hash.
+  if (errorInfo.normalizedMessage) {
+    return errorInfo.normalizedMessage
+  }
+
+  const message = error instanceof Error && typeof error.message === 'string' ? error.message : String(error)
+  const messageA = normalizeGroupingMessage(message, type)
+  return `${group}\n${messageA}`
+}
+
+const getMetadata = function ({ location, plugin, tsConfig }, childEnv, groupingHash) {
+  const pluginMetadata = getPluginMetadata({ location, plugin })
+  const envMetadata = getEnvMetadata(childEnv)
+  const locationMetadata = getLocationMetadata(location, envMetadata)
+  return { location: locationMetadata, ...pluginMetadata, tsConfig, env: envMetadata, other: { groupingHash } }
+}
+
+const getPluginMetadata = function ({ location, plugin }) {
+  if (plugin === undefined) {
+    return {}
+  }
+
+  const { pluginPackageJson, ...pluginA } = plugin
+  const homepage = getHomepage(pluginPackageJson, location)
+  return { plugin: { ...pluginA, homepage }, pluginPackageJson }
+}
+
+const getApp = function () {
+  return {
+    osName: osType(),
+    osVersion: osName(),
+    freeMemory: freemem(),
+    totalMemory: totalmem(),
+  }
+}
+
+// `error.name` is shown proeminently in the Bugsnag UI. We need to update it to
+// match error `type` since it is more granular and useful.
+// But we change it back after Bugsnag is done reporting.
+const updateErrorName = function (error, type) {
+  const { name } = error
+  // This might fail if `name` is a getter or is non-writable.
+  try {
+    error.name = type
+  } catch {}
+  return name
+}
+
+const reportError = async function ({ errorMonitor, error, logs, testOpts, eventProps }) {
+  if (testOpts.errorMonitor) {
+    printEventForTest(error, eventProps, logs)
+    return
+  }
+
+  try {
+    await promisify(errorMonitor.notify)(error, (event) => onError(event, eventProps))
+    // Failsafe
+  } catch {
+    log(logs, `Error monitor could not notify\n${error.stack}`)
+  }
+}
+
+const getEventProps = function ({ severity, group, groupingHash, metadata, app }) {
+  // `unhandled` is used to calculate Releases "stabiity score", which is
+  // basically the percentage of unhandled errors. Since we handle all errors,
+  // we need to implement this according to error types.
+  const unhandled = severity === 'error'
+  return { severity, context: group, groupingHash, _metadata: metadata, app, unhandled }
+}
+
+// Add more information to Bugsnag events
+const onError = function (event, eventProps) {
+  // Bugsnag client requires directly mutating the `event`
+  // eslint-disable-next-line fp/no-mutating-assign
+  Object.assign(event, {
+    ...eventProps,
+    unhandled: event.unhandled || eventProps.unhandled,
+    // eslint-disable-next-line no-underscore-dangle
+    _metadata: { ...event._metadata, ...eventProps._metadata },
+    app: { ...event.app, ...eventProps.app },
+  })
+  return true
+}

package/src/error/monitor/start.js

@@ -0,0 +1,69 @@
+import { fileURLToPath } from 'url'
+
+import Bugsnag from '@bugsnag/js'
+import memoizeOne from 'memoize-one'
+
+import { log } from '../../log/logger.js'
+import { ROOT_PACKAGE_JSON } from '../../utils/json.js'
+
+const projectRoot = fileURLToPath(new URL('../../..', import.meta.url))
+
+// Start a client to monitor errors
+export const startErrorMonitor = function ({ flags: { mode }, logs, bugsnagKey }) {
+  if (!bugsnagKey) {
+    return
+  }
+
+  const isTest = isBugsnagTest(bugsnagKey)
+  const releaseStage = getReleaseStage(mode)
+  const logger = getLogger(logs, isTest)
+  try {
+    const errorMonitor = startBugsnag({
+      apiKey: bugsnagKey,
+      appVersion: `${ROOT_PACKAGE_JSON.name} ${ROOT_PACKAGE_JSON.version}`,
+      appType: ROOT_PACKAGE_JSON.name,
+      releaseStage,
+      logger,
+      projectRoot,
+    })
+
+    // Allows knowing the percentage of failed builds per release
+    if (!isTest) {
+      errorMonitor.startSession()
+    }
+
+    return errorMonitor
+    // Failsafe
+  } catch (error) {
+    log(logs, `Error monitor could not start\n${error.stack}`)
+  }
+}
+
+const isBugsnagTest = function (bugsnagKey) {
+  return bugsnagKey === BUGSNAG_TEST_KEY
+}
+
+const BUGSNAG_TEST_KEY = '00000000000000000000000000000000'
+
+// Bugsnag.start() caches a global instance and warns on duplicate calls.
+// This ensures the warning message is not shown when calling the main function
+// several times.
+const startBugsnag = memoizeOne(Bugsnag.start.bind(Bugsnag), () => true)
+
+// Based the release stage on the `mode`
+const getReleaseStage = function (mode = DEFAULT_RELEASE_STAGE) {
+  return mode
+}
+
+const DEFAULT_RELEASE_STAGE = 'unknown'
+
+// We don't want Bugsnag logs except on warnings/errors.
+// We also want to use our own `log` utility, unprefixed.
+// In tests, we don't print Bugsnag because it sometimes randomly fails to
+// send sessions, which prints warning messags in test snapshots.
+const getLogger = function (logs, isTest) {
+  const logFunc = isTest ? noop : log.bind(null, logs)
+  return { debug: noop, info: noop, warn: logFunc, error: logFunc }
+}
+
+const noop = function () {}

package/src/error/parse/clean_stack.js

@@ -0,0 +1,87 @@
+import { cwd } from 'process'
+
+import cleanStack from 'clean-stack'
+import stripAnsi from 'strip-ansi'
+
+// Clean stack traces:
+//  - remove our internal code, e.g. the logic spawning plugins
+//  - remove node modules and Node.js internals
+//  - strip process.cwd()
+//  - remove colors
+// Keep non stack trace lines as is.
+// We do not use libraries that patch `Error.prepareStackTrace()` because they
+// tend to create issues.
+export const cleanStacks = function ({ stack, rawStack, debug }) {
+  if (stack === undefined) {
+    return
+  }
+
+  // Internal errors / bugs keep their full stack trace
+  // Same in debug mode
+  if (rawStack || debug) {
+    return stack
+  }
+
+  return stack.split('\n').reduce(cleanStackLine, '').replace(INITIAL_NEWLINES, '')
+}
+
+const cleanStackLine = function (lines, line) {
+  const lineA = line.replace(getCwd(), '')
+  const lineB = stripAnsi(lineA)
+
+  if (!STACK_LINE_REGEXP.test(lineB)) {
+    return `${lines}\n${lineA}`
+  }
+
+  if (shouldRemoveStackLine(lineB)) {
+    return lines
+  }
+
+  const lineC = cleanStack(lineB)
+
+  if (lineC === '') {
+    return lines
+  }
+
+  return `${lines}\n${lineC}`
+}
+
+// `process.cwd()` can sometimes fail: directory name too long, current
+// directory has been removed, access denied.
+const getCwd = function () {
+  try {
+    return cwd()
+  } catch {
+    return ''
+  }
+}
+
+// Check if a line is part of a stack trace
+const STACK_LINE_REGEXP = /^\s+at /
+
+const shouldRemoveStackLine = function (line) {
+  const lineA = normalizePathSlashes(line)
+  return INTERNAL_STACK_STRINGS.some((stackString) => lineA.includes(stackString)) || INTERNAL_STACK_REGEXP.test(lineA)
+}
+
+const INTERNAL_STACK_STRINGS = [
+  // Anonymous function
+  '<anonymous>',
+  '(index 0)',
+  // nyc internal code
+  'node_modules/append-transform',
+  'node_modules/signal-exit',
+  // Node internals
+  '(node:',
+]
+
+// This is only needed for local builds and tests
+const INTERNAL_STACK_REGEXP = /(packages|@netlify)\/build\/(src\/|tests\/helpers\/|tests\/.*\/tests.js|node_modules)/
+
+const INITIAL_NEWLINES = /^\n+/
+
+const normalizePathSlashes = function (line) {
+  return line.replace(BACKLASH_REGEXP, '/')
+}
+
+const BACKLASH_REGEXP = /\\/g

package/src/error/parse/location.js

@@ -0,0 +1,62 @@
+import { getBuildCommandDescription, getPluginOrigin } from '../../log/description.js'
+
+// Retrieve an error's location to print in logs.
+// Each error type has its own logic (or none if there's no location to print).
+export const getLocationInfo = function ({ stack, location, locationType }) {
+  // No location to print
+  if (locationType === undefined && stack === undefined) {
+    return
+  }
+
+  // The location is only the stack trace
+  if (locationType === undefined) {
+    return stack
+  }
+
+  const locationString = LOCATIONS[locationType](location)
+  return [locationString, stack].filter(Boolean).join('\n')
+}
+
+const getBuildCommandLocation = function ({ buildCommand, buildCommandOrigin }) {
+  const description = getBuildCommandDescription(buildCommandOrigin)
+  return `In ${description}:
+${buildCommand}`
+}
+
+const getFunctionsBundlingLocation = function ({ functionName, functionType }) {
+  if (functionType === 'edge') {
+    return 'While bundling edge function'
+  }
+
+  return `While bundling function "${functionName}"`
+}
+
+const getCoreStepLocation = function ({ coreStepName }) {
+  return `During ${coreStepName}`
+}
+
+const getBuildFailLocation = function ({ event, packageName, loadedFrom, origin }) {
+  const eventMessage = getEventMessage(event)
+  const pluginOrigin = getPluginOrigin(loadedFrom, origin)
+  return `${eventMessage} "${packageName}" ${pluginOrigin}`
+}
+
+const getEventMessage = function (event) {
+  if (event === 'load') {
+    return `While loading`
+  }
+
+  return `In "${event}" event in`
+}
+
+const getApiLocation = function ({ endpoint, parameters }) {
+  return `While calling the Netlify API endpoint '${endpoint}' with:\n${JSON.stringify(parameters, null, 2)}`
+}
+
+const LOCATIONS = {
+  buildCommand: getBuildCommandLocation,
+  functionsBundling: getFunctionsBundlingLocation,
+  coreStep: getCoreStepLocation,
+  buildFail: getBuildFailLocation,
+  api: getApiLocation,
+}

package/src/error/parse/normalize.js

@@ -0,0 +1,29 @@
+// Ensure error is an `Error` instance.
+// If is an `Error` instance but is missing usual `Error` properties, we make
+// sure its static properties are preserved.
+export const normalizeError = function (error) {
+  if (Array.isArray(error)) {
+    return normalizeArray(error)
+  }
+
+  if (!(error instanceof Error)) {
+    return new Error(String(error))
+  }
+
+  if (typeof error.message !== 'string') {
+    error.message = String(error)
+  }
+
+  if (typeof error.stack !== 'string') {
+    Error.captureStackTrace(error, normalizeError)
+  }
+
+  return error
+}
+
+// Some libraries throw arrays of Errors
+const normalizeArray = function (errorArray) {
+  const [error, ...errors] = errorArray.map(normalizeError)
+  error.errors = errors
+  return error
+}