terrors

func Augment ¶

func Augment(err error, context string, params map[string]string) error

Augment adds context to an existing error. If the error given is not already a terror, a new terror is created.

func Is ¶

func Is(err error, code ...string) bool

Is checks whether an error is a given code. Similarly to `errors.Is`, this unwinds the error stack and checks each underlying error for the code. If any match, this returns true. Note that Is only behaves differently to PrefixMatches when errors in the stack have different codes. For example, this is the case when errors are initialized with NewInternalWithCause, but not with Augment. We prefer this over using a method receiver on the terrors Error, as the function signature requires an error to test against, and checking against terrors would requite creating a new terror with the specific code.

func IsRetryable ¶

func IsRetryable(err error) bool

IsRetryable returns true if the error is a terror and whether the error was caused by an action which can be retried.

func Marshal ¶

func Marshal(e *Error) *pe.Error

Marshal an error into a protobuf for transmission

func Matches ¶

func Matches(err error, match string) bool

Matches returns true if the error is a terror error and the string returned from error.Error() contains the given param string. This means you can match the error on different levels e.g. dotted codes `bad_request` or `bad_request.missing_param` or even on the more descriptive message Deprecated: Please use `Is` instead. Note that `Is` will attempt to match each error in the stack using `PrefixMatches`, so if you were previously matching against a part of the string returned from error.Error() that is _not_ the prefix, then this will be a breaking change. In this case you should update the string to match the prefix. If this is not possible, you can match against the entire error string explicitly, for example:

strings.Contains(err.Error(), "context deadline exceeded")

But we consider this bad practice and is part of the motivation for deprecating Matches in the first place.

err := NotFound("handler_missing", "Handler not found", nil)
fmt.Println(Matches(err, "not_found.handler_missing"))

Output:

true

func PrefixMatches ¶

func PrefixMatches(err error, prefixParts ...string) bool

PrefixMatches returns true if the error is a terror and the string returned from error.Error() starts with the given param string. This means you can match the error on different levels e.g. dotted codes `bad_request` or `bad_request.missing_param`. Each dotted part can be passed as a separate argument e.g. `terrors.PrefixMatches(terr, terrors.ErrBadRequest, "missing_param")` is the same as terrors.PrefixMatches(terr, "bad_request.missing_param")` Deprecated: Please use `Is` instead.

func Propagate ¶

func Propagate(err error) error

Propagate an error without changing it. This is equivalent to `return err` if the error is already a terror. If it is not a terror, this function will create one, and set the given error as the cause. This is a drop-in replacement for `terrors.Wrap(err, nil)` which adds causal chain functionality.

func StackStringWithMaxSize ¶

func StackStringWithMaxSize(p *Error, sizeLimit int) string

func Wrap ¶

func Wrap(err error, params map[string]string) error

Wrap takes any error interface and wraps it into an Error. This is useful because an Error contains lots of useful goodies, like the stacktrace of the error. NOTE: If `err` is already an `Error`, it will add the params passed in to the params of the Error Deprecated: Use Augment instead.

func WrapWithCode ¶

func WrapWithCode(err error, params map[string]string, code string) error

WrapWithCode wraps an error with a custom error code. If `err` is already an `Error`, it will add the params passed in to the params of the error Deprecated: Use Augment instead. If you need to set the code of the error, then you should return a new error instead. For example

terrors.WrapWithCode(err, map[string]string{"foo": "bar"}, "bad_request.failed")

would become

terrors.BadRequest("failed", err.Error(), map[string]string{"foo": "bar"})

fn := "not/a/file"
_, err := os.Open(fn)
if err != nil {
	errParams := map[string]string{
		"filename": fn,
	}
	err = WrapWithCode(err, errParams, ErrNotFound)
	terr := err.(*Error)
	fmt.Println(terr.Error())
	

Output:

not_found: open not/a/file: no such file or directory