CODEWITHSUNDEEP
pythonwrapper
4m1nh4j1
4m1nh4j1

Reputation: 4356

Raising errors without traceback

I would like to use raise without printing the traceback on the screen. I know how to do that using try ..catch but doesn't find a way with raise.

Here is an example:

def my_function(self):
    resp = self.resp
    if resp.status_code == 404:
        raise NoSuchElementError('GET'+self.url+'{}'.format(resp.status_code)) 
    elif resp.status_code == 500:
        raise ServerErrorError('GET'+self.url+'{}'.format(resp.status_code))

When executing this, if I have a 404, the traceback will print on the screen.

Traceback (most recent call last):
  File "test.py", line 32, in <module>
    print ins.my_function()
  File "api.py", line 820, in my_function
    raise NoSuchElementError('GET ' + self.url + ' {} '.format(resp.status_code))

This is an API wrapper and I don't want users to see the traceback but to see the API response codes and error messages instead.

Is there a way to do it ?

Upvotes: 5

Views: 14942

Answers (5)

user9608133
user9608133

Reputation:

Modified @Alec answer:

from contextlib import contextmanager

@contextmanager
def disable_exception_traceback():
    """
    All traceback information is suppressed and only the exception type and value are printed
    """
    default_value = getattr(sys, "tracebacklimit", 1000)  # `1000` is a Python's default value
    sys.tracebacklimit = 0
    yield
    sys.tracebacklimit = default_value  # revert changes

Usage:

with disable_exception_traceback():
    raise AnyYourCustomException()

Use this if you only need to hide a traceback without modifying an exception message. Tested on Python 3.8

UPD: code improved by @DrJohnAStevenson comment

Upvotes: 5

FoxtBirdy
FoxtBirdy

Reputation: 1

You can create a class that takes two values; Type and code for a custom Exception Message. Afterwards, you can just pass the class in a try/except statement.

class ExceptionHandler(Exception):
    def __init__(self, exceptionType, code):
        self.exceptionType = exceptionType
        self.code = code
        print(f"Error logged: {self.exceptionType}, Code: {self.code}")
        

try:
    raise(ExceptionHandler(exceptionType=KeyboardInterrupt, code=101))
except Exception:
    pass

Upvotes: 0

Alec
Alec

Reputation: 1469

I ran into a similar problem where a parent class was using the exception value on raise to pass messages through but where I didn't want to dump the traceback. @lejlot gives a great solution using sys.excepthook but I needed to apply it with a more limited scope. Here's the modification:

import sys
from contextlib import contextmanager

@contextmanager
def except_handler(exc_handler):
    "Sets a custom exception handler for the scope of a 'with' block."
    sys.excepthook = exc_handler
    yield
    sys.excepthook = sys.__excepthook__

Then, to use it:

def my_exchandler(type, value, traceback):
    print(': '.join([str(type.__name__), str(value)]))

with except_handler(my_exchandler):
    raise Exception('Exceptional!')

# -> Exception: Exceptional!

That way, if an exception isn't raised in the block, default exception handling will resume for any subsequent exceptions:

with except_handler(my_exchandler):
    pass

raise Exception('Ordinary...')

# -> Traceback (most recent call last):
# ->   File "raise_and_suppress_traceback.py", line 22, in <module>
# ->     raise Exception('Ordinary...')
# -> Exception: Ordinary...

Upvotes: 5

kylieCatt
kylieCatt

Reputation: 11039

Catch the exception, log it and return something that indicates something went wrong to the consumer (sending a 200 back when a query failed will likely cause problems for your client).

try:
     return do_something()
except NoSuchElementError as e:
    logger.error(e)
    return error_response()

The fake error_response() function could do anything form returning an empty response or an error message. You should still make use of proper HTTP status codes. It sounds like you should be returning a 404 in this instance.

You should handle exceptions gracefully but you shouldn't hide errors from clients completely. In the case of your NoSuchElementError exception it sounds like the client should be informed (the error might be on their end).

Upvotes: 0

lejlot
lejlot

Reputation: 66805

The problem is not with raising anything, but with what python interpreter does, when your program terminates with an exception (and it simply prints the stack trace). What you should do if you want to avoid it, is to put try except block around everything that you want to "hide" the stack trace, like:

def main():
  try:
    actual_code()
  except Exception as e:
    print(e)

The other way around is to modify the exeption handler, sys.excepthook(type, value, traceback), to do your own logic, like

def my_exchandler(type, value, traceback):
  print(value)

import sys
sys.excepthook = my_exchandler

you can even condition of exception type and do the particular logic iff it is your type of exception, and otherwise - backoff to the original one.

Upvotes: 5

Related Questions