Yes, this eats exceptions
547454
def sentry_exception (e, request, message = None):
  """"""
  try:
    logtool.log_fault (e, message = message, level = logging.INFO)
    data = {
      "task": task,
      "request": {
        "args": task.request.args,
        "callbacks": task.request.callbacks,
        "called_directly": task.request.called_directly,
        "correlation_id": task.request.correlation_id,
        "delivery_info": task.request.delivery_info,
        "errbacks": task.request.errbacks,
        "eta": task.request.eta,
        "expires": task.request.expires,
        "headers": task.request.headers,
        "hostname": task.request.hostname,
        "id": task.request.id,
        "is_eager": task.request.is_eager,
        "kwargs": task.request.kwargs,
        "origin": task.request.origin,
        "parent_id": task.request.parent_id,
        "reply_to": task.request.reply_to,
        "retries": task.request.retries,
        "root_id": task.request.root_id,
        "task": task.request.task,
        "taskset": task.request.taskset,
        "timelimit": task.request.timelimit,
        "utc": task.request.utc,
      },
    }
    if message:
      data["message"] = message
    SENTRY.extra_context (data)
    einfo = sys.exc_info ()
    rc = SENTRY.captureException (einfo)
    del einfo
    LOG.error ("Sentry filed: %s", rc)
  except Exception as ee:
    logtool.log_fault (ee, message = "FAULT: Problem logging exception.",
                       level = logging.INFO)
1198290
def exception(self, msg=None, *args, **kwargs):
        
        kwargs['exc_info'] = 1
        return self._log(logging.ERROR, msg, args, kwargs)
36115
public boolean isSingleton(String exceptionName) {
        if (size != 1) {
            return false;
        }
        ObjectType e = iterator().next();
        return e.toString().equals(exceptionName);

    }
1366904
function _throw (code, customMessage, original, data) {
    immutableError.throw(this, code, customMessage, original, data)
}
1245125
private static SSLException asSSLException(Exception e) throws SSLException {
        if (e instanceof SSLException)
            return (SSLException) e;
        return new SSLException(e.getMessage(), e);
    }
862991
function isException(url, exceptions) {
	if (exceptions && Array.isArray(exceptions)) {
		for (let i = 0; i < exceptions.length; i++) {
			if ((new RegExp(exceptions[i])).test(expressUtility.getBaseRoute(url))) {
				// Found exception
				return true;
			}
		}
	}
	return false;
}
1348316
public void addAll(ExceptionSet other) {
        exceptionSet.or(other.exceptionSet);
        explicitSet.or(other.explicitSet);
        size = countBits(exceptionSet);

        commonSupertype = null;
    }
362274
private function exception() : void
    {
        if ($this->response->getStatusCode() === Response::HTTP_FORBIDDEN) {
            throw ServiceException::invalidApiKey();
        }

        if ($this->response->getStatusCode() === Response::HTTP_UNPROCESSABLE_ENTITY) {
            throw ServiceException::invalidPayload();
        }

        if ($this->response->getStatusCode() === Response::HTTP_TOO_MANY_REQUESTS) {
            throw ServiceException::rateLimit();
        }

        if ($this->response->getStatusCode() === Response::HTTP_INTERNAL_SERVER_ERROR) {
            throw ServiceException::serverError();
        }

        throw ServiceException::generic();
    }
981006
def return_false_on_exception(func):
    
    @wraps(func)
    def exceptfalse(*args, **kwargs):
        if not kwargs.pop('raise_exceptions', False):
            try:
                return func(*args, **kwargs)
            except Exception:
                return False
        else:
            return func(*args, **kwargs)
    return exceptfalse
1136482
def throws(exc):
    '''
    
    '''
    if not __CHECKING__:
        return lambda f: f

    def wrap(f):
        def call(*args, **kwd):
            res = f(*args, **kwd)
            # raise UncheckedExceptionError if exc is not automatically
            # registered by a function decorated with @catches(exc);
            # otherwise do nothing
            exc_checker.throwing(exc)
            return res
        call.__name__ = f.__name__
        return call
    return wrap
945321
function Exception(code, message) {
    Error.captureStackTrace(this, Exception);
    this.name = Exception.name;
    this.code = code;
    this.message = message;
}
490117
def remove_on_exception(dirname, remove=True):
    """"""
    os.makedirs(dirname)
    try:
        yield
    except:
        if remove:
            shutil.rmtree(dirname, ignore_errors=True)
        raise
850643
public function throwsAnythingExcept()
    {
        try {
            $this->data[0]();
        } catch (Exception $exception) {
            $exceptionClass = get_class($exception);
            if ($exceptionClass === $this->data[1]) {
                throw new DidNotMatchException(
                    "Expected any exception except {$this->data[1]} to be " .
                    "thrown, but $exceptionClass was thrown."
                );
            }
        }
    }
877707
def schedule_exception(exception, target):
    
    if not isinstance(target, compat.greenlet):
        raise TypeError("can only schedule exceptions for greenlets")
    if target.dead:
        raise ValueError("can't send exceptions to a dead greenlet")
    schedule(target)
    state.to_raise[target] = exception
1032718
synchronized void insert_except(DevFailed res, TimeVal when, TimeVal needed)
	{
		ring.insert_except(res,when);
		needed_time = needed;
	}
749414
def exceptions(self):
        """"""

        return (self._session.query(Process)
                .filter(Process.d_vid == self._d_vid)
                .filter(Process.exception_class != None)
                .order_by(Process.modified)).all()
365745
def _incr_exceptions(self, conn):
        
        self._pool_manager.get_connection(self.pid, conn).exceptions += 1