Clone this repo:


  1. 3622ed4 Merge pull request #10 from hashicorp/compliance/add-license by Caleb Albers · 8 months ago master
  2. 33906e6 [COMPLIANCE] Update MPL 2.0 LICENSE by hashicorp-copywrite[bot] · 12 months ago
  3. 7b00e5d Merge pull request #9 from hashicorp/go1.13-errors-compat by Daniel Nephin · 3 years, 2 months ago v1.1.0
  4. 96a78fc Unwrap in Walk for compat with go1.13 errors by Daniel Nephin · 3 years, 2 months ago
  5. 09e55f2 Add Unwrap for compat with go1.13 errors by Daniel Nephin · 3 years, 2 months ago


errwrap is a package for Go that formalizes the pattern of wrapping errors and checking if an error contains another error.

There is a common pattern in Go of taking a returned error value and then wrapping it (such as with fmt.Errorf) before returning it. The problem with this pattern is that you completely lose the original error structure.

Arguably the correct approach is that you should make a custom structure implementing the error interface, and have the original error as a field on that structure, such as this example. This is a good approach, but you have to know the entire chain of possible rewrapping that happens, when you might just care about one.

errwrap formalizes this pattern (it doesn't matter what approach you use above) by giving a single interface for wrapping errors, checking if a specific error is wrapped, and extracting that error.

Installation and Docs

Install using go get

Full documentation is available at


Basic Usage

Below is a very basic example of its usage:

// A function that always returns an error, but wraps it, like a real
// function might.
func tryOpen() error {
	_, err := os.Open("/i/dont/exist")
	if err != nil {
		return errwrap.Wrapf("Doesn't exist: {{err}}", err)

	return nil

func main() {
	err := tryOpen()

	// We can use the Contains helpers to check if an error contains
	// another error. It is safe to do this with a nil error, or with
	// an error that doesn't even use the errwrap package.
	if errwrap.Contains(err, "does not exist") {
		// Do something
	if errwrap.ContainsType(err, new(os.PathError)) {
		// Do something

	// Or we can use the associated `Get` functions to just extract
	// a specific error. This would return nil if that specific error doesn't
	// exist.
	perr := errwrap.GetType(err, new(os.PathError))

Custom Types

If you're already making custom types that properly wrap errors, then you can get all the functionality of errwraps.Contains and such by implementing the Wrapper interface with just one function. Example:

type AppError {
  Code ErrorCode
  Err  error

func (e *AppError) WrappedErrors() []error {
  return []error{e.Err}

Now this works:

err := &AppError{Err: fmt.Errorf("an error")}
if errwrap.ContainsType(err, fmt.Errorf("")) {
	// This will work!