@netlify/build 0.4.48 → 1.0.0-dl-test

package/src/error/monitor/report.js

@@ -1,140 +0,0 @@
-const { type, freemem, totalmem } = require('os')
-const { env } = require('process')
-const { promisify } = require('util')
-
-const osName = require('os-name')
-
-const { getEnvMetadata } = require('../../env/metadata')
-const { log } = require('../../log/logger.js')
-const { getErrorInfo } = require('../info')
-const { getHomepage } = require('../parse/plugin')
-const { getTypeInfo } = require('../type')
-
-const { normalizeGroupingMessage } = require('./normalize')
-const { printEventForTest } = require('./print')
-
-// Report a build failure for monitoring purpose
-const reportBuildError = async function(error, errorMonitor) {
-  if (errorMonitor === undefined) {
-    return
-  }
-
-  const errorInfo = getErrorInfo(error)
-  const { type, severity, title, group = title } = getTypeInfo(errorInfo)
-  const severityA = getSeverity(severity, errorInfo)
-  const groupA = getGroup(group, errorInfo)
-  const groupingHash = getGroupingHash(groupA, error, type)
-  const metadata = getMetadata(errorInfo, groupingHash)
-  const app = getApp()
-
-  const errorName = updateErrorName(error, type)
-  try {
-    await reportError({
-      errorMonitor,
-      error,
-      severity: severityA,
-      group: groupA,
-      groupingHash,
-      metadata,
-      app,
-    })
-  } 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') {
-    return 'info'
-  }
-
-  return severity
-}
-
-const getGroup = function(group, errorInfo) {
-  if (typeof group !== 'function') {
-    return group
-  }
-
-  return group(errorInfo)
-}
-
-const getGroupingHash = function(group, error, type) {
-  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, childEnv }, groupingHash) {
-  const pluginMetadata = getPluginMetadata(plugin)
-  const envMetadata = getEnvMetadata(childEnv)
-  return { location, ...pluginMetadata, env: envMetadata, other: { groupingHash } }
-}
-
-const getPluginMetadata = function(plugin) {
-  if (plugin === undefined) {
-    return {}
-  }
-
-  const { packageJson } = plugin
-  const homepage = getHomepage(packageJson)
-  return { plugin: { ...plugin, homepage }, packageJson }
-}
-
-const getApp = function() {
-  return {
-    osName: type(),
-    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
-  error.name = type
-  return name
-}
-
-const reportError = async function({ errorMonitor, error, severity, group, groupingHash, metadata, app }) {
-  try {
-    await promisify(errorMonitor.notify)(error, event =>
-      onError({ event, severity, group, groupingHash, metadata, app }),
-    )
-    // Failsafe
-  } catch (error) {
-    log(`Error monitor could not notify\n${error.stack}`)
-    return
-  }
-}
-
-// Add more information to Bugsnag events
-const onError = function({ event, 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 = event.unhandled || severity === 'error'
-
-  Object.assign(event, {
-    severity,
-    context: group,
-    groupingHash,
-    _metadata: { ...event._metadata, ...metadata },
-    app: { ...event.app, ...app },
-    unhandled,
-  })
-
-  if (env.NETLIFY_BUILD_TEST === '1') {
-    printEventForTest(event)
-    return false
-  }
-
-  return true
-}
-
-module.exports = { reportBuildError }

package/src/error/monitor/start.js

@@ -1,50 +0,0 @@
-const { env } = require('process')
-
-const Bugsnag = require('@bugsnag/js')
-
-const { name, version } = require('../../../package.json')
-const { log } = require('../../log/logger.js')
-
-const projectRoot = `${__dirname}/../../..`
-
-// Start a client to monitor errors
-const startErrorMonitor = function({ mode }) {
-  const apiKey = env.BUGSNAG_KEY
-  if (!apiKey) {
-    return
-  }
-
-  const releaseStage = getReleaseStage(mode)
-  try {
-    const errorMonitor = Bugsnag.start({
-      apiKey,
-      appVersion: `${name} ${version}`,
-      appType: name,
-      releaseStage,
-      logger,
-      projectRoot,
-    })
-
-    // Allows knowing the percentage of failed builds per release
-    errorMonitor.startSession()
-
-    return errorMonitor
-    // Failsafe
-  } catch (error) {
-    log(`Error monitor could not start\n${error.stack}`)
-    return
-  }
-}
-
-// 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.
-const logger = { debug() {}, info() {}, warn: log, error: log }
-
-module.exports = { startErrorMonitor }

package/src/error/parse/clean_stack.js

@@ -1,86 +0,0 @@
-const { cwd } = require('process')
-
-const cleanStack = require('clean-stack')
-const stripAnsi = require('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.
-const cleanStacks = function(string, rawStack) {
-  // Internal errors / bugs keep their full stack trace
-  if (rawStack || string === undefined) {
-    return string
-  }
-
-  return String(string)
-    .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 (isUselessStack(lineB)) {
-    return lines
-  }
-
-  if (isInternalStack(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 (error) {
-    return ''
-  }
-}
-
-// Check if a line is part of a stack trace
-const STACK_LINE_REGEXP = /^\s+at /
-
-const isUselessStack = function(line) {
-  const lineA = line.replace(BACKLASH_REGEXP, '/')
-  return (
-    // Anonymous function
-    lineA.includes('<anonymous>') ||
-    // nyc internal code
-    lineA.includes('node_modules/append-transform') ||
-    lineA.includes('node_modules/signal-exit')
-  )
-}
-
-const BACKLASH_REGEXP = /\\/g
-
-const isInternalStack = function(line) {
-  // This is only needed for local builds
-  return INTERNAL_STACK_REGEXP.test(line)
-}
-
-const INTERNAL_STACK_REGEXP = /(packages|@netlify)[/\\]build[/\\](src|node_modules)[/\\]/
-
-const INITIAL_NEWLINES = /^\n+/
-
-module.exports = { cleanStacks }

package/src/error/parse/location.js

@@ -1,50 +0,0 @@
-const { getBuildCommandDescription, getPluginOrigin } = require('../../log/description')
-
-// 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).
-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, configPath }) {
-  const description = getBuildCommandDescription(configPath)
-  return `In ${description}:
-${buildCommand}`
-}
-
-const getBuildFailLocation = function({ event, package, loadedFrom, origin }) {
-  const eventMessage = getEventMessage(event)
-  const pluginOrigin = getPluginOrigin(loadedFrom, origin)
-  return `${eventMessage} "${package}" ${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,
-  buildFail: getBuildFailLocation,
-  api: getApiLocation,
-}
-
-module.exports = { getLocationInfo }

package/src/error/parse/parse.js

@@ -1,87 +0,0 @@
-const { getErrorInfo } = require('../info')
-const { getTypeInfo } = require('../type')
-
-const { getLocationInfo } = require('./location')
-const { getPluginInfo } = require('./plugin')
-const { getErrorProps } = require('./properties')
-const { getStackInfo } = require('./stack')
-
-// Parse all error information into a normalized sets of properties
-const parseError = function({ error, colors }) {
-  const {
-    message,
-    stack,
-    netlifyConfig,
-    childEnv,
-    errorProps,
-    errorInfo,
-    errorInfo: { location = {}, plugin = {} },
-    state,
-    title,
-    isSuccess,
-    stackType,
-    locationType,
-    showErrorProps,
-    rawStack,
-  } = parseErrorInfo(error)
-
-  const titleA = getTitle(title, errorInfo)
-
-  const { message: messageA, stack: stackA } = getStackInfo({ message, stack, stackType, rawStack, isSuccess })
-
-  const pluginInfo = getPluginInfo(plugin, location)
-  const locationInfo = getLocationInfo({ stack: stackA, location, locationType })
-  const errorPropsA = getErrorProps({ errorProps, showErrorProps, colors })
-  return {
-    state,
-    title: titleA,
-    message: messageA,
-    pluginInfo,
-    locationInfo,
-    netlifyConfig,
-    childEnv,
-    errorProps: errorPropsA,
-    isSuccess,
-  }
-}
-
-// Parse error instance into all the basic properties containing information
-const parseErrorInfo = function(error) {
-  const { message, stack, netlifyConfig, childEnv, ...errorProps } = normalizeError(error)
-  const errorInfo = getErrorInfo(errorProps)
-  const { state, title, isSuccess, stackType, locationType, showErrorProps, rawStack } = getTypeInfo(errorInfo)
-  return {
-    message,
-    stack,
-    netlifyConfig,
-    childEnv,
-    errorProps,
-    errorInfo,
-    state,
-    title,
-    isSuccess,
-    stackType,
-    locationType,
-    showErrorProps,
-    rawStack,
-  }
-}
-
-const normalizeError = function(error) {
-  if (error instanceof Error) {
-    return error
-  }
-
-  return new Error(String(error))
-}
-
-// Retrieve title to print in logs
-const getTitle = function(title, errorInfo) {
-  if (typeof title !== 'function') {
-    return title
-  }
-
-  return title(errorInfo)
-}
-
-module.exports = { parseError }

package/src/error/parse/plugin.js

@@ -1,68 +0,0 @@
-// Retrieve plugin's package.json details to include in error messages.
-// Please note `packageJson` has been normalized by `normalize-package-data`.
-const getPluginInfo = function({ packageJson = {} }, { package }) {
-  if (Object.keys(packageJson).length === 0) {
-    return
-  }
-
-  return Object.entries(FIELDS)
-    .map(([name, getField]) => serializeField({ name, getField, packageJson, package }))
-    .filter(Boolean)
-    .join('\n')
-}
-
-// Serialize a single package.json field
-const serializeField = function({ name, getField, packageJson, package }) {
-  const field = getField(packageJson, package)
-  if (field === undefined) {
-    return
-  }
-
-  const nameA = `${name}:`.padEnd(NAME_PADDING)
-  return `${nameA}${field}`
-}
-
-const NAME_PADDING = 16
-
-const getPackage = function(packageJson, package) {
-  return package
-}
-
-const getVersion = function({ version }) {
-  if (version === '') {
-    return
-  }
-
-  return version
-}
-
-const getHomepage = function(packageJson = {}) {
-  return getRepository(packageJson) || getNpmLink(packageJson) || getIssuesLink(packageJson)
-}
-
-const getRepository = function({ repository: { url } = {} }) {
-  return url
-}
-
-const getNpmLink = function({ name }) {
-  if (!name) {
-    return
-  }
-
-  return `https://www.npmjs.com/package/${name}`
-}
-
-const getIssuesLink = function({ bugs: { url } = {} }) {
-  return url
-}
-
-// List of package.json to serialize
-const FIELDS = {
-  Package: getPackage,
-  Version: getVersion,
-  Repository: getRepository,
-  'npm link': getNpmLink,
-  'Report issues': getIssuesLink,
-}
-
-module.exports = { getPluginInfo, getHomepage }

package/src/error/parse/properties.js

@@ -1,20 +0,0 @@
-const { inspect } = require('util')
-
-const { omit } = require('../../utils/omit')
-const { INFO_SYM } = require('../info')
-
-// In uncaught exceptions, print error static properties
-const getErrorProps = function({ errorProps, showErrorProps, colors }) {
-  const errorPropsA = omit(errorProps, CLEANED_ERROR_PROPS)
-
-  if (!showErrorProps || Object.keys(errorPropsA).length === 0) {
-    return
-  }
-
-  return inspect(errorPropsA, { colors, depth: 5 })
-}
-
-// Remove error static properties that should not be logged
-const CLEANED_ERROR_PROPS = [INFO_SYM, 'requireStack']
-
-module.exports = { getErrorProps }

package/src/error/parse/serialize_log.js

@@ -1,46 +0,0 @@
-const { THEME } = require('../../log/theme')
-
-const { parseError } = require('./parse')
-
-// Serialize an error object into a title|body string to print in logs
-const serializeLogError = function(error) {
-  const { title, message, pluginInfo, locationInfo, netlifyConfig, errorProps, isSuccess } = parseError({
-    error,
-    colors: true,
-  })
-  const body = getBody({ message, pluginInfo, locationInfo, errorProps, isSuccess })
-  return { title, body, isSuccess, netlifyConfig }
-}
-
-const getBody = function({ message, pluginInfo, locationInfo, errorProps, isSuccess }) {
-  if (isSuccess) {
-    return message
-  }
-
-  return Object.entries({
-    message,
-    pluginInfo,
-    locationInfo,
-    errorProps,
-  })
-    .filter(blockHasValue)
-    .map(serializeBlock)
-    .join('\n\n')
-}
-
-const blockHasValue = function([, value]) {
-  return value !== undefined
-}
-
-const serializeBlock = function([key, value]) {
-  return `${THEME.errorSubHeader(LOG_BLOCK_NAMES[key])}\n${value}`
-}
-
-const LOG_BLOCK_NAMES = {
-  message: 'Error message',
-  pluginInfo: 'Plugin details',
-  locationInfo: 'Error location',
-  errorProps: 'Error properties',
-}
-
-module.exports = { serializeLogError }

package/src/error/parse/serialize_status.js

@@ -1,28 +0,0 @@
-const { parseError } = require('./parse')
-
-// Serialize an error object to `statuses` properties
-const serializeErrorStatus = function(error) {
-  const { state, title, message, locationInfo, errorProps } = parseError({ error, colors: false })
-  const text = getText({ locationInfo, errorProps })
-  return { state, title, summary: message, text }
-}
-
-const getText = function({ locationInfo, errorProps }) {
-  const parts = [locationInfo, getErrorProps(errorProps)].filter(Boolean)
-
-  if (parts.length === 0) {
-    return
-  }
-
-  return parts.join('\n\n')
-}
-
-const getErrorProps = function(errorProps) {
-  if (errorProps === undefined) {
-    return
-  }
-
-  return `Error properties:\n${errorProps}`
-}
-
-module.exports = { serializeErrorStatus }

package/src/error/parse/stack.js

@@ -1,45 +0,0 @@
-const { cleanStacks } = require('./clean_stack')
-
-// Retrieve the stack trace
-const getStackInfo = function({ message, stack, stackType, rawStack, isSuccess }) {
-  const { message: messageA, stack: stackA } = splitStackInfo({ message, stack, stackType })
-  const messageB = isSuccess ? messageA.replace(SUCCESS_ERROR_NAME, '') : messageA
-  const stackB = cleanStacks(stackA, rawStack)
-  return { message: messageB, stack: stackB }
-}
-
-const splitStackInfo = function({ message, stack, stackType }) {
-  // Some errors should not show any stack trace
-  if (stackType === 'none') {
-    return { message }
-  }
-
-  // Some errors have their stack trace inside `error.message` instead of
-  // `error.stack` due to IPC
-  if (stackType === 'message') {
-    return splitStack(message)
-  }
-
-  return splitStack(stack)
-}
-
-const splitStack = function(string) {
-  const lines = string.split('\n')
-  const stackIndex = lines.findIndex(isStackTrace)
-
-  if (stackIndex === -1) {
-    return { message: string }
-  }
-
-  const messageA = lines.slice(0, stackIndex).join('\n')
-  const stackA = lines.slice(stackIndex).join('\n')
-  return { message: messageA, stack: stackA }
-}
-
-const isStackTrace = function(line) {
-  return line.trim().startsWith('at ')
-}
-
-const SUCCESS_ERROR_NAME = 'Error: '
-
-module.exports = { getStackInfo }

package/src/error/process.js

@@ -1,13 +0,0 @@
-const {
-  env: { NETLIFY_BUILD_DEBUG_PROCESS_ERRORS },
-} = require('process')
-
-const logProcessErrors = require('log-process-errors')
-
-const { hasColors } = require('../log/colors')
-
-// Print stack traces of warnings.
-// This is for debugging purpose only, so behind an environment variable.
-if (NETLIFY_BUILD_DEBUG_PROCESS_ERRORS === '1') {
-  logProcessErrors({ colors: hasColors() })
-}