error.go

package stack

import (
	"bytes"
	"fmt"
	"io"
	"strconv"

	"github.com/pkg/errors"
	"github.com/rs/zerolog"
	"github.com/ugorji/go/codec"
)

type IUnwrapper interface {
	Unwrap() error
}
type stackTracer interface {
	StackTrace() errors.StackTrace
}
type wrappedErr struct {
	str string
	err error
}

func (e wrappedErr) Error() string {
	return e.str
}
func (e wrappedErr) Unwrap() error {
	return e.err
}

type ErrorKVP struct {
	Key   string
	Value any
}

func (e ErrorKVP) MarshalZerologObject(ze *zerolog.Event) {
	ze.Interface(e.Key, e.Value)
}

type kvpList []ErrorKVP

func (k kvpList) MarshalZerologArray(a *zerolog.Array) {
	for _, v := range k {
		a.Object(v)
	}
}

type Error struct {
	error
	extraData kvpList
	stack     MarshableStack
}
type t interface {
	Is(error) bool
}

func (es *Error) Is(target error) bool {
	err := es.error
	for {
		if err == target {
			return true
		}
		if err = errors.Unwrap(err); err == nil {
			return false
		}
	}
}
func (es *Error) HasStack() bool {
	return len(es.stack) > 0
}

func Trace(err error, extra ...ErrorKVP) error {
	if err == nil {
		return nil
	}
	// Prevent nesting tracing
	if stackTracedError, useNewError := GetTrace(err); stackTracedError != nil {
		stackTracedError.extraData = append(stackTracedError.extraData, extra...)
		if useNewError {
			return stackTracedError
		}
		return err
	}
	return &Error{
		error: err,
		// Some things may use this
		extraData: extra,
		// Pop this off the call stack
		stack: MarshalStack()[1:],
	}
}

func Wrap(err error, message string, extra ...ErrorKVP) error {
	if err == nil {
		return nil
	}
	// Prevent nested tracing
	var sTrace = &Error{}
	if errors.As(err, &sTrace) {
		sTrace.error = wrappedErr{str: message + ": " + sTrace.Error()}
		if len(extra) > 0 {
			sTrace.extraData = append(sTrace.extraData, extra...)
		}
		return sTrace
	}
	return &Error{
		error: wrappedErr{str: message + ": " + err.Error(), err: err},

		// Some things may use this
		extraData: extra,
		// Pop this off the call stack
		stack: MarshalStack()[1:],
	}
}
func (es *Error) StackTrace() errors.StackTrace {
	return es.stack.StackTrace()
}

func (es *Error) RawStack() MarshableStack {
	return es.stack
}
func (es *Error) TopLine() (error, string) {
	if len(es.stack) == 0 {
		return es.error, ""
	}
	return es.error, es.stack[0].File() + ":" + strconv.Itoa(es.stack[0].Line())
}
func (es *Error) Extra() []ErrorKVP {
	return es.extraData
}
func (es *Error) Unwrap() error {
	return es.error
}
func (es *Error) MarshalZerologObject(e *zerolog.Event) {

	e.Str("error", es.error.Error()).Array("stack", es.stack)
	if es.extraData != nil {
		e.Array("extra", es.extraData)
	}
}

func (es *Error) Cause() error {
	return es.error
}

func (es *Error) Format(s fmt.State, verb rune) {
	switch verb {
	case 'v':
		if s.Flag('+') {
			fmt.Fprintf(s, "%+v", es.Cause())
			es.stack.Format(s, verb)
			if len(es.extraData) > 0 {
				fmt.Fprintf(s, "\nExtra:\n%+v", es.extraData)
			}
			return
		}
		fallthrough
	case 's':
		io.WriteString(s, es.Error())
	case 'q':
		fmt.Fprintf(s, "%q", es.Error())
	}
}

// HasTrace determines if there is a traceable error
func HasTrace(err error) (isStackTraced bool) {
	tErr := ToTypedError(err)
	if tErr == nil {
		return false
	}
	return tErr.HasStack()
}

func GetTrace(err error) (wrappedErr *Error, useNewError bool) {
	// Snapshot the top level error incase it needs to return a new wrapped version of the error.
	// This library pre-dates pkg/errors having good stack-tracing support
	var originalError = err
	for {
		if err == nil {
			break
		}
		if tErr, isStackTraced := err.(stackTracer); isStackTraced {
			var internalError = &Error{}
			if errors.As(err, &internalError) {
				return internalError, false
			}
			var out MarshableStack
			for _, frame := range tErr.StackTrace() {
				out = append(out, PCFrame(frame))
			}
			return &Error{
				error:     originalError,
				extraData: nil,
				stack:     out,
			}, true
		}
		if wrapper, ok := err.(IUnwrapper); ok {
			err = wrapper.Unwrap()
		} else {
			break
		}
	}
	return nil, false
}

// TraceToString converts a trace to a string that can be read, this doesn't capture the extra data just a stack trace
// This is mostly used for tests to make it more readable if something melts down
func TraceToString(err error) string {
	if err == nil {
		return "No error"
	}
	target, _ := GetTrace(err)
	if target == nil || target.stack == nil {
		return err.Error()
	}
	buf := bytes.Buffer{}
	codec.NewEncoder(&buf, &codec.JsonHandle{Indent: 2}).Encode(target.stack)
	return buf.String()
}

func ToTypedError(err error) (typedErr *Error) {
	typedErr = &Error{}
	if errors.As(err, &typedErr) {
		return typedErr
	}
	return nil
}

func UpliftStackTrace(err error) error {
	trace, _ := GetTrace(err)
	if trace == nil || trace.error == nil {
		return err
	}
	return &Error{
		error:     err,
		extraData: trace.extraData,
		stack:     trace.stack,
	}
}