exception

func BuildCauseChain ¶ added in v1.9.0

func BuildCauseChain(causeErr error, maxDepth int) []string

func BuildCauseContextChain ¶ added in v1.9.0

func BuildCauseContextChain(causeErr error, maxDepth int) []map[string]any

func Exit ¶

func Exit(err *ExitError)

func IsAlreadyLogged ¶ added in v1.19.0

func IsAlreadyLogged(err error) bool

IsAlreadyLogged reads the mark at the depth MarkLogged writes it. It is the single reader: reading the mark off a concrete *Error instead misses a marked HttpException and anything wrapping a marked error, which are then rendered a second time.

func IsHttpException ¶

func IsHttpException(err error) bool

IsHttpException answers whether AsHttpException would find a usable exception, so a caller that trusts it and then dereferences cannot meet a disagreement.

func LogContext ¶

func LogContext(err error, extra ...exceptioncontract.Context) exceptioncontract.Context

LogContext assembles the loggable context of an error: its message under "error", the context of the nearest ContextProvider in its chain, the cause chain walked from the error's own wrap link, and every extra map merged on top in order, later entries winning.

func Logged ¶ added in v1.19.0

func Logged(err error) error

Logged answers an error that reports itself already logged, and is what a writer returns after filing its record. An error whose chain carries an AlreadyLogged implementer is marked in place and handed back unchanged, so its identity — and every errors.Is and errors.As its readers perform on it — survives. An error whose chain carries none has nowhere for the mark to live: errors.New, fmt.Errorf and every runtime error make MarkLogged a silent no-op, and the next reader then files the same failure a second time. That error is wrapped in a marked melody error keeping it as its cause, so the mark the writer meant to leave is the mark the reader finds. The wrap cannot change how a status is resolved: it happens exactly when no HttpException is in the chain, which is exactly when the status was already going to be the generic one.

func MarkLogged ¶

func MarkLogged(err error) error

MarkLogged marks the nearest AlreadyLogged implementer in the chain — the depth IsAlreadyLogged reads the mark back from — and returns the error unchanged.

func Panic ¶

func Panic(err *Error)

func PanicCause ¶ added in v1.19.0

func PanicCause(recoveredValue any) error

PanicCause reads a recovered panic value as the cause of the error a recovery boundary fabricates in its place. An error-shaped panic value belongs in the cause slot, not in a context slot: kept only in the context it collapses to its bare message at the render boundary — the json logger stringifies an error it finds in a context — so the context map and the cause chain of the very error that was raised reach no record at all, and the reason a write failed is gone while the stack that says where survives. A typed nil answers no cause, because its Error() would dereference a nil receiver at the first render, and a panic value that is not an error has no cause to give.