bugsnag-go: github.com/bugsnag/bugsnag-go/errors Index | Examples | Files

package errors

import "github.com/bugsnag/bugsnag-go/errors"

Package errors provides errors that have stack-traces.



Package Files

error.go parse_panic.go stackframe.go


var MaxStackDepth = 50

The maximum number of stackframes on any error.

type Error Uses

type Error struct {
    Err   error
    Cause *Error
    // contains filtered or unexported fields

Error is an error with an attached stacktrace. It can be used wherever the builtin error interface is expected.

func Errorf Uses

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.


for i := 1; i <= 2; i++ {
    if i%2 == 1 {
        e := Errorf("can only halve even numbers, got %d", i)
        fmt.Printf("Error: %+v", e)


Error: can only halve even numbers, got 1

func New Uses

func New(e interface{}, skip int) *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 skip parameter indicates how far up the stack to start the stacktrace. 0 is from the current call, 1 from its caller, etc.


// Wrap io.EOF with the current stack-trace and return it
e := New(io.EOF, 0)
fmt.Printf("%+v", e)




defer func() {
    if err := recover(); err != nil {
        // skip 1 frame (the deferred function) and then return the wrapped err
        err = New(err, 1)

func ParsePanic Uses

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 (*Error) Callers Uses

func (err *Error) Callers() []uintptr

Callers returns the raw stack frames as returned by runtime.Callers()

func (*Error) Error Uses

func (err *Error) Error() string

Error returns the underlying error's message.

func (*Error) Stack Uses

func (err *Error) Stack() []byte

Stack returns the callstack formatted the same way that go does in runtime/debug.Stack()

func (*Error) StackFrames Uses

func (err *Error) StackFrames() []StackFrame

StackFrames returns an array of frames containing information about the stack.

func (*Error) TypeName Uses

func (err *Error) TypeName() string

TypeName returns the type this error. e.g. *errors.stringError.

type ErrorWithCallers Uses

type ErrorWithCallers interface {
    Error() string
    Callers() []uintptr

ErrorWithCallers allows passing in error objects that also have caller information attached.

type ErrorWithStackFrames Uses

type ErrorWithStackFrames interface {
    Error() string
    StackFrames() []StackFrame

ErrorWithStackFrames allows the stack to be rebuilt from the stack frames, thus allowing to use the Error type when the program counter is not available.

type StackFrame Uses

type StackFrame struct {
    File           string
    LineNumber     int
    Name           string
    Package        string
    ProgramCounter uintptr
    // contains filtered or unexported fields

A StackFrame contains all necessary information about to generate a line in a callstack.

func NewStackFrame Uses

func NewStackFrame(pc uintptr) (frame StackFrame)

NewStackFrame popoulates a stack frame object from the program counter.

func (*StackFrame) Func Uses

func (frame *StackFrame) Func() *runtime.Func

Func returns the function that this stackframe corresponds to

func (*StackFrame) SourceLine Uses

func (frame *StackFrame) SourceLine() (string, error)

SourceLine gets the line of code (from File and Line) of the original source if possible

func (*StackFrame) String Uses

func (frame *StackFrame) String() string

String returns the stackframe formatted in the same way as go does in runtime/debug.Stack()

Package errors imports 8 packages (graph) and is imported by 40 packages. Updated 2021-01-18. Refresh now. Tools for package owners.