emperror

README

The Emperor takes care of all errors personally.

Development

The project requires Glide to install dependencies.

$ make dep

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 to libraries and applications.

Index

• func HandleIfErr(handler Handler, err error)
• func HandleRecover(handler Handler)
• func Recover(r interface{}) (err error)
• func With(err error, keyvals ...interface{}) error
• func WithHttpRequest(err error, r *http.Request) error
• func WithPrefix(err error, keyvals ...interface{}) error
• type Causer
• type Contextor
• type ErrorCollection
• type Handler
  • func HandlerWith(handler Handler, keyvals ...interface{}) Handler
  • func HandlerWithPrefix(handler Handler, keyvals ...interface{}) Handler
  • func NewCompositeHandler(handlers ...Handler) Handler
  • func NewNopHandler() Handler
• type HandlerFunc
  • func (h HandlerFunc) Handle(err error)
• type HandlerLogFunc
  • func (h HandlerLogFunc) Handle(err error)
• type HttpError
• type MultiErrorBuilder
  • func NewMultiErrorBuilder() *MultiErrorBuilder
  • func (b *MultiErrorBuilder) Add(err error)
  • func (b *MultiErrorBuilder) ErrOrNil() error
• type SingleWrapMode
• type StackTracer
• type TestHandler
  • func (h *TestHandler) Errors() []error
  • func (h *TestHandler) Handle(err error)
  • func (h *TestHandler) Last() error

Functions

func HandleIfErr

func HandleIfErr(handler Handler, err error)

HandleIfErr handles an error whenever it occurs.

func HandleRecover

func HandleRecover(handler Handler)

HandleRecover recovers from a panic and handles the error.

defer emperror.HandleRecover(errorHandler)

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 or WithPrefix keyvals is appended to the existing context, but a new error is returned.

func WithHttpRequest

func WithHttpRequest(err error, r *http.Request) error

WithHttpRequest attaches an HTTP request to the error.

func WithPrefix

func WithPrefix(err error, keyvals ...interface{}) error

WithPrefix returns a new error with keyvals context appended to it. If the wrapped error is already a contextual error created by With or WithPrefix keyvals is prepended to the existing context, but a new error is returned.

Types

type Causer

type Causer interface {
	Cause() error
}

Causer is the interface defined in github.com/pkg/errors for specifying a parent error.

type Contextor

type Contextor interface {
	Context() []interface{}
}

Contextor represents an error which holds a context.

type ErrorCollection

type ErrorCollection interface {
	Errors() []error
}

ErrorCollection holds a list of errors.

type Handler

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

Handler is responsible for handling an error.

This interface allows libraries to decouple from logging and error handling solutions.

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.

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.

func NewCompositeHandler

func NewCompositeHandler(handlers ...Handler) Handler

NewCompositeHandler returns a new compositeHandler.

func NewNopHandler

func NewNopHandler() Handler

NewNopHandler returns an error handler that doesn't do anything.

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 log function.

type HandlerLogFunc

type HandlerLogFunc func(args ...interface{})

HandlerLogFunc wraps a log-like function and turns it into an error handler.

func (HandlerLogFunc) Handle

func (h HandlerLogFunc) Handle(err error)

Handle calls the underlying log function.

type HttpError

type HttpError interface {
	HttpRequest() *http.Request
}

HttpError interface provides a way to attach an http.Request to the 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.

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 StackTracer

type StackTracer interface {
	StackTrace() errors.StackTrace
}

StackTracer is the interface defined in github.com/pkg/errors for exposing stack trace from an error.

type TestHandler

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

TestHandler throws every error away.

func (*TestHandler) Errors

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

Errors returns all the handled errors.

func (*TestHandler) Handle

func (h *TestHandler) Handle(err error)

Handle saves the error in a list.

func (*TestHandler) Last

func (h *TestHandler) Last() error

Last returns the last handled error.