func Context(err error) []interface{}
Context extracts the context key-value pairs from an error (or error chain).
func ExposeStackTrace(err error) error
ExposeStackTrace exposes the stack trace (if any) in the outer error.
func ForEachCause(err error, fn func(err error) bool)
ForEachCause loops through an error chain and calls a function for each of them, starting with the topmost one.
The function can return false to break the loop before it ends.
func Handle(handler Handler, err error)
Handle handles an error whenever it occurs.
func HandleRecover(handler Handler)
HandleRecover recovers from a panic and handles the error.
defer emperror.HandleRecover(errorHandler)
func Panic(err error)
Panic panics if the passed error is not nil. If the error does not contain any stack trace, the function attaches one, starting from the frame of the "Panic" function call.
This function is useful with HandleRecover when panic is used as a flow control tool to stop the application.
func Recover(r interface{}) (err error)
Recover accepts a recovered panic (if any) and converts it to an error (if necessary).
func StackTrace(err error) (errors.StackTrace, bool)
StackTrace returns the stack trace from an error (if any).
func With(err error, keyvals ...interface{}) error
With returns a new error with keyvals context appended to it. If the wrapped error is already a contextual error created by With keyvals is appended to the existing context, but a new error is returned.
func Wrap(err error, message string) error
Wrap returns an error annotating err with a stack trace at the point Wrap is called (if there is none attached to the error yet), and the supplied message. If err is nil, Wrap returns nil.
Note: do not use this method when passing errors between goroutines.
func WrapWith(err error, message string, keyvals ...interface{}) error
WrapWith returns an error annotating err with a stack trace at the point Wrap is called (if there is none attached to the error yet), the supplied message, and the supplied context. If err is nil, Wrap returns nil.
Note: do not use this method when passing errors between goroutines.
func Wrapf(err error, format string, args ...interface{}) error
Wrapf returns an error annotating err with a stack trace at the point Wrapf is call (if there is none attached to the error yet), and the format specifier. If err is nil, Wrapf returns nil.
Note: do not use this method when passing errors between goroutines.
Handler is responsible for handling an error.
This interface allows libraries to decouple from logging and error handling solutions.
type Handler interface {
// Handle takes care of unhandled errors.
Handle(err error)
}
func HandlerWith(handler Handler, keyvals ...interface{}) Handler
HandlerWith returns a new error handler with keyvals context appended to it. If the wrapped error handler is already a contextual error handler created by HandlerWith or HandlerWithPrefix keyvals is appended to the existing context, but a new error handler is returned.
The created handler will prepend it's own context to the handled errors.
func HandlerWithPrefix(handler Handler, keyvals ...interface{}) Handler
HandlerWithPrefix returns a new error handler with keyvals context prepended to it. If the wrapped error handler is already a contextual error handler created by HandlerWith or HandlerWithPrefix keyvals is prepended to the existing context, but a new error handler is returned.
The created handler will prepend it's own context to the handled errors.
func NewCompositeHandler(handlers ...Handler) Handler
NewCompositeHandler returns a new compositeHandler.
func NewNoopHandler() Handler
NewNoopHandler creates a no-op error handler that discards all received errors. Useful in examples and as a fallback error handler.
HandlerFunc wraps a function and turns it into an error handler.
type HandlerFunc func(err error)
func (h HandlerFunc) Handle(err error)
Handle calls the underlying log function.
MultiErrorBuilder provides an interface for aggregating errors and exposing them as a single value.
type MultiErrorBuilder struct {
Message string
SingleWrapMode SingleWrapMode
// contains filtered or unexported fields
}
func NewMultiErrorBuilder() *MultiErrorBuilder
NewMultiErrorBuilder returns a new MultiErrorBuilder.
func (b *MultiErrorBuilder) Add(err error)
Add adds an error to the list.
Calling this method concurrently is not safe.
func (b *MultiErrorBuilder) ErrOrNil() error
ErrOrNil returns a MultiError the builder aggregates a list of errors, or returns nil if the list of errors is empty.
It is useful to avoid checking if there are any errors added to the list.
SingleWrapMode defines how MultiErrorBuilder behaves when there is only one error in the list.
type SingleWrapMode int
These constants cause MultiErrorBuilder to behave as described if there is only one error in the list.
const (
AlwaysWrap SingleWrapMode = iota // Always return a MultiError.
ReturnSingle // Return the single error.
)
TestHandler is a simple stub for the handler interface recording every error.
The TestHandler is safe for concurrent use.
type TestHandler struct {
// contains filtered or unexported fields
}
func NewTestHandler() *TestHandler
NewTestHandler returns a new TestHandler.
func (h *TestHandler) Count() int
Count returns the number of events recorded in the logger.
func (h *TestHandler) Errors() []error
Errors returns all handled errors.
func (h *TestHandler) Handle(err error)
Handle records the error.
func (h *TestHandler) LastError() error
LastError returns the last handled error (if any).
| Name | Synopsis |
|---|---|
| .. | |
| handler | |
| airbrakehandler | Package airbrakehandler provides Airbrake/Errbit integration. |
| bugsnaghandler | Package bugsnaghandler provides Bugsnag integration. |
| logrushandler | Package logrushandler provides Logrus integration. |
| rollbarhandler | Package rollbarhandler provides Rollbar integration. |
| sentryhandler | |
| httperr | |