This is like {#maruku_error} but will never raise.
357806
def maruku_recover(s, src=nil, con=nil, recover=nil)
      policy = get_setting(:on_error)

      case policy
      when :ignore
      when :raise, :warning
        tell_user create_frame(describe_error(s, src, con, recover))
      else
        raise "Unknown on_error policy: #{policy.inspect}"
      end
    end
214760
def assert_raises(expected=StandardError)
      begin
        yield
      rescue => actual
        return actual if actual.kind_of?(expected)
        raise Failure.new("Failure: Unexpected Exception", expected, actual)
      end
      raise Failure.new("Failure: No Exception", expected, "Nothing raised.")
    end
648230
function onEntityDeletionFailed( serverResponse ) {
			self.logInterface.error( serverResponse.data );
			self.scope.$emit( "absyncError", serverResponse );

			if( self.throwFailures ) {
				throw serverResponse;
			}
		}
1346979
function unknownError(message, stack) {
    jitsu.log.error(message);
    stack.split('\n').forEach(function (line) {
      jitsu.log.error(line);
    })
  }
644084
function onEntityRetrievalFailure( serverResponse ) {
			self.logInterface.error( self.logPrefix + "Unable to retrieve entity with ID '" + id + "' from the server.",
				serverResponse );
			self.scope.$emit( "absyncError", serverResponse );

			if( self.throwFailures ) {
				throw serverResponse;
			}
		}
758420
def raise_for_api_error(headers: MutableMapping, data: MutableMapping) -> None:
    

    if not data["ok"]:
        raise exceptions.SlackAPIError(data.get("error", "unknow_error"), headers, data)

    if "warning" in data:
        LOG.warning("Slack API WARNING: %s", data["warning"])
1360372
public final void mJAVASCRIPT() throws RecognitionException {
		try {
			int _type = JAVASCRIPT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// druidG.g:647:2: ( ( 'JAVASCRIPT:' | 'javascript:' ) )
			// druidG.g:647:5: ( 'JAVASCRIPT:' | 'javascript:' )
			{
			// druidG.g:647:5: ( 'JAVASCRIPT:' | 'javascript:' )
			int alt33=2;
			int LA33_0 = input.LA(1);
			if ( (LA33_0=='J') ) {
				alt33=1;
			}
			else if ( (LA33_0=='j') ) {
				alt33=2;
			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 33, 0, input);
				throw nvae;
			}

			switch (alt33) {
				case 1 :
					// druidG.g:647:6: 'JAVASCRIPT:'
					{
					match("JAVASCRIPT:"); 

					}
					break;
				case 2 :
					// druidG.g:647:21: 'javascript:'
					{
					match("javascript:"); 

					}
					break;

			}

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
575069
function onerror(meta, err) {
    const { ok, sourceFrame, atLine } = options.utils.getCodeInfo({
      parsedArgv: options.parsedArgv,
      filename: meta.filename,
      err,
    });

    if (ok) {
      console.error(options.ansi.bold.bgRed('  CRITICAL  '), atLine);
      console.error(sourceFrame);
    } else {
      console.error(options.ansi.bold.bgRed('  CRITICAL  '));
      console.error(options.ansi.red(err.stack));
    }
    console.error('');
  }
1328473
def raise_error(result)
      raise unless result.is_a? HTTP::Message

      err   = JSON.parse(result.body)
      klass = MantaClient.const_get err['code']
      raise klass, err['message']
    rescue NameError, TypeError, JSON::ParserError
      raise UnknownError, result.status.to_s + ': ' + result.body
    end
860914
function NeverImplemented(message, code_id) {
    Error.call(this);
    this.message = message || "never will be implemented";
    this.code_id = code_id || null;
    this.statusCode = 501;
}
615260
def error(text = "")
      e = /ERROR\s(\d+)\s::\s(.*)/.match(text) || {}
      name = (e[2] || "UnknownError").titleize
      code = e[1] || -1
      error_class = name.gsub(/\s/, "")

      if error_class == "NothingFound"
        []
      else
        begin
          raise Semrush::Exception.const_get(error_class).new(self, "#{name} (#{code})")
        rescue
          raise Semrush::Exception::Base.new(self, "#{name} (#{code}) *** error_class=#{error_class} not implemented ***")
        end
      end
    end
658625
def error(msg, delay=0.5, chevrons=True, verbose=True):
    """"""
    if verbose:
        if chevrons:
            click.secho("\n❯❯ " + msg, err=True, fg="red")
        else:
            click.secho(msg, err=True, fg="red")
        time.sleep(delay)
241033
function UncaughtExceptionHandler(error) {
    // Call module.exports.crit here so that we can intercept the call in the tests
    module.exports.crit(`Unhandled exception: ${error.message}`);
    module.exports.crit(error.stack.toString());
    process.exit(1);
}
109075
def does_not_raise(self, function, *args, **kwargs):
        
        try:
            return function(*args, **kwargs)
        except Exception as e:
            self.log_error("{} did raise {}: {}".format(
                function.__name__,
                type(e).__name__, e
            ), None)
1148121
function ErrorWithCaller(caller) {
    Error.prepareStackTrace = function justStoreStackStace(error, frames) {
        error.__StackStace = frames;
        return '';
    };
    Error.captureStackTrace(this, caller);
    this.stack;  // jshint ignore:line
    delete Error.prepareStackTrace;
}
1055359
@Override
  public final void onModuleLoad() {
    GWT.setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
      @Override
      public void onUncaughtException(Throwable e) {
        HtmlPlatform.log.error("Uncaught Exception: ", e);
      }
    });

    // Need to do everything else in a deferred command, so that
    // the uncaught exception handler has taken effect
    Scheduler.get().scheduleDeferred(new ScheduledCommand() {

      @Override
      public void execute() {
        start();
      }

    });
  }
1238033
def _no_answer_do_retry(self, pk, pattern):
        """"""
        logger.info('Resending for pattern %s', pattern)
        # Set the timer to None before trying to send again
        self.send_packet(pk, expected_reply=pattern, resend=True)