The maximum number of stackframes on any error.
var MaxStackDepth = 50
func As(err error, target interface{}) bool
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.
For more information see stdlib errors.As.
func Is(e error, original error) bool
Is detects whether the error is equal to a given error. Errors are considered equal by this function if they are matched by errors.Is or if their contained errors are matched through errors.Is.
func Join(errs ...error) error
Join returns an error that wraps the given errors. 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.
For more information see stdlib errors.Join.
func Unwrap(err error) error
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.
For more information see stdlib errors.Unwrap.
Error is an error with an attached stacktrace. It can be used wherever the builtin error interface is expected.
type Error struct {
Err error
// contains filtered or unexported fields
}
func Errorf(format string, a ...interface{}) *Error
Errorf creates a new error with the given message. You can use it as a drop-in replacement for fmt.Errorf() to provide descriptive errors in return values.
func New(e interface{}) *Error
New makes an Error from the given value. If that value is already an error then it will be used directly, if not, it will be passed to fmt.Errorf("%v"). The stacktrace will point to the line of code that called New.
func ParsePanic(text string) (*Error, error)
ParsePanic allows you to get an error object from the output of a go program that panicked. This is particularly useful with https://github.com/mitchellh/panicwrap.
func Wrap(e interface{}, skip int) *Error
Wrap makes an Error from the given value. If that value is already an error then it will be used directly, if not, it will be passed to fmt.Errorf("%v"). The skip parameter indicates how far up the stack to start the stacktrace. 0 is from the current call, 1 from its caller, etc.
▹ Example
func WrapPrefix(e interface{}, prefix string, skip int) *Error
WrapPrefix makes an Error from the given value. If that value is already an error then it will be used directly, if not, it will be passed to fmt.Errorf("%v"). The prefix parameter is used to add a prefix to the error message when calling Error(). The skip parameter indicates how far up the stack to start the stacktrace. 0 is from the current call, 1 from its caller, etc.
func (err *Error) Callers() []uintptr
Callers satisfies the bugsnag ErrorWithCallerS() interface so that the stack can be read out.
func (err *Error) Error() string
Error returns the underlying error's message.
func (err *Error) ErrorStack() string
ErrorStack returns a string that contains both the error message and the callstack.
func (err *Error) Stack() []byte
Stack returns the callstack formatted the same way that go does in runtime/debug.Stack()
func (err *Error) StackFrames() []StackFrame
StackFrames returns an array of frames containing information about the stack.
func (err *Error) TypeName() string
TypeName returns the type this error. e.g. *errors.stringError.
func (err *Error) Unwrap() error
Return the wrapped error (implements api for As function).
A StackFrame contains all necessary information about to generate a line in a callstack.
type StackFrame struct {
// The path to the file containing this ProgramCounter
File string
// The LineNumber in that file
LineNumber int
// The Name of the function that contains this ProgramCounter
Name string
// The Package that contains this function
Package string
// The underlying ProgramCounter
ProgramCounter uintptr
}
func NewStackFrame(pc uintptr) (frame StackFrame)
NewStackFrame popoulates a stack frame object from the program counter.
func (frame *StackFrame) Func() *runtime.Func
Func returns the function that contained this frame.
func (frame *StackFrame) SourceLine() (string, error)
SourceLine gets the line of code (from File and Line) of the original source if possible.
func (frame *StackFrame) String() string
String returns the stackframe formatted in the same way as go does in runtime/debug.Stack()