def handle_errors(
            cls, message, *format_args,
            re_raise=True, exception_class=Exception,
            do_finally=None, do_except=None, do_else=None,
            **format_kwds
    ):
        """
        provides a context manager that will intercept exceptions and repackage
        them as Buzz instances with a message attached:

        .. code-block:: python
        with Buzz.handle_errors("It didn't work"):
            some_code_that_might_raise_an_exception()

        :param: message:         The message to attach to the raised Buzz
        :param: format_args:     Format arguments. Follows str.format conv.
        :param: format_kwds:     Format keyword args. Follows str.format conv.
        :param: re_raise:        If true, the re-packaged exception will be
                                 raised
        :param: exception_class: Limits the class of exceptions that will be
                                 re-packaged as a Buzz exception.
                                 Any other exception types will not be caught
                                 and re-packaged.
                                 Defaults to Exception (will handle all
                                 exceptions)
        :param: do_finally:      A function that should always be called at the
                                 end of the block. Should take no parameters
        :param: do_except:       A function that should be called only if there
                                 was an exception. Should take the raised
                                 exception as its first parameter, the final
                                 message for the exception that will be raised
                                 as its second, and the traceback as its third
        :param: do_else:         A function taht should be called only if there
                                 were no exceptions encountered
        """
        try:
            yield
        except exception_class as err:
            try:
                final_message = cls.reformat_exception(
                    message, err, *format_args, **format_kwds
                )
            except Exception as msg_err:
                raise cls(
                    "Failed while formatting message: {}".format(repr(msg_err))
                )

            trace = cls.get_traceback()

            if do_except is not None:
                do_except(err, final_message, trace)
            if re_raise:
                raise cls(final_message).with_traceback(trace)
        else:
            if do_else is not None:
                do_else()
        finally:
            if do_finally is not None:
                do_finally()