Documentation
¶
Index ¶
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func HasTag ¶
Example ¶
package main
import (
"fmt"
"github.com/adamluzsi/frameless/pkg/errorutil"
)
func main() {
type MyTag struct{}
err := fmt.Errorf("foo bar baz")
errorutil.HasTag(err, MyTag{}) // false
err = errorutil.Tag(err, MyTag{})
errorutil.HasTag(err, MyTag{}) // true
}
Output:
func LookupDetail ¶
func Merge ¶
Merge will combine all given non nil error values into a single error value. If no valid error is given, nil is returned. If only a single non nil error value is given, the error value is returned.
Example ¶
package main
import (
"fmt"
"github.com/adamluzsi/frameless/pkg/errorutil"
)
func main() {
// creates an error value that combines the input errors.
err := errorutil.Merge(fmt.Errorf("foo"), fmt.Errorf("bar"), nil)
_ = err
}
Output:
Types ¶
type Error ¶
type Error string
Error is an implementation for the error interface that allow you to declare exported globals with the `consttypes` keyword.
TL;DR: consttypes ErrSomething errorutil.Error = "something is an error"
type ErrorHandler ¶
type ErrorHandler interface {
// HandleError allow the interactor implementation to be notified about unexpected situations.
HandleError(ctx context.Context, err error) error
}
ErrorHandler describes that an object able to handle error use-cases for its purpose.
For e.g. if the component is a pubsub subscription event handler, then implementing ErrorHandler means it suppose to handle unexpected use-cases such as connection interruption.
type UserError ¶
type UserError struct {
// ID is a constant string value that expresses the user's error scenario.
// The caller who receives the error will use this code to present the UserError to their users and,
// most likely, provide a localised error message about the error scenario to the end user.
// Traditionally this should be a string without any white space.
//
// Example: "foo-is-forbidden-with-active-baz"
ID consttypes.String
// Message is the error message meant to be read by a developer working on the implementation of the caller.
// It is not expected to be seen by end users.
// It might be written in English for portability reasons.
//
// Example: "Authentication failed due to incorrect username or password."
Message consttypes.String
}
Example ¶
package main
import (
"errors"
"fmt"
"math/rand"
"github.com/adamluzsi/frameless/pkg/errorutil"
)
func main() {
fooEntityID := rand.Int()
bazEntityID := rand.Int()
usrerr := errorutil.UserError{
ID: "foo-is-forbidden-with-active-baz",
Message: "It is forbidden to execute Foo when you have an active Baz",
}
var err error = usrerr.With().Detailf("Foo(ID:%d) /Baz(ID:%d)", fooEntityID, bazEntityID)
// add some details using error wrapping
err = fmt.Errorf("some wrapper layer: %w", err)
// retrieve with errors pkg
if ue := (errorutil.UserError{}); errors.As(err, &ue) {
fmt.Printf("%#v\n", ue)
}
if errors.Is(err, errorutil.UserError{}) {
fmt.Println("it's a Layer 8 error")
}
// retrieve with errorutil pkg
if userError, ok := errorutil.LookupUserError(err); ok {
fmt.Printf("%#v\n", userError)
}
}
Output:
func LookupUserError ¶
Example ¶
package main
import (
"fmt"
"github.com/adamluzsi/frameless/pkg/errorutil"
)
func main() {
err := errorutil.UserError{
ID: "constant-err-scenario-code",
Message: "some message for the dev",
}
if userError, ok := errorutil.LookupUserError(err); ok {
fmt.Printf("%#v\n", userError)
}
}
Output:
func (UserError) With ¶
Example ¶
package main
import (
"github.com/adamluzsi/frameless/pkg/errorutil"
)
func main() {
usrErr := errorutil.UserError{
ID: "foo-is-forbidden-with-active-baz",
Message: "It is forbidden to execute Foo when you have an active Baz",
}
// returns with Err that has additional concrete details
_ = usrErr.With().Detailf("Foo(ID:%d) /Baz(ID:%d)", 42, 7)
}
Output:
type WithErr ¶ added in v0.90.0
type WithErr struct{ Err error }
func (WithErr) Context ¶ added in v0.90.0
Context will combine an error with a context, so the current context can be used at the place of error handling. This can be useful if tracing ID and other helpful values are kept in the context.
Example ¶
package main
import (
"context"
"fmt"
"github.com/adamluzsi/frameless/pkg/errorutil"
)
func main() {
err := fmt.Errorf("foo bar baz")
ctx := context.Background()
err = errorutil.With(err).
Context(ctx)
_, _ = errorutil.LookupContext(err) // ctx, true
}
Output:
func (WithErr) Detail ¶ added in v0.90.0
Detail will return an error that has explanation as detail attached to it.
Example ¶
package main
import (
"fmt"
"github.com/adamluzsi/frameless/pkg/errorutil"
)
func main() {
err := fmt.Errorf("foo bar baz")
err = errorutil.With(err).
Detail("it was the foo or bar or baz")
_, _ = errorutil.LookupDetail(err) // "it was the foo or bar or baz", true
}
Output:
func (WithErr) Detailf ¶ added in v0.90.0
Detailf will return an error that has explanation as detail attached to it. Detailf formats according to a fmt format specifier and returns the resulting string.
Example ¶
package main
import (
"fmt"
"github.com/adamluzsi/frameless/pkg/errorutil"
)
func main() {
err := fmt.Errorf("foo bar baz")
err = errorutil.With(err).
Detailf("--> %s <--", "it was the foo or bar or baz")
_, _ = errorutil.LookupDetail(err) // "--> it was the foo or bar or baz <--", true
}
Output:
Source Files
Click to show internal directories.
Click to hide internal directories.