github.com/pkg/errors

import "github.com/pkg/errors"

import pkgerrors "github.com/pkg/errors"

package main

import (
	"fmt"
	"io/ioutil"
	"github.com/pkg/errors"
)

func readConfig(path string) error {
	data, err := ioutil.ReadFile(path)
	if err != nil {
		// Wrap adds context message and stack trace
		return errors.Wrap(err, "failed to read config")
	}

	// Process data...
	if len(data) == 0 {
		// New creates error with stack trace
		return errors.New("config file is empty")
	}

	return nil
}

func main() {
	err := readConfig("/etc/app/config.yaml")
	if err != nil {
		// Print with stack trace using %+v
		fmt.Printf("%+v\n", err)

		// Get root cause
		rootErr := errors.Cause(err)
		fmt.Printf("Root cause: %v\n", rootErr)
	}
}

// New returns an error with the supplied message.
// New also records the stack trace at the point it was called.
func New(message string) error

// 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 Errorf(format string, args ...interface{}) error

// Create simple error
err := errors.New("configuration not found")

// Create formatted error
err := errors.Errorf("invalid port: %d", port)

// Wrap returns an error annotating err with a stack trace
// at the point Wrap is called, and the supplied message.
// If err is nil, Wrap returns nil.
func Wrap(err error, message string) error

// Wrapf returns an error annotating err with a stack trace
// at the point Wrapf is called, and the format specifier.
// If err is nil, Wrapf returns nil.
func Wrapf(err error, format string, args ...interface{}) error

// Wrap with context message
file, err := os.Open(path)
if err != nil {
	return errors.Wrap(err, "failed to open database")
}

// Wrap with formatted message
_, err = io.Copy(dest, src)
if err != nil {
	return errors.Wrapf(err, "failed to copy %s to %s", src, dest)
}

// WithStack annotates err with a stack trace at the point WithStack was called.
// If err is nil, WithStack returns nil.
func WithStack(err error) error

// Add stack trace only
if err != nil {
	return errors.WithStack(err)
}

// WithMessage annotates err with a new message.
// If err is nil, WithMessage returns nil.
func WithMessage(err error, message string) error

// WithMessagef annotates err with the format specifier.
// If err is nil, WithMessagef returns nil.
func WithMessagef(err error, format string, args ...interface{}) error

// Add context without stack trace
if err != nil {
	return errors.WithMessage(err, "database connection failed")
}

// Add formatted context
if err != nil {
	return errors.WithMessagef(err, "retry %d/%d failed", attempt, maxRetries)
}

// 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.
func Cause(err error) error

// Get the root cause of wrapped errors
rootErr := errors.Cause(err)

// Type assert the root cause
switch errors.Cause(err).(type) {
case *os.PathError:
	// handle file system errors
case *net.OpError:
	// handle network errors
default:
	// handle other errors
}

// Is reports whether any error in err's chain matches target.
//
// The chain consists of err itself followed by the sequence of errors obtained by
// repeatedly calling Unwrap.
//
// 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.
func Is(err, target error) bool

// As finds the first error in err's chain that matches target, and if so, sets
// target to that error value and returns true.
//
// The chain consists of err itself followed by the sequence of errors obtained by
// repeatedly calling Unwrap.
//
// 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.
//
// As will panic if target is not a non-nil pointer to either a type that implements
// error, or to any interface type. As returns false if err is nil.
func As(err error, target interface{}) bool

// 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.
func Unwrap(err error) error

// Check if error matches a sentinel
if errors.Is(err, io.EOF) {
	// handle EOF
}

// Extract typed error from chain
var pathErr *os.PathError
if errors.As(err, &pathErr) {
	fmt.Printf("Failed to access: %s\n", pathErr.Path)
}

// Get immediate wrapped error
innerErr := errors.Unwrap(err)

type stackTracer interface {
	StackTrace() StackTrace
}

// Type assert to extract stack trace
type stackTracer interface {
	StackTrace() errors.StackTrace
}

if err, ok := err.(stackTracer); ok {
	st := err.StackTrace()
	fmt.Printf("%+v\n", st[0:2]) // Print top two frames
}

// Simple error message
fmt.Printf("%s\n", err)    // "failed to read config: file not found"

// Extended format with stack traces
fmt.Printf("%+v\n", err)   // Prints error with complete stack trace

type Frame uintptr

// Format formats the frame according to the fmt.Formatter interface.
//
//    %s    source file
//    %d    source line
//    %n    function name
//    %v    equivalent to %s:%d
//
// Format accepts flags that alter the printing of some verbs, as follows:
//
//    %+s   function name and path of source file relative to the compile time
//          GOPATH separated by \n\t (<funcname>\n\t<path>)
//    %+v   equivalent to %+s:%d
func (f Frame) Format(s fmt.State, verb rune)

// MarshalText formats a stacktrace Frame as a text string. The output is the
// same as that of fmt.Sprintf("%+v", f), but without newlines or tabs.
func (f Frame) MarshalText() ([]byte, error)

// Format individual frame
fmt.Printf("%+v\n", frame)  // function name and full path with line
fmt.Printf("%s:%d\n", frame, frame)  // file:line
fmt.Printf("%n\n", frame)   // function name only

// Serialize frame to text
text, err := frame.MarshalText()

type StackTrace []Frame

// Format formats the stack of Frames according to the fmt.Formatter interface.
//
//    %s	lists source files for each Frame in the stack
//    %v	lists the source file and line number for each Frame in the stack
//
// Format accepts flags that alter the printing of some verbs, as follows:
//
//    %+v   Prints filename, function, and line number for each Frame in the stack.
func (st StackTrace) Format(s fmt.State, verb rune)

// Format entire stack trace
fmt.Printf("%+v\n", stackTrace)  // Full details for all frames
fmt.Printf("%v\n", stackTrace)   // Compact format
fmt.Printf("%s\n", stackTrace)   // Just filenames

type causer interface {
	Cause() error
}

func validateConfig(data []byte) error {
	if len(data) == 0 {
		return errors.New("empty configuration")
	}
	return nil
}

func loadConfig(path string) error {
	data, err := ioutil.ReadFile(path)
	if err != nil {
		return errors.Wrap(err, "failed to read file")
	}

	if err := validateConfig(data); err != nil {
		return errors.Wrap(err, "invalid configuration")
	}

	return nil
}

func initApp() error {
	if err := loadConfig("/etc/app.conf"); err != nil {
		return errors.Wrap(err, "failed to initialize application")
	}
	return nil
}

// Add context + stack trace (most common)
return errors.Wrap(err, "database query failed")

// Add only context (no new stack frame)
return errors.WithMessage(err, "validation failed")

// Add only stack trace (preserve original message)
return errors.WithStack(err)

if err != nil {
	// Development: see full stack trace
	log.Printf("Error: %+v\n", err)

	// Production: simpler output
	log.Printf("Error: %v\n", err)

	return err
}

switch err := errors.Cause(err).(type) {
case *json.SyntaxError:
	log.Printf("JSON syntax error at byte %d", err.Offset)
case *os.PathError:
	log.Printf("File operation failed: %s", err.Path)
default:
	log.Printf("Unknown error: %v", err)
}

// Traditional approach
rootErr := errors.Cause(err)

// Go 1.13+ approach (requires Go 1.13+)
if errors.Is(err, os.ErrNotExist) {
	// handle not found
}

var pathErr *os.PathError
if errors.As(err, &pathErr) {
	// work with pathErr
}