README
¶
errors
Minimalist and zero-dependency errors library with stacktrace support for Go (for wrapping and formatting an errors).
Installation
go get github.com/Cleverse/go-utilities/errors
Documentation
¶
Overview ¶
Package errors provides Pure Golang errors library with stacktrace support (for wrapping, formatting and joining an errors).
Add errors context to your report just by wrapping it with stacktrace.
b, err := json.Unmarshal(data, &Data)
if err != nil {
return errors.WithStack(err)
}
Describe more error details by wrapping it with message.
data := "foo"
if err := Do("foo"); err != nil {
return errors.Wrapf(err, "failed to do %q", data)
}
Debugging will be easier when you can see the stacktrace.
if err := HugeStackCall(ctx); err != nil {
fmt.Printf("[ERROR]: %+v", err)
}
Index ¶
- func As(err error, target interface{}) bool
- func Cause(err error) error
- func Errorf(format string, args ...interface{}) error
- func Is(err, target error) bool
- func Join(errs ...error) error
- func New(text string, skip ...int) error
- func Unwrap(err error) error
- func WithStack(err error) error
- func Wrap(err error, message string) error
- func Wrapf(err error, format string, args ...interface{}) error
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func As ¶
As finds the first error in err's tree that matches target, and if one is found, sets target to that error value and returns true. Otherwise, it returns false.
The tree consists of err itself, followed by the errors obtained by repeatedly calling Unwrap. When err wraps multiple errors, As examines err followed by a depth-first traversal of its children.
An error matches target if the error's concrete value is assignable to the value pointed to by target, or if the error has a method As(interface{}) bool such that As(target) returns true. In the latter case, the As method is responsible for setting target.
An error type might provide an As method so it can be treated as if it were a different error type.
As panics if target is not a non-nil pointer to either a type that implements error, or to any interface type.
func Cause ¶
Cause returns the underlying cause of the error, if possible. An error value has a cause if it implements the following interface:
type causer interface {
Cause() error
}
If the error does not implement Cause, the original error will be returned. If the error is nil, nil will be returned without further investigation.
nolint: errorlint, wrapcheck
func Errorf ¶
Errorf formats according to a format specifier and returns the string as a value that satisfies error. Errorf also records the stack trace at the point it was called.
func Is ¶
Is reports whether any error in err's tree matches target.
The tree consists of err itself, followed by the errors obtained by repeatedly calling Unwrap. When err wraps multiple errors, Is examines err followed by a depth-first traversal of its children.
An error is considered to match a target if it is equal to that target or if it implements a method Is(error) bool such that Is(target) returns true.
An error type might provide an Is method so it can be treated as equivalent to an existing error. For example, if MyError defines
func (m MyError) Is(target error) bool { return target == fs.ErrExist }
then Is(MyError{}, fs.ErrExist) returns true. See syscall.Errno.Is for an example in the standard library. An Is method should only shallowly compare err and the target and not call Unwrap on either.
func Join ¶
Join returns an error that wraps the given errors with a stack trace at the point WithStack was called. Any nil error values are discarded. Join returns nil if every value in errs is nil. The error formats as the concatenation of the strings obtained by calling the Error method of each element of errs, with a newline between each string.
A non-nil error returned by Join implements the Unwrap() []error method.
func New ¶
New returns an error with the supplied message. New also records the stack trace at the point it was called.
this function is supports to skip stack frames. default is 0 (begin at your current function call) for more information see WithStack function in github.com/Cleverse/go-utilities/errors/errconstructor
func Unwrap ¶
Unwrap returns the result of calling the Unwrap method on err, if err's type contains an Unwrap method returning error. Otherwise, Unwrap returns nil.
Unwrap only calls a method of the form "Unwrap() error". In particular Unwrap does not unwrap errors returned by Join.
func WithStack ¶
WithStack annotates err with a stack trace at the point WithStack was called. If err is nil, WithStack returns nil.
Types ¶
This section is empty.
Source Files
Directories