[errors] de-specialize Transient in favor of Tags.

grpc/grpcutil/errors.go

 // Copyright 2016 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package grpcutil
 
 import (
-        "github.com/luci/luci-go/common/errors"
-
         "google.golang.org/grpc"
         "google.golang.org/grpc/codes"
+
+        "github.com/luci/luci-go/common/errors"
+        "github.com/luci/luci-go/common/retry"
 )
 
+// Errf falls through to grpc.Errorf, but will tag the resulting error with
+// retry.Tag if it's transient.
+//
+// This is named `Errf` so that it won't trigger "go vet" misuse errors.
+func Errf(code codes.Code, fmt string, a ...interface{}) error {
+        ret := grpc.Errorf(code, fmt, a...)
+        if IsTransientCode(code) {
+                ret = retry.Tag.Apply(ret)

[dnj, 2017/06/24 14:53:55]

This is concerning to me WRT current behavior. I like it, but we should think
hard about its implications.

e.g., previously someone could use "retry.WithTransient" / Transient to tell a
retry loop to retry just "NotFound". Now, it will retry NotFound and other
transient errors.

[iannucci, 2017/06/24 20:16:10]

I'll undo this for now then

+        }
+        return ret
+}
+
 var (
-        // Errf falls through to grpc.Errorf, with the notable exception that it isn't
-        // named "Errorf" and, consequently, won't trigger "go vet" misuse errors.
-        Errf = grpc.Errorf
-
         // OK is an empty grpc.OK status error.
         OK = Errf(codes.OK, "")
 
         // Canceled is an empty grpc.Canceled error.
         Canceled = Errf(codes.Canceled, "")
 
         // Unknown is an empty grpc.Unknown error.
         Unknown = Errf(codes.Unknown, "")
 
         // InvalidArgument is an empty grpc.InvalidArgument error.
@@ skipping 45 matching lines @@
 // If the supplied error is nil, nil will be returned.
 //
 // Note that non-gRPC errors will have code grpc.Unknown, which is considered
 // transient, and be wrapped. This function should only be used on gRPC errors.
 func WrapIfTransient(err error) error {
         if err == nil {
                 return nil
         }
 
         if IsTransientCode(Code(err)) {
-                err = errors.WrapTransient(err)
+                err = retry.Tag.Apply(err)
         }
         return err
 }
 
-const grpcCodeKey = "__grpcutil.Code"
+// Tag may be used to associate a gRPC status code with this error.
+//
+// The tag value MUST be a "google.golang.org/grpc/codes".Code.
+var Tag = errors.NewTagger("gRPC Code", func(v interface{}) {
+        _ = v.(codes.Code)
+})
 
 // Code returns the gRPC code for a given error.
 //
 // In addition to the functionality of grpc.Code, this will unwrap any wrapped
 // errors before asking for its code.
 func Code(err error) codes.Code {
-        if code := errors.ExtractData(err, grpcCodeKey); code != nil {
+        if code, ok := Tag.ValueIn(err); ok {
                 return code.(codes.Code)
         }
         return grpc.Code(errors.Unwrap(err))
 }
 
-// Annotate begins annotating the error, and adds the given gRPC code.
-// This code may be extracted with the Code function in this package.
-func Annotate(err error, code codes.Code) *errors.Annotator {
-        return errors.Annotate(err).D(grpcCodeKey, code)
-}
-
 // ToGRPCErr is a shorthand for Errf(Code(err), "%s", err)
 func ToGRPCErr(err error) error {
         return Errf(Code(err), "%s", err)
 }
 
 // IsTransientCode returns true if a given gRPC code is associated with a
 // transient gRPC error type.
 func IsTransientCode(code codes.Code) bool {
         switch code {
         case codes.Internal, codes.Unknown, codes.Unavailable:
                 return true
 
         default:
                 return false
         }
 }