@netlify/build 0.5.0 → 1.0.0-dl-test

package/lib/core/severity.js

@@ -0,0 +1,21 @@
+const SEVERITY_MAP = {
+    success: { severityCode: 0, status: 'success' },
+    none: { severityCode: 1, status: 'cancelled' },
+    info: { severityCode: 2, status: 'user-error' },
+    warning: { severityCode: 3, status: 'plugin-error' },
+    error: { severityCode: 4, status: 'system-error' },
+};
+const SUCCESS_SEVERITY = 'success';
+/** Indicates a bug in our codebase */
+const FALLBACK_SEVERITY = 'error';
+/** Map error severities to exit codes and status (used for telemetry purposes) */
+export const FALLBACK_SEVERITY_ENTRY = SEVERITY_MAP[FALLBACK_SEVERITY];
+/**
+ * Used to extract exit codes and respective status strings
+ * 1|2|3 indicate whether this was a user|plugin|system error.
+ */
+export const getSeverity = (severity = FALLBACK_SEVERITY) => {
+    const severityEntry = severity in SEVERITY_MAP ? SEVERITY_MAP[severity] : FALLBACK_SEVERITY_ENTRY;
+    const success = severity === SUCCESS_SEVERITY;
+    return { success, ...severityEntry };
+};

package/lib/core/types.js

@@ -0,0 +1,8 @@
+export var SeverityCode;
+(function (SeverityCode) {
+    SeverityCode[SeverityCode["success"] = 1] = "success";
+    SeverityCode[SeverityCode["buildCancelled"] = 2] = "buildCancelled";
+    SeverityCode[SeverityCode["userError"] = 3] = "userError";
+    SeverityCode[SeverityCode["pluginError"] = 4] = "pluginError";
+    SeverityCode[SeverityCode["systemError"] = 5] = "systemError";
+})(SeverityCode = SeverityCode || (SeverityCode = {}));

package/lib/core/user_node_version.js

@@ -0,0 +1,32 @@
+import { version as currentVersion, execPath } from 'process';
+import { execa } from 'execa';
+import semver from 'semver';
+import { addErrorInfo } from '../error/info.js';
+// Retrieve Node.js version if the Node.js path is using nvm.
+// `node.exe` on Windows, `bin/node` on Unix.
+const NVM_NODE_VERSION_REGEXP = /[/\\]v(\d+\.\d+\.\d+)[/\\](bin[/\\]node|node.exe)$/;
+// Retrieve Node.js version from current process
+const getCurrentNodeVersion = function () {
+    return semver.clean(currentVersion);
+};
+// Retrieve Node.js version from `--node-path` or fallback to extracting the current Node.js process version
+export const getUserNodeVersion = async function (nodePath) {
+    // No `--node-path` CLI flag, use the current node process version
+    if (nodePath === execPath) {
+        return getCurrentNodeVersion();
+    }
+    // Extract version from path
+    const result = NVM_NODE_VERSION_REGEXP.exec(nodePath);
+    if (result !== null) {
+        return result[1];
+    }
+    // Fallback to actually running `node --version` with the given nodePath
+    const { stdout } = await execa(nodePath, ['--version'], { reject: false });
+    const version = semver.clean(stdout);
+    if (version === null) {
+        const error = new Error(`Invalid --node-path CLI flag: ${nodePath}`);
+        addErrorInfo(error, { type: 'resolveConfig' });
+        throw error;
+    }
+    return version;
+};

package/lib/env/changes.js

@@ -0,0 +1,43 @@
+import { env } from 'process';
+import filterObj from 'filter-obj';
+import mapObj from 'map-obj';
+// If plugins modify `process.env`, this is propagated in other plugins and in
+// `build.command`. Since those are different processes, we figure out when they
+// do this and communicate the new `process.env` to other processes.
+export const getNewEnvChanges = function (envBefore, netlifyConfig, netlifyConfigCopy) {
+    const processEnvChanges = diffEnv(envBefore, env);
+    const netlifyConfigEnvChanges = diffEnv(netlifyConfig.build.environment, netlifyConfigCopy.build.environment);
+    return { ...processEnvChanges, ...netlifyConfigEnvChanges };
+};
+const diffEnv = function (envBefore, envAfter) {
+    const envChanges = filterObj(envAfter, (name, value) => value !== envBefore[name]);
+    const deletedEnv = filterObj(envBefore, (name) => envAfter[name] === undefined);
+    const deletedEnvA = mapObj(deletedEnv, setToNull);
+    return { ...envChanges, ...deletedEnvA };
+};
+// `undefined` is not JSON-serializable (which is used in process IPC), so we
+// convert it to `null`
+// Note: `process.env[name] = undefined` actually does
+// `process.env[name] = 'undefined'` in Node.js.
+const setToNull = function (name) {
+    return [name, null];
+};
+// Set `process.env` changes from a previous different plugin.
+// Can also merge with a `currentEnv` plain object instead of `process.env`.
+export const setEnvChanges = function (envChanges, currentEnv = env) {
+    Object.entries(envChanges).forEach(([name, value]) => {
+        setEnvChange(name, value, currentEnv);
+    });
+    return { ...currentEnv };
+};
+const setEnvChange = function (name, value, currentEnv) {
+    if (currentEnv[name] === value) {
+        return;
+    }
+    if (value === null) {
+        // `currentEnv` is a mutable variable
+        delete currentEnv[name];
+        return;
+    }
+    currentEnv[name] = value;
+};

package/lib/env/main.js

@@ -0,0 +1,14 @@
+import { env } from 'process';
+import filterObj from 'filter-obj';
+import { getParentColorEnv } from '../log/colors.js';
+// Retrieve the environment variables passed to plugins and `build.command`
+// When run locally, this tries to emulate the production environment.
+export const getChildEnv = function ({ envOpt, env: allConfigEnv }) {
+    const parentColorEnv = getParentColorEnv();
+    const parentEnv = { ...env, ...allConfigEnv, ...envOpt, ...parentColorEnv };
+    return filterObj(parentEnv, shouldKeepEnv);
+};
+const shouldKeepEnv = function (key) {
+    return !REMOVED_PARENT_ENV.has(key.toLowerCase());
+};
+const REMOVED_PARENT_ENV = new Set(['bugsnag_key']);

package/lib/env/metadata.js

@@ -0,0 +1,68 @@
+import { env } from 'process';
+import filterObj from 'filter-obj';
+// Retrieve environment variables used in error monitoring
+export const getEnvMetadata = function (childEnv = env) {
+    return filterObj(childEnv, isEnvMetadata);
+};
+const isEnvMetadata = function (name) {
+    return ENVIRONMENT_VARIABLES.has(name);
+};
+// This is sorted by most useful in debugging to least
+const ENVIRONMENT_VARIABLES = new Set([
+    // URL and IDs
+    'BUILD_ID',
+    'DEPLOY_ID',
+    'SITE_NAME',
+    'SITE_ID',
+    'REPOSITORY_URL',
+    'URL',
+    'DEPLOY_URL',
+    'DEPLOY_PRIME_URL',
+    // Git
+    'HEAD',
+    'COMMIT_REF',
+    'CACHED_COMMIT_REF',
+    'BRANCH',
+    'CONTEXT',
+    'PULL_REQUEST',
+    'REVIEW_ID',
+    // Node
+    'NODE_VERSION',
+    'AWS_LAMBDA_JS_RUNTIME',
+    'NPM_VERSION',
+    'YARN_VERSION',
+    'NPM_FLAGS',
+    'YARN_FLAGS',
+    'NVM_FLAGS',
+    'NODE_ENV',
+    // Go
+    'GO_VERSION',
+    'GO_IMPORT_PATH',
+    'GOCACHE',
+    'GOPATH',
+    'GOROOT',
+    // Ruby
+    'RUBY_VERSION',
+    'GEM_HOME',
+    'GEM_PATH',
+    'GIMME_GCO_ENABLED',
+    'GIMME_ENV_PREFIX',
+    'GIMME_GO_PREFIX',
+    'GIMME_NO_ENV_ALIAS',
+    'GIMME_TYPE',
+    'IRBRC',
+    'MY_RUBY_HOME',
+    // Hugo
+    'HUGO_VERSION',
+    // Java
+    'JAVA_VERSION',
+    // PHP
+    'PHP_VERSION',
+    // Python
+    'PIPENV_DEFAULT_PYTHON_VERSION',
+    'PIPENV_RUNTIME',
+    'PIPENV_VENV_IN_PROJECT',
+    // Git LFS
+    'GIT_LFS_ENABLED',
+    'GIT_LFS_FETCH_INCLUDE',
+]);

package/lib/error/api.js

@@ -0,0 +1,37 @@
+import isPlainObj from 'is-plain-obj';
+import mapObj from 'map-obj';
+import { addErrorInfo } from './info.js';
+// Wrap `api.*` methods so that they add more error information
+export const addApiErrorHandlers = function (api) {
+    if (api === undefined) {
+        return;
+    }
+    return mapObj(api, addErrorHandler);
+};
+const addErrorHandler = function (key, value) {
+    if (typeof value !== 'function') {
+        return [key, value];
+    }
+    const valueA = apiMethodHandler.bind(null, key, value);
+    return [key, valueA];
+};
+const apiMethodHandler = async function (endpoint, method, parameters, ...args) {
+    try {
+        return await method(parameters, ...args);
+    }
+    catch (error) {
+        redactError(error);
+        addErrorInfo(error, { type: 'api', location: { endpoint, parameters } });
+        throw error;
+    }
+};
+// Redact API token from the build logs
+const redactError = function (error) {
+    if (error instanceof Error &&
+        isPlainObj(error.data) &&
+        isPlainObj(error.data.headers) &&
+        typeof error.data.headers.Authorization === 'string') {
+        error.data.headers.Authorization = error.data.headers.Authorization.replace(HEX_REGEXP, 'HEX');
+    }
+};
+const HEX_REGEXP = /[\da-f]{6,}/g;

package/lib/error/build.js

@@ -0,0 +1,36 @@
+import safeJsonStringify from 'safe-json-stringify';
+import { CUSTOM_ERROR_KEY } from './info.js';
+// Retrieve error information from child process and re-build it in current
+// process. We need this since errors static properties are not kept by
+// `v8.serialize()`.
+export const jsonToError = function ({ name, message, stack, ...errorProps }) {
+    const error = new Error('');
+    assignErrorProps(error, { name, message, stack });
+    // Assign static error properties (if any)
+    // We need to mutate the `error` directly to preserve its `name`, `stack`, etc.
+    Object.assign(error, errorProps);
+    return error;
+};
+// Make sure `name`, `message` and `stack` are not enumerable
+const assignErrorProps = function (error, values) {
+    ERROR_PROPS.forEach((name) => {
+        assignErrorProp(error, name, values[name]);
+    });
+};
+const ERROR_PROPS = ['name', 'message', 'stack'];
+const assignErrorProp = function (error, name, value) {
+    // `Object.defineProperty()` requires direct mutation
+    Object.defineProperty(error, name, { value, enumerable: false, writable: true, configurable: true });
+};
+// Inverse of `jsonToError()`.
+export const errorToJson = function (error) {
+    const { name, message, stack, [CUSTOM_ERROR_KEY]: customError, ...errorProps } = error;
+    // diagnosticText is not enumerable in TSError, so we need to grab it manually. destructuring won't work.
+    if (error.diagnosticText) {
+        errorProps.diagnosticText = error.diagnosticText;
+    }
+    return {
+        ...safeJsonStringify.ensureProperties(errorProps),
+        ...safeJsonStringify.ensureProperties({ name, message, stack, [CUSTOM_ERROR_KEY]: customError }),
+    };
+};

package/lib/error/cancel.js

@@ -0,0 +1,7 @@
+// Cancel builds, for example when a plugin uses `utils.build.cancelBuild()`
+export const cancelBuild = async function ({ api, deployId }) {
+    if (api === undefined || !deployId) {
+        return;
+    }
+    await api.cancelSiteDeploy({ deploy_id: deployId });
+};

package/lib/error/colors.js

@@ -0,0 +1,9 @@
+import stripAnsi from 'strip-ansi';
+// Remove ANSI sequences from `error.message`
+export const removeErrorColors = function (error) {
+    if (!(error instanceof Error)) {
+        return;
+    }
+    error.message = stripAnsi(error.message);
+    error.stack = stripAnsi(error.stack);
+};

package/lib/error/handle.js

@@ -0,0 +1,44 @@
+import { cwd as getCwd } from 'process';
+import { pathExists } from 'path-exists';
+import { logBuildError } from '../log/messages/core.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, 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, logs, debug });
+    }
+    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/lib/error/info.js

@@ -0,0 +1,37 @@
+// 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/lib/error/monitor/location.js

@@ -0,0 +1,16 @@
+// 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/lib/error/monitor/normalize.js

@@ -0,0 +1,86 @@
+// 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/lib/error/monitor/print.js

@@ -0,0 +1,20 @@
+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/lib/error/monitor/report.js

@@ -0,0 +1,120 @@
+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 {
+        // continue regardless error
+    }
+    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`
+    Object.assign(event, {
+        ...eventProps,
+        unhandled: event.unhandled || eventProps.unhandled,
+        _metadata: { ...event._metadata, ...eventProps._metadata },
+        app: { ...event.app, ...eventProps.app },
+    });
+    return true;
+};