oops
Error handling with context, stack trace and source fragments
About oops
This large README is shown as a plain-text preview. Read the full README at the source
# Oops - Structured Error Handling for Go
> **Transform your Go error handling from "oops!" to "aha!" moments**
[](https://github.com/samber/oops/releases)
[](https://pkg.go.dev/github.com/samber/oops)
[](https://goreportcard.com/report/github.com/samber/oops)
[](https://codecov.io/gh/samber/oops)
[](https://github.com/samber/oops/graphs/contributors)
[](./LICENSE)
**Oops** is a comprehensive Go error handling library that provides structured error management with rich contextual information. It's designed as a drop-in replacement for Go's built-in `error`, adding powerful features like stack traces, source code fragments, structured attributes, and developer-friendly debugging hints.
**šÆ Key Features:**
- **š§ Drop-in Replacement**: Seamlessly replaces standard Go error handling
- **š Rich Context**: Add structured attributes, user info
- **š Debug-Friendly**: Out-of-the-box stacktraces and source code fragments
- **š Error Chaining**: Wrap and compose errors with additional context
- **š”ļø Panic Recovery**: Built-in panic handling with error conversion
- **ā
Assertions**: One-line assertion helpers for validation
- **ā” Performance**: Zero dependencies, lightweight and fast
- **š Logger Integration**: Works with all major Go logging libraries
- **āļø Separation of Concerns**: Error handling and logging are separate jobs
- **š³ Easy Integration**: No large refactoring required
> [!WARNING]
> **Important**: This is NOT a logging library. `oops` should complements your existing logging toolchain (zap, zerolog, logrus, slog, go-sentry...).
š„· Start hacking `oops` with this [playground](https://go.dev/play/p/ETUqN96Cj1G).
<div align="center">
<hr>
<sup><b>Sponsored by:</b></sup>
<br>
<a href="https://cast.ai/samuel">
<div>
<img src="https://github.com/user-attachments/assets/502f8fa8-e7e8-4754-a51f-036d0443e694" width="200" alt="Cast AI">
</div>
<div>
Cut Kubernetes & AI costs, boost application stability
</div>
</a>
<br>
<a href="https://www.dash0.com?utm_campaign=148395251-samber%20github%20sponsorship&utm_source=github&utm_medium=sponsorship&utm_content=samber">
<div>
<img src="https://github.com/user-attachments/assets/b1f2e876-0954-4dc3-824d-935d29ba8f3f" width="200" alt="Dash0">
</div>
<div>
100% OpenTelemetry-native observability platform<br>Simple to use, built on open standards, and designed for full cost control
</div>
</a>
<hr>
</div>
<img align="right" title="Oops gopher logo" alt="logo: thanks Gimp" width="350" src="https://github.com/user-attachments/assets/7e02dcc5-5c07-43de-a7e0-a16d2dd0a73d">
**Table of content**
- [š Install](#-install)
- [š” Quick start](#-quick-start)
- [š§ Spec](#-spec)
- [Error builder](#error-builder)
- [Context](#context)
- [Other helpers](#other-helpers)
- [Stack trace](#stack-trace)
- [Source fragments](#source-fragments)
- [Panic handling](#panic-handling)
- [Assertions](#assertions)
- [Output](#output)
- [Go context](#go-context)
- [š« Loggers](#-loggers)
- [š„· Tips and best practices](#-tips-and-best-practices)
### Context rich error handling
In a few minutes, your logs will look like this:
<div style="text-align:center;">
<img alt="Why 'oops'?" src="./assets/motivation.png" style="max-width: 650px;">
</div>
## š Install
```sh
go get github.com/samber/oops
# AI Agent Skill:
npx skills add https://github.com/samber/cc-skills-golang --skill golang-samber-oops
```
This library is v1 and follows SemVer strictly.
No breaking changes will be made to APIs before v2.0.0.
This library has no dependencies outside the Go standard library.
## š” Quick start
This library provides a simple `error` builder for composing structured errors, with contextual attributes and stack trace.
Since `oops.OopsError` implements the `error` interface, you will be able to compose and wrap native errors with `oops.OopsError`.
```go
import "github.com/samber/oops"
func main() {
// Simple error with context
err := oops.
In("user-service").
Tags("database", "postgres").
Code("network_failure").
User("user-123", "email", "[email protected]").
With("path", "/hello/world").
Errorf("failed to fetch user: %s", "connection timeout")
// Error wrapping
if err != nil {
return oops.
Trace("req-123").
With("product_id", "456").
Wrapf(err, "user operation failed")
}
}
```
## š§ Spec
GoDoc: [https://godoc.org/github.com/samber/oops](https://godoc.org/github.com/samber/oops)
### Error builder
| Method | Description |
| ----------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- |
| `.New(message string) error` | Formats returns `oops.OopsError` object that satisfies `error` |
| `.Errorf(format string, args ...any) error` | Formats an error and returns `oops.OopsError` object that satisfies `error` |
| `.Wrap(err error) error` | Wraps an error into an `oops.OopsError` object that satisfies `error` |
| `.Wrapf(err error, format string, args ...any) error` | Wraps an error into an `oops.OopsError` object that satisfies `error` and formats an error message |
| `.Recover(cb func()) error` | Handle panic and returns `oops.OopsError` object that satisfies `error`. |
| `.Recoverf(cb func(), format string, args ...any) error` | Handle panic and returns `oops.OopsError` object that satisfies `error` and formats an error message. |
| `.Assert(condition bool) OopsErrorBuilder` | Panics if condition is false. Assertions can be chained. |
| `.Assertf(condition bool, format string, args ...any) OopsErrorBuilder` | Panics if condition is false and formats an error message. Assertions can be chained. |
| `.Join(err1 error, err2 error, ...) error` | Join returns an error that wraps the given errors. |
| `.CallerSkip(n int) OopsErrorBuilder` | Skip N extra frames when capturing the stack trace (useful when wrapping oops in helper functions) |
#### Examples
```go
// with error wrapping
err0 := oops.
In("repository").
Tags("database", "sql").
Wrapf(sql.Exec(query), "could not fetch user") // Wrapf returns nil when sql.Exec() is nil
// with panic recovery
err1 := oops.
In("repository").
Tags("database", "sql").
Recover(func () {
panic("caramba!")
})
// with assertion
err2 := oops.
In("repository").
Tags("database", "sql").
Recover(func () {
// ...
oops.Assertf(time.Now().Weekday() == 1, "This code should run on Monday only.")
// ...
})
// oops.New
err3 := oops.
In("repository").
Tags("database", "sql").
New("an error message")
// oops.Errorf
err4 := oops.
In("repository").
Tags("database", "sql").
Errorf("an error message: %d", 42)
```
### Context
The library provides an error builder. Each method can be used standalone (eg: `oops.With(...)`) or from a previous builder instance (eg: `oops.In("iam").User("user-42")`).
The `oops.OopsError` builder must finish with either `.Errorf(...)`, `.Wrap(...)`, `.Wrapf(...)`, `.Join(...)`, `.Recover(...)` or `.Recoverf(...)`.
| Builder method | Getter | Description |
| --------------------------------------- | --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `.With(string, any)` | `err.Context() map[string]any` | Supply a list of attributes key+value. Values of type `func() any {}` are accepted and evaluated lazily. |
| `.WithContext(context.Context, ...any)` | `err.Context() map[string]any` | Supply a list of values declared in context. Values of type `func() any {}` are accepted and evaluated lazily. |
| `.Code(any)` | `err.Code() any` | Set a code or slug that describes the error. Error messages are intended to be read by humans, but such code is expected to be read by machines and be transported over different services |
| `.Public(string)` | `err.Public() string` | Set a message that is safe to show to an end user |
| `.Time(time.Time)` | `err.Time() time.Time` | Set the error time (default: `time.Now()`) |
| `.Since(time.Time)` | `err.Duration() time.Duration` | Set the error duration |
| `.Duration(time.Duration)` | `err.Duration() time.Duration` | Set the error duration |
| `.In(string)` | `err.Domain() string` | Set the feature category or domain |
| `.Tags(...string)` | `err.Tags() []string` | Add multiple tags, describing the feature returning an error |
| | `err.HasTag(string) bool` | Check whether the error contains provided tag |
| `.Trace(string)` | `err.Trace() string` | Add a transaction id, trace id, correlation id... (default: ULID) |
| `.Span(string)` | `err.Span() string` | Add a span representing a unit of work or operation... (default: ULID) |
| `.Hint(string)` | `err.Hint() string` | Set a hint for faster debugging |
| `.Owner(string)` | `err.Owner() string` | Set the name/email of the colleague/team responsible for handling this error. Useful for alerting purpose |
| `.User(string, any...)` | `err.User() (string, map[string]any)` | Supply user id with optional attributes (string key/value pairs, `map[string]any`, and `slog.Attr`) |
| `.Tenant(string, any...)` | `err.Tenant() (string, map[string]any)` | Supply tenant id with optional attributes (string key/value pairs, `map[string]any`, and `slog.Attr`) |
| `.Request(*http.Request, bool)` | `err.Request() *http.Request` | Supply http request |
| `.Response(*http.Response, bool)` | `err.Response() *http.Response` | Supply http response |
| `.FromContext(context.Context)` | | Reuse an existing OopsErrorBuilder transported in a Go context |
| | `err.Layers() []*OopsError` | Return all OopsError layers in the chain from outermost to innermost, so callers can inspect attributes at any layer (non-OopsError errors are skipped) |
#### Examples
```go
// simple error with public facing message
err0 := oops.
Public("Could not fetch user.").
Errorf("sql: bad connection")
// simple error with stacktrace
err1 := oops.New("could not fetch user")
// with optional domain
err2 := oops.
In("repository").
Tags("database", "sql").
Errorf("could not fetch user")
// with custom attributes
ctx := context.WithContext(context.Background(), "a key", "value")
err3 := oops.
With("driver", "postgresql").
With("query", query).
With("query.duration", queryDuration).
With("lorem", func() string { return "ipsum" }). // lazy evaluation
WithContext(ctx, "a key", "another key").
Errorf("could not fetch user")
// with trace+span
err4 := oops.
Trace(traceID).
Span(spanID).
Errorf("could not fetch user")
// with hint and ownership, for helping developer to solve the issue
err5 := oops.
Hint("The user could have been removed. Please check deleted_at column.").
Owner("Slack: #api-gateway").
Errorf("could not fetch user")
// with optional userID
err6 := oops.
User(userID).
Errorf("could not fetch user")
// with optional user data
err7 := oops.
User(userID, "firstname", "Samuel").
Errorf("could not fetch user")
// with map and slog.Attr user data
err7b := oops.
User(userID,
map[string]any{"plan": "pro"},
slog.String("email", "[email protected]"),
"name",
"Samuel").
Errorf("could not fetch user")
// with optional user and tenant
err8 := oops.
User(userID, "firstname", "Samuel").
Tenant(workspaceID,
map[string]any{"name": "my little project"},
slog.String("country", "fr"),
"locale",
"fr-FR").
Errorf("could not fetch user")
// with optional http request and response
err9 := oops.
Request(req, false).
Response(res, true).
Errorf("could not fetch user")
// reuse an existing OopsErrorBuilder transported in a Go context
ctx := oops.WithBuilder(context.TODO(), err9)
// [...]
err10 := oops.
FromContext(ctx).
Errorf("could not fetch user")
```
### Other helpers
- `oops.AsOops(error) (OopsError, bool)` ā extracts an `oops.OopsError` from an error chain (alias to `errors.As`)
- `oops.AsError[MyError](error) (MyError, bool)` ā generic form of `errors.As`, without requiring a typed variable declaration
### Stack trace
This library provides a pretty printed stack trace for each generated error.
The stack trace max depth can be set using:
```go
// default: 10
oops.StackTraceMaxDepth = 42
```
Callers can be skipped when wrapping oops in helper functions:
```go
func myWrapError(err error) error {
return oops.CallerSkip(1).Wrap(err)
}
```
Specific packages or functions can be permanently excluded from stack traces.
Patterns are matched using `strings.Contains` against the raw values from
`runtime.CallersFrames` (absolute file path and fully-qualified function name):
```go
// Call once at program startup (not goroutine-safe)
oops.FrameSkip("myproject/pkg/errutil", "") // skip by file path substring
oops.FrameSkip("", "WrapErr") // skip by function name substring
```
The stack trace will be printed this way:
```go
err := oops.Errorf("permission denied")
fmt.Println(err.(oops.OopsError).Stacktrace())
```
<div style="text-align:center;">
<img alt="Stacktrace" src="./assets/stacktrace1.png" style="max-width: 650px;">
</div>
Wrapped errors will be reported as an annotated stack trace:
```go
err1 := oops.Errorf("permission denied")
// ...
err2 := oops.Wrapf(err1, "something failed")
fmt.Println(err2.(oops.OopsError).Stacktrace())
```
<div style="text-align:center;">
<img alt="Stacktrace" src="./assets/stacktrace2.png" style="max-width: 650px;">
</div>
### Source fragments
The exact error location can be provided in a Go file extract.
Source fragments are hidden by default. You must run `oops.SourceFragmentsHidden = false` to enable this feature. Go source files being read at run time, you have to keep the source code at the same location.
In a future release, this library is expected to output a colorized extract. Please contribute!
```go
oops.SourceFragmentsHidden = false
err1 := oops.Errorf("permission denied")
// ...
err2 := oops.Wrapf(err1, "something failed")
fmt.Println(err2.(oops.OopsError).Sources())
```
<div style="text-align:center;">
<img alt="Sources" src="./assets/sources1.png" style="max-width: 650px;">
</div>
### Panic handling
`oops` library is delivered with a try/catch -ish error handler. 2 handlers variants are available: `oops.Recover()` and `oops.Recoverf()`. Both can be used in the `oops` error builder with usual methods.
š„· Start hacking `oops.Recover()` with this [playground](https://go.dev/play/p/uGwrFj9mII8).
```go
func mayPanic() {
panic("permission denied")
}
func handlePanic() error {
return oops.
Code("iam_authz_missing_permission").
In("authz").
With("permission", "post.create").
Trace("6710668a-2b2a-4de6-b8cf-3272a476a1c9").
Hint("Runbook: https://doc.acme.org/doc/abcd.md").
Recoverf(func() {
// ...
mayPanic()
// ...
}, "unexpected error %d", 42)
}
```
### Assertions
Assertions may be considered an anti-pattern for Golang since we only call `panic()` for unexpected and critical errors. In this situation, assertions might help developers to write safer code.
```go
func mayPanic() {
x := 42
Frequently Asked Questions
What is oops?
oops is a Error Handling library for the Go programming language. Error handling with context, stack trace and source fragments
How do I install oops?
Install oops with the Go module system using `go get samber/oops`. Check the repository for the current installation instructions.
What category does oops belong to?
oops is listed under Error Handling, specifically Error Handling.