debug/error: improve monkit naming of drpc errors

also allows for an error to specifically override what
err class monkit displays.

example usage:
https://review.dev.storj.io/c/storj/storj/+/16258

Change-Id: Ib5dc0e12020c3f3a68841fdd8acbf015721173b1

Author: jtolio

debug/error.go

@@ -8,13 +8,41 @@ import (
 
 	"github.com/spacemonkeygo/monkit/v3"
 
-	"storj.io/drpc/drpcerr"
+	"storj.io/common/rpc/rpcstatus"
 )
 
 func init() {
 	monkit.AddErrorNameHandler(func(err error) (string, bool) {
-		if code := drpcerr.Code(err); code != 0 {
-			return fmt.Sprintf("drpc_%d", code), true
+		var code uint64
+	forLoop:
+		for i := 0; i < 100; i++ {
+			if v, ok := err.(interface{ Name() (string, bool) }); ok {
+				if cls, ok := v.Name(); ok && cls != "" {
+					return cls, true
+				}
+			}
+			if v, ok := err.(interface{ Code() uint64 }); ok {
+				if code == 0 {
+					code = v.Code()
+				}
+			}
+			switch v := err.(type) { //nolint: errorlint // this is a custom unwrap loop
+			case interface{ Cause() error }:
+				err = v.Cause()
+			case interface{ Unwrap() error }:
+				err = v.Unwrap()
+			case interface{ Unwrap() []error }:
+				errs := v.Unwrap()
+				if len(errs) == 0 {
+					break
+				}
+				err = errs[0]
+			default:
+				break forLoop
+			}
+		}
+		if code != 0 {
+			return fmt.Sprintf("drpc_%s", rpcstatus.StatusCode(code).String()), true
 		}
 		return "", false
 	})

rpc/rpcstatus/status.go

@@ -70,21 +70,18 @@ func Code(err error) StatusCode {
 	case errors.Is(err, context.DeadlineExceeded):
 		return DeadlineExceeded
 	default:
-		if code := StatusCode(drpcerr.Code(err)); code != Unknown {
-			return code
-		}
-
-		return Unknown
+		return StatusCode(drpcerr.Code(err))
 	}
 }
 
-// Wrap wraps the error with the provided status code.
-func Wrap(code StatusCode, err error) error {
+// NamedWrap returns the err error wrapped with a defined monkit class name and status code.
+func NamedWrap(name string, code StatusCode, err error) error {
 	if err == nil {
 		return nil
 	}
 
 	ce := &codeErr{
+		name: name,
 		code: code,
 	}
 
@@ -96,14 +93,29 @@ func Wrap(code StatusCode, err error) error {
 	return ce
 }
 
+// NamedError creates and returns an error wrapped with a defined monkit class name and status code.
+func NamedError(name string, code StatusCode, msg string) error {
+	return NamedWrap(name, code, errs.New("%s", msg))
+}
+
+// NamedErrorf creates and returns an error wrapped with a defined monkit class name and status code.
+func NamedErrorf(name string, code StatusCode, format string, a ...any) error {
+	return NamedWrap(name, code, errs.New(format, a...))
+}
+
+// Wrap wraps the error with the provided status code.
+func Wrap(code StatusCode, err error) error {
+	return NamedWrap("", code, err)
+}
+
 // Error wraps the message with a status code into an error.
 func Error(code StatusCode, msg string) error {
-	return Wrap(code, errs.New("%s", msg))
+	return NamedError("", code, msg)
 }
 
 // Errorf : Error :: fmt.Sprintf : fmt.Sprint.
 func Errorf(code StatusCode, format string, a ...interface{}) error {
-	return Wrap(code, errs.New(format, a...))
+	return NamedErrorf("", code, format, a...)
 }
 
 type errsError interface {
@@ -114,11 +126,13 @@ type errsError interface {
 
 // codeErr implements error that can work both in grpc and drpc.
 type codeErr struct {
+	name string
 	errsError
 	code StatusCode
 }
 
 func (c *codeErr) Unwrap() error { return c.errsError }
 func (c *codeErr) Cause() error  { return c.errsError }
 
-func (c *codeErr) Code() uint64 { return uint64(c.code) }
+func (c *codeErr) Code() uint64         { return uint64(c.code) }
+func (c *codeErr) Name() (string, bool) { return c.name, c.name != "" }