Go Error Wrapping: Difference between revisions

From NovaOrdis Knowledge Base
Jump to navigation Jump to search
Line 11: Line 11:
Error wrapping and returning the result to the upper layer is just one of the error handling patterns in Go. The others are [[Go_Language_Error_Handling#Deal_with_the_Consequences_and_Continue_the_Flow|fully handling the error without returning it]], simply [[Go_Language_Error_Handling#Handle_the_Error_as_Opaque_and_Return_It_Unmodified|returning it without any modification]], and [[Go_Language_Error_Handling#Annotate_the_Error|returning a new annotated error]].  
Error wrapping and returning the result to the upper layer is just one of the error handling patterns in Go. The others are [[Go_Language_Error_Handling#Deal_with_the_Consequences_and_Continue_the_Flow|fully handling the error without returning it]], simply [[Go_Language_Error_Handling#Handle_the_Error_as_Opaque_and_Return_It_Unmodified|returning it without any modification]], and [[Go_Language_Error_Handling#Annotate_the_Error|returning a new annotated error]].  


This pattern consists in wrapping an error returned by the underlying layer into an "outer" error instance. This is typically done to add information relevant to the context that caught the error being processed. For example, if access to a database fails with access denied, handing the error may consist in wrapping the original error into a new error that also includes the user and the operation, which is richer context that can help with troubleshooting the problem by the operators of the program.
This pattern consists in wrapping an error returned by the underlying layer into an "outer" error instance. This is typically done to '''add information relevant to the context''' that caught the error being processed. For example, if access to a database fails with access denied, handing the error may consist in wrapping the original error into a new error that also includes the user and the operation, which is richer context that can help with troubleshooting the problem by the operators of the program.


Another situation when wrapping the error is useful is when we want to mark the error as a specific type. For example, the same access denied to the database can be wrapped into a "Forbidden" error type, so a hypothetical HTTP handling layer that receives the error returns a 403 status code.
Another situation when wrapping the error is useful is when we want to '''mark the error as a specific type'''. For example, the same access denied to the database can be wrapped into a "Forbidden" error type, so a hypothetical HTTP handling layer that receives the error returns a 403 status code.


However, wrapping the error is more than [[Go_Language_Error_Handling#Annotate_the_Error|error annotation]], because it involves embedding an actual error instance, preserving its unique identity, instead of concatenating strings.
However, wrapping the error is more than [[Go_Language_Error_Handling#Annotate_the_Error|error annotation]], because it involves embedding an actual error instance, preserving its unique identity, instead of concatenating strings.

Revision as of 01:48, 31 December 2023

External

Internal

Overview

The error mechanism in Go allows "wrapping" error instances into other error instances, while preserving the wrapped error identity. This pattern supports building an error tree that is useful in preserving context.

Error wrapping should be the preferred pattern to use when we want to provide additional context to an error

Error wrapping and returning the result to the upper layer is just one of the error handling patterns in Go. The others are fully handling the error without returning it, simply returning it without any modification, and returning a new annotated error.

This pattern consists in wrapping an error returned by the underlying layer into an "outer" error instance. This is typically done to add information relevant to the context that caught the error being processed. For example, if access to a database fails with access denied, handing the error may consist in wrapping the original error into a new error that also includes the user and the operation, which is richer context that can help with troubleshooting the problem by the operators of the program.

Another situation when wrapping the error is useful is when we want to mark the error as a specific type. For example, the same access denied to the database can be wrapped into a "Forbidden" error type, so a hypothetical HTTP handling layer that receives the error returns a 403 status code.

However, wrapping the error is more than error annotation, because it involves embedding an actual error instance, preserving its unique identity, instead of concatenating strings.

Wrap the Error

Individual errors are typically wrapped with fmt.Errorf(). To wrap multiple error instances into a single outer error, use errors.Join().

Wrap an Individual Error

A typical error handling pattern is to handle an error returned by a function invocation by "wrapping" it into an outer error instance that provides additional context, in form of an addition error text message.The approach is different from annotating the error because it creates a new error instance while preserving the identity of the wrapped error. The wrapped error is still reachable by introspecting the error tree with methods like errors.Is() or errors.As().

The error is wrapped with fmt.Errorf() and %w conversion character:

if err != nil {
  outer := fmt.Errorf("additional context: %w", err)
  return outer
}

fmt.Errorf() call creates a new error instance whose Error() method concatenates the error message provided as argument and the inner error message:

additional context: original context

The outer error assumes the logical identity of the inner error: the outer error "is" all its inner errors. This can be checked programmatically with errors.Is() function:

errors.Is(outer, err) // returns true

The outer error becomes the direct ancestor of the wrapped error, and successive invocations of the fmt.Errorf() result in an error tree, where the identity of the wrapped errors can be checked with errors.Is(). More details on errors.Is() can be found below. The wrapped error can be obtained from the outer error by calling errors.Unwrap().

Invoking fmt.Errorf() with More that One Error Argument

fmt.Errorf() is conventionally invoked with just one "%w" conversion character and one error argument. This results in building a degenerated tree that is in fact a linked list. However, more than one error can be provided as argument to fmt.Errorf():

err := fmt.Errorf("err")
err2 := fmt.Errorf("err2")
outer := fmt.Errorf("outer: %w %w", err, err2)
println(errors.Is(outer, err))  // prints true
println(errors.Is(outer, err2)) // prints true

The behavior of errors.Unwrap() seems to be a bit inconsistent in this situation: it won't return the error instances, but nil. This seems to imply that fmt.Errors() should only be used to wrap a single error.

errors.Join()

https://pkg.go.dev/errors#Join

Join returns an error that wraps the given errors. Any nil error values are discarded. Join returns nil if every value provided as argument is nil. The error formats as the concatenation of the strings obtained by calling the Error() method of each element, with a newline between each string.

Inspect the Error Tree

errors.Is()

https://pkg.go.dev/errors#Is

The presence of a wrapped error inside an outer error, as a direct or indirect descendant in the error tree rooted in the outer error, can be confirmed with errors.Is(<outer_error>, <sought_for_error>) function. Always prefer errors.Is() over type assertions. errors.Is() is designed to work with both individual errors and wrapped errors. Furthermore, errors.Is() is safe to use if the first argument, outer_error is nil.

orig := fmt.Errorf("original error")
intermediate := fmt.Errorf("intermediate error: %w", orig)
outer := fmt.Errorf("final intermediate error: %w", intermediate)
println(errors.Is(outer, intermediate)) // prints "true"
println(errors.Is(outer, orig))         // prints "true"
println(errors.Is(intermediate, orig))  // prints "true"

errors.As()

https://pkg.go.dev/errors#As

errors.As() provides a safe way to locate the first error in the error tree that matches the error type provided as the second argument. If no match is found, the function returns false. errors.As() is similar, but weaker form of errors.Is() with the difference that types, and not identities are compared.

errors.Unwrap()

https://pkg.go.dev/errors#Unwrap

errors.Unwrap(<outer_error>) returns the inner error instance wrapped inside the outer error by a fmt.Errorf("%w") call. errors.Unwrap() does not unwrap errors returned by errors.Join().

orig := fmt.Errorf("original error")
intermediate := fmt.Errorf("intermediate error: %w", orig)
outer := fmt.Errorf("final intermediate error: %w", intermediate)
println(errors.Unwrap(outer) == intermediate) // prints true
println(errors.Unwrap(intermediate) == orig)  // prints true

When more than one errors is wrapped with fmt.Errorf(), errors.Unwrap() returns nil. This seems to be a bit inconsistent, and implies that fmt.Errorf() should only be used to wrap single errors.

Unwrap() errror Implementation

Example:

Custom Error Types | Unwrap() implementation