How to implement stack tracing?

I am trying to implement stack error tracing. I am having difficulty tracing the error. The following code catches the db error. But it doesn’t trace the error:

// err represents *db.Error
if err != nil {
  return nil, errors.Wrap(err, "error msg")
}

// Now, in the error middleware:
func traceError(err error) {
	_, ok := err.(stackTracer)
	if ok {
		fmt.Print("tracer implemented")
	} else {
		fmt.Print("tracer not implemented")
	}
}
switch e := errors.Cause(err).(type) {
  case *db.Error:
    fmt.Print("caught db error")
    traceError(err)
  defaut:
    fmt.Print("unknown error")
    traceError(err)
}

Outputs:

caught db error
tracer not implemented

When I create new error the trace is implemented:

// err represents *db.Error
if err != nil {
  newError := errors.New(err.Error())
  return nil, errors.Wrap(newError, "error msg")
}

Outputs:

unknown error
tracer implemented

My desired output is:

caught db error
tracer implemented

Edit: After re-looking I found my code is working fine. I might have messed something somewhere in my code.

Just noticed that the question is talking about the package github.com/pkg/errors. Except for some syntax error in the question, it works as expected:

package main

import (
	"fmt"
	"io/fs"
	"os"

	"github.com/pkg/errors"
)

func fn() error {
	_, err := os.Open("non-existing")
	if err != nil {
		return errors.Wrap(err, "fn")
	}

	return nil
}

type stackTracer interface {
	StackTrace() errors.StackTrace
}

func traceError(err error) {
	_, ok := err.(stackTracer)
	if ok {
		fmt.Println("tracer implemented")
	} else {
		fmt.Println("tracer not implemented")
	}
}

func main() {
	err := fn()

	switch e := errors.Cause(err); e.(type) {
	case *fs.PathError:
		fmt.Println("caught fs error")
		traceError(err)
	default:
		fmt.Println("unknown error")
		traceError(err)
	}
}

The output is:

caught fs error
tracer implemented