emperror

README

The Emperor takes care of all errors personally.

Go's philosophy encourages to gracefully handle errors whenever possible, but some times recovering from an error is not.

In those cases handling the error means making the best effort to record every detail for later inspection, doing that as high in the application stack as possible.

This project provides tools to make error handling easier.

Read more about the topic here:

• https://dave.cheney.net/2016/04/27/dont-just-check-errors-handle-them-gracefully
• https://8thlight.com/blog/kyle-krull/2018/08/13/exploring-error-handling-patterns-in-go.html
• https://banzaicloud.com/blog/error-handling-go/

Features

• Various error handling strategies (eg. logging, third-party error services) using a simple interface
• Various helpers related to error handling (recovery from panics, etc)
• Integrations with well-known error catchers and libraries:
  • Logur
  • Logrus
  • Sentry SDK (both hosted and on-premise)
  • Bugsnag SDK
  • Airbrake SDK / Errbit
  • Rollbar SDK

Installation

go get emperror.dev/emperror

Usage

Log errors

Logging is one of the most common target to record error events.

Emperror has two logger integrations by default:

• Logur handler
• Logrus handler

Annotate errors passing through an error handler

Emperror can annotate errors with details as defined in emperror.dev/errors

package main

import (
	"emperror.dev/emperror"
	"emperror.dev/errors"
)

func main() {
	handler := emperror.WithDetails(newHandler(), "key", "value")

	err := errors.New("error")

	// handled error will receive the handler details
	handler.Handle(err)
}

Panics and recovers

package main

import (
	"emperror.dev/emperror"
	"emperror.dev/errors"
)

func main() {
	var handler emperror.Handler = newHandler()

	// Recover from panics and handle them as errors
	defer emperror.HandleRecover(handler)

	// nil errors will not panic
	emperror.Panic(nil)

	// this will panic if foo returns with a non-nil error
	// useful in main func for initial setup where "if err != nil" does not make much sense
	emperror.Panic(foo())
}

func foo() error {
	return errors.New("error")
}

Filter errors

Sometimes you might not want to handle certain errors that reach the error handler. A common example is a catch-all error handler in a server. You want to return business errors to the client.

package main

import (
	"emperror.dev/emperror"
	"emperror.dev/errors/match"
)

func main() {
	var handler emperror.Handler = emperror.WithFilter(newHandler(), match.Any{/*any emperror.ErrorMatcher*/})

    // errors matching the provided matcher will not be handled
	handler.Handle(err)
}

Development

When all coding and testing is done, please run the test suite:

$ make check

License

The MIT License (MIT). Please see License File for more information.

Documentation

Overview

Package emperror provides error handling solutions and tools for libraries and applications.

Index

• func Context(err error) []interface{}
• func ExposeStackTrace(err error) error
• func ForEachCause(err error, fn func(err error) bool)
• func Handle(handler Handler, err error)
• func HandleRecover(handler Handler)
• func Panic(err error)
• func Recover(r interface{}) (err error)
• func With(err error, keyvals ...interface{}) error
• func Wrap(err error, message string) error
• func WrapWith(err error, message string, keyvals ...interface{}) error
• func Wrapf(err error, format string, args ...interface{}) error
• type ContextAwareHandler
  • func MakeContextAware(handler Handler) ContextAwareHandler
• type ErrorMatcher
• type Errors
• type Handler
  • func HandlerWith(handler Handler, keyvals ...interface{}) Handler
  • func HandlerWithDetails(handler Handler, details ...interface{}) Handler
  • func HandlerWithPrefix(handler Handler, keyvals ...interface{}) Handler
  • func NewCompositeHandler(handlers ...Handler) Handler
  • func NewNoopHandler() Handler
  • func WithDetails(handler Handler, details ...interface{}) Handler
  • func WithFilter(handler Handler, matcher ErrorMatcher) Handler
• type HandlerFunc
  • func (h HandlerFunc) Handle(err error)
• type Handlers
  • func (h Handlers) Close() error
  • func (h Handlers) Handle(err error)
• type MultiErrorBuilder
  • func NewMultiErrorBuilder() *MultiErrorBuilder
  • func (b *MultiErrorBuilder) Add(err error)
  • func (b *MultiErrorBuilder) ErrOrNil() error
• type SingleWrapMode
• type TestHandler
  • func NewTestHandler() *TestHandler
  • func (h *TestHandler) Count() int
  • func (h *TestHandler) Errors() []error
  • func (h *TestHandler) Handle(err error)
  • func (h *TestHandler) LastError() error

Examples

• WithFilter

Functions

func Context

func Context(err error) []interface{}

Context extracts the context key-value pairs from an error (or error chain). Deprecated: use emperror.dev/errors.GetDetails instead.

func ExposeStackTrace

func ExposeStackTrace(err error) error

ExposeStackTrace exposes the stack trace (if any) in the outer error.

func ForEachCause

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.

Deprecated: use emperror.dev/errors.UnwrapEach instead.

func Handle

func Handle(handler Handler, err error)

Handle handles an error (if one occurred).

func HandleRecover

func HandleRecover(handler Handler)

HandleRecover recovers from a panic and handles the error.

defer emperror.HandleRecover(errorHandler)

func Panic

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

func Recover(r interface{}) (err error)

Recover accepts a recovered panic (if any) and converts it to an error (if necessary).

func With

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. Deprecated: use emperror.dev/errors.WithDetails instead.

func Wrap

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. Deprecated: use emperror.dev/errors.WrapIf instead.

func WrapWith

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. Deprecated: use emperror.dev/errors.WrapIfWithDetails instead.

func Wrapf

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. Deprecated: use emperror.dev/errors.WrapIff instead.

Types

type ContextAwareHandler

type ContextAwareHandler interface {
	// Handle handles an error.
	Handle(ctx context.Context, err error)
}

ContextAwareHandler is similar to Handler, except it receives a context as well. It is useful in request terminal error handling situations. An implementation MAY extract information from the context and annotate err with it.

func MakeContextAware

func MakeContextAware(handler Handler) ContextAwareHandler

MakeContextAware wraps an error handler and turns it into a ContextAwareHandler.

type ErrorMatcher

type ErrorMatcher interface {
	// MatchError checks if err matches a certain condition.
	MatchError(err error) bool
}

ErrorMatcher checks if an error matches a certain condition.

type Errors

type Errors interface {
	// Errors returns the list of wrapped errors.
	Errors() []error
}

Errors is responsible for listing multiple errors. Deprecated: use multi error tools from emperror.dev/errors instead.

type Handler

type Handler interface {
	// Handle handles an error.
	Handle(err error)
}

Handler is a generic error handler. It allows applications (and libraries) to handle errors without worrying about the actual error handling strategy (logging, error tracking service, etc).

func HandlerWith

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. Deprecated: use WithDetails instead.

func HandlerWithDetails

func HandlerWithDetails(handler Handler, details ...interface{}) Handler

HandlerWithDetails returns a new error handler annotated with key-value pairs.

The created handler will add it's own details to the handled errors. Deprecated: use WithDetails instead.

func HandlerWithPrefix

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. Deprecated: no replacement at this time.

func NewCompositeHandler

func NewCompositeHandler(handlers ...Handler) Handler

NewCompositeHandler returns a new compositeHandler. Deprecated: use Handlers instead.

func NewNoopHandler

func NewNoopHandler() Handler

NewNoopHandler creates a no-op error handler that discards all received errors. Useful in examples and as a fallback error handler.

func WithDetails

func WithDetails(handler Handler, details ...interface{}) Handler

WithDetails returns a new error handler that annotates every error with a set of key-value pairs.

func WithFilter

func WithFilter(handler Handler, matcher ErrorMatcher) Handler

WithDetails returns a new error handler that discards errors matching any of the specified filters. Otherwise it passes errors to the next handler.

Example

err := errors.New("no more errors")
isErr := errors.New("is")

type asError struct {
	error
}
asErr := asError{errors.New("as")}

handler := WithFilter(
	HandlerFunc(func(err error) { fmt.Println(err) }),
	match.Any{
		match.Is(isErr),
		match.As(&asError{}),
	},
)

handler.Handle(err)
handler.Handle(isErr)
handler.Handle(asErr)

Output:

no more errors

type HandlerFunc

type HandlerFunc func(err error)

HandlerFunc wraps a function and turns it into an error handler.

func (HandlerFunc) Handle

func (h HandlerFunc) Handle(err error)

Handle calls the underlying function.

type Handlers

type Handlers []Handler

Handlers collects a number of error handlers into a single one.

func (Handlers) Close

func (h Handlers) Close() error

Close calls Close on the underlying handlers (if there is any closable handler).

func (Handlers) Handle

func (h Handlers) Handle(err error)

type MultiErrorBuilder

type MultiErrorBuilder struct {
	Message        string
	SingleWrapMode SingleWrapMode
	// contains filtered or unexported fields
}

MultiErrorBuilder provides an interface for aggregating errors and exposing them as a single value. Deprecated: use multi error tools from emperror.dev/errors instead.

func NewMultiErrorBuilder

func NewMultiErrorBuilder() *MultiErrorBuilder

NewMultiErrorBuilder returns a new MultiErrorBuilder.

func (*MultiErrorBuilder) Add

func (b *MultiErrorBuilder) Add(err error)

Add adds an error to the list.

Calling this method concurrently is not safe.

func (*MultiErrorBuilder) ErrOrNil

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.

type SingleWrapMode

type SingleWrapMode int

SingleWrapMode defines how MultiErrorBuilder behaves when there is only one error in the list.

const (
	AlwaysWrap   SingleWrapMode = iota // Always return a multiError.
	ReturnSingle                       // Return the single error.
)

These constants cause MultiErrorBuilder to behave as described if there is only one error in the list.

type TestHandler

type TestHandler struct {
	// contains filtered or unexported fields
}

TestHandler is a simple stub for the handler interface recording every error.

The TestHandler is safe for concurrent use.

func NewTestHandler

func NewTestHandler() *TestHandler

NewTestHandler returns a new TestHandler.

func (*TestHandler) Count

func (h *TestHandler) Count() int

Count returns the number of events recorded in the logger.

func (*TestHandler) Errors

func (h *TestHandler) Errors() []error

Errors returns all handled errors.

func (*TestHandler) Handle

func (h *TestHandler) Handle(err error)

Handle records the error.

func (*TestHandler) LastError

func (h *TestHandler) LastError() error

LastError returns the last handled error (if any).