### function appError(display) Displays an "application" error.
329978
function appError(display) {
    if (display.output) {
      jitsu.log.error('Error output from application. This is usually a user error.');
      display.output.split('\n').forEach(function (line) {
        jitsu.log.error(line);
      })
    }

    return !display.solenoid
      ? unknownError(display.message, display.stack)
      : solenoidError(display);
  }
651372
function ErrorDisplay(player, options) {
    _classCallCheck(this, ErrorDisplay);

    var _this = _possibleConstructorReturn(this, _ModalDialog.call(this, player, options));

    _this.on(player, 'error', _this.open);
    return _this;
  }
863745
function _renderError(err, request) {
  const error = Boom.boomify(err);
  let status = error.output.statusCode;
  let rendered;
  let errorFile;

  if (this.local && status !== 404) {
    errorFile = resolve(dashboard.paths.views, 'errors', 'trace.html');
    rendered = Template.fromFile(errorFile).render({
      error: {
        status,
        title: error.output.payload.error,
        message: error.message,
        stack: error.stack,
      },
      request,
    });
  } else {
    const siteFile = resolve(this.paths.www, '_error.html');
    status = status === 404 ? 404 : 500;
    errorFile = status === 404 && fs.existsSync(siteFile) ? siteFile : resolve(dashboard.paths.views, 'errors', `${status}.html`);
    rendered = fs.readFileSync(errorFile, 'utf-8');
  }

  if (status !== 404) {
    Logger.extra(error.stack);
  }

  return [status, rendered];
}
75133
function error(err, req, res, next) {
  // log it
  if (!test) console.error(err.stack);

  // respond with 500 "Internal Server Error".
  res.status(500);
  res.send('Internal Server Error');
}
381650
function error(exception) {
		if (typeof customErrorHandler === 'function') {
			customErrorHandler(exception);
			return;
		}
		if (globalConfig.debug) {
			throw exception;
		} else {
			application.fire('error', {
				exception: exception
			});
		}
	}
472170
function displayErrorOnStatus(error) {
			var display = {};
			display.Severity = "Error"; //$NON-NLS-0$
			display.HTML = false;
			
			try {
				var resp = JSON.parse(error.responseText);
				display.Message = resp.DetailedMessage ? resp.DetailedMessage : 
					(resp.Message ? resp.Message : messages["Problem while performing the action"]);
			} catch (Exception) {
				display.Message = messages["Problem while performing the action"];
			}
			
			serviceRegistry.getService("orion.page.message").setProgressResult(display); //$NON-NLS-0$
		}
1111854
public static function catchFatalErrors(Application $app, $flush = true)
    {
        if (self::$screen !== null) {
            echo self::$screen;

            return;
        }

        // Get last error, if any
        $error = error_get_last();

        // Let Whoops handle AJAX requested fatal errors
        if (isset($_SERVER['HTTP_X_REQUESTED_WITH']) && $_SERVER['HTTP_X_REQUESTED_WITH'] == 'XMLHttpRequest') {
            return;
        }

        if (($error['type'] === E_ERROR || $error['type'] === E_PARSE)) {
            $html = self::$html;

            // Flush the early error data buffered output from catchFatalErrorsEarly()
            if ($flush) {
                Response::closeOutputBuffers(0, false);
            }

            // Detect if we're being called from a core, an extension or vendor
            $isBoltCoreError = strpos($error['file'], $app['resources']->getPath('rootpath/src'));
            $isVendorError = strpos($error['file'], $app['resources']->getPath('rootpath/vendor'));
            $isExtensionError = strpos($error['file'], $app['resources']->getPath('extensions'));

            // Assemble error trace
            $errorblock = '<code style="display:block; white-space: pre-wrap;">Error: ' . $error['message'] . '</code><br>';
            $errorblock .= '<code>File:  ' . $error['file'] . '</code><br>';
            $errorblock .= '<code>Line:  ' . $error['line'] . '</code><br><br>';

            if ($isBoltCoreError === 0) {
                $html = str_replace('%error_title%', 'PHP Fatal error: Bolt core', $html);
                $html = str_replace('%info%', '', $html);
                $message = $errorblock;
            } elseif ($isVendorError === 0) {
                $html = str_replace('%error_title%', 'PHP Fatal error: Vendor library', $html);
                $html = str_replace('%info%', '', $html);
                $message = $errorblock;
            } elseif ($isExtensionError === 0) {
                $base = str_replace($app['resources']->getPath('extensions'), '', $error['file']);
                $parts = explode(DIRECTORY_SEPARATOR, ltrim($base, '/'));
                $package = $parts[1] . '/' . $parts[2];

                $html = str_replace('%error_title%', 'PHP Fatal error: Bolt extensions', $html);
                $html = str_replace(
                    '%info%',
                    '<p>You will only be able to continue by disabling the extension by adding the following to app/config/extensions.yml:</p>' .
                    '<p><code style="display:block;">' . $parts[1] . ':<br>' .
                    '&nbsp;&nbsp;&nbsp;&nbsp;' . $parts[2] . ': false</code></p>',
                    $html
                );
                $message = '<h4>There is a fatal error in the \'' . $package . '\' extension ' .
                    'loaded on your Bolt Installation.<h4>';
                $message .= $errorblock;
            } else {
                // Unknown
                $html = str_replace('%error_title%', 'PHP Fatal error: Bolt generic', $html);
                $html = str_replace('%info%', '', $html);
                $message = $errorblock;
            }

            $message = nl2br($message);
            $html = str_replace('%error%', $message, $html);

            // Determine if we're on the command line. If so, don't output HTML.
            if (PHP_SAPI == 'cli') {
                $html = self::cleanHTML($html);
            }

            echo str_replace($app['resources']->getPath('rootpath'), '', $html);
        }

        echo self::$screen;
    }
195178
function ErrorStackParser$$parseOpera11(error) {
	            var filtered = _filter(error.stack.split('\n'), function (line) {
	                return !!line.match(FIREFOX_SAFARI_STACK_REGEXP) &&
	                    !line.match(/^Error created at/);
	            }, this);
	
	            return _map(filtered, function (line) {
	                var tokens = line.split('@');
	                var locationParts = this.extractLocation(tokens.pop());
	                var functionCall = (tokens.shift() || '');
	                var functionName = functionCall
	                        .replace(/<anonymous function(: (\w+))?>/, '$2')
	                        .replace(/\([^\)]*\)/g, '') || undefined;
	                var argsRaw;
	                if (functionCall.match(/\(([^\)]*)\)/)) {
	                    argsRaw = functionCall.replace(/^[^\(]+\(([^\)]*)\)$/, '$1');
	                }
	                var args = (argsRaw === undefined || argsRaw === '[arguments not available]') ? undefined : argsRaw.split(',');
	                return new StackFrame(functionName, args, locationParts[0], locationParts[1], locationParts[2], line);
	            }, this);
	        }
463918
function formatError (error, intend) {
  var message

  // Get the error message based on the error
  var errorMessage = 'NO ERROR MESSAGE FOUND'
  if (error.message && typeof error.message.toString === 'function') {
    errorMessage = error.message + ''
  }
  if (typeof error.inspect === 'function') {
    errorMessage = error.inspect() + ''
  }
  message = errorMessage

  // Build a clean stack trace (and extract the error message out of it,
  // if it is included in the stack trace, since it's usually better)
  var stack = error.stack || errorMessage
  var index = stack.indexOf(errorMessage)
  if (index !== -1) {
    index += errorMessage.length
    message = stack.slice(0, index)
    stack = stack.slice(index + 1)
  }

  // Add extra text for uncaught errors
  if (error.uncaught) {
    message = 'Uncaught ' + message
  }

  // Show diffs for assertion errors
  var actual = error.actual
  var expected = error.expected
  if (error.showDiff !== false && sameType(actual, expected) && expected !== undefined) {
    // Try and get a better message ouf of the assertion error
    // (this is when the user supplied his own description to "expect")
    var match = errorMessage.match(/^([^:]+): expected/)
    message = match ? match[1].red + '\n\n' : ''

    // Add the diff
    message += inlineDiff(error.actual, error.expected)
  } else {
    message = message.red
  }

  return {
    message: intendLines(message, false, intend),
    stack: intendLines(stack, true, intend)
  }
}
1298898
def runtime_error(self, msg, method):
        
        if self.testing:
            self._py3_wrapper.report_exception(msg)
            raise KeyboardInterrupt

        if self.error_hide:
            self.hide_errors()
            return

        # only show first line of error
        msg = msg.splitlines()[0]

        errors = [self.module_nice_name, u"{}: {}".format(self.module_nice_name, msg)]

        # if we have shown this error then keep in the same state
        if self.error_messages != errors:
            self.error_messages = errors
            self.error_index = 0
        self.error_output(self.error_messages[self.error_index], method)
687680
function lambdaError(fn, settings){
    var log = (settings && settings.log === false ? false : true);
    var map = (settings && settings.map ? settings.map : undefined);
    var exclude = (settings && settings.exclude ? settings.exclude : undefined);
    
    return (event, context, callback) => {
        fn(event, context, (err, result) => {
            if(err){
                if(log){
                    console.error(Errors.stack(err));
                }
                
                if(typeof err !== 'object'){
                    console.error('Error must be an object:', err);
                    err = new InvalidErrorValue(err);
                }
                
                return callback(Errors.json(err, false, map, exclude));
            }
            
            return callback(null, result);
        });
    };
}
480761
function formatError(error) {
        function localize(key) {
            if (Strings[key]) {
                return Strings[key];
            }
            console.log("Unknown installation error", key);
            return Strings.UNKNOWN_ERROR;
        }

        if (Array.isArray(error)) {
            error[0] = localize(error[0]);
            return StringUtils.format.apply(window, error);
        } else {
            return localize(error);
        }
    }
15642
function Error($err,$fn)
	{
	global $_ADODB_ACTIVE_DBS;

		$fn = get_class($this).'::'.$fn;
		$this->_lasterr = $fn.': '.$err;

		if ($this->_dbat < 0) {
			$db = false;
		}
		else {
			$activedb = $_ADODB_ACTIVE_DBS[$this->_dbat];
			$db = $activedb->db;
		}

		if (function_exists('adodb_throw')) {
			if (!$db) {
				adodb_throw('ADOdb_Active_Record', $fn, -1, $err, 0, 0, false);
			}
			else {
				adodb_throw($db->databaseType, $fn, -1, $err, 0, 0, $db);
			}
		} else {
			if (!$db || $db->debug) {
				ADOConnection::outp($this->_lasterr);
			}
		}

	}
1133285
function aError(errorObject){
  if(!terminal.symbolProgress) terminal.symbolProgress="? ";
  if(errorObject.aux){
    if(!terminal.colors.aux) terminal.colors.aux= chalk.white;
    console.log(terminal.colors.error(terminal.symbolProgress+" Error: "+errorObject.message)+ " " +terminal.colors.aux(errorObject.aux));
    console.log();  
  }
  else{
    console.log(terminal.colors.error(terminal.symbolProgress+" Error: "+errorObject.message));
    console.log();
  }    
}
1079426
function showError(arg) {
        notifier.notify({
            title: 'Error',
            message: '' + arg,
            sound: 'Basso'
        })
        console.log(arg)
        this.emit('end');
    }
935708
function unhandledErrorListener(err, namespace) {
  console.error('[distribucache] (%s) error from an unhandled ' +
    '`error` event:\n', namespace, err && err.stack || err);
}
775887
function( error ) {
		if( error instanceof Buffer && error.toString().match( app.options.errorMessage ) ) {
			initialized( 'Development server has error.' );
		}
	}