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

common/lhttp/client.go

 // Copyright 2015 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 lhttp
 
 import (
         "bytes"
         "encoding/json"
         "fmt"
@@ skipping 65 matching lines @@
                         attempts++
                         req, err := rgen()
                         if err != nil {
                                 return err
                         }
 
                         resp, err := c.Do(req)
                         if err != nil {
                                 // Retry every error. This is sad when you specify an invalid hostname but
                                 // it's better than failing when DNS resolution is flaky.
-                                return errorHandler(nil, errors.WrapTransient(err))
+                                return errorHandler(nil, retry.Tag.Apply(err))
                         }
                         status = resp.StatusCode
 
                         switch {
                         case status == 408, status == 429, status >= 500:
                                 // The HTTP status code means the request should be retried.
-                                err = errors.WrapTransient(
-                                        fmt.Errorf("http request failed: %s (HTTP %d)", http.StatusText(status), status))
+                                err = errors.Reason("http request failed: %(text)s (HTTP %(code)d)").
+                                        D("text", http.StatusText(status)).D("code", status).Tag(retry.Tag).Err()
                         case status == 404 && strings.HasPrefix(req.URL.Path, "/_ah/api/"):
                                 // Endpoints occasionally return 404 on valid requests!
                                 logging.Infof(ctx, "lhttp.Do() got a Cloud Endpoints 404: %#v", resp.Header)
-                                err = errors.WrapTransient(
-                                        fmt.Errorf("http request failed (endpoints): %s (HTTP %d)", http.StatusText(status), status))
+                                err = errors.Reason("http request failed (endpoints): %(text)s (HTTP %(code)d)").
+                                        D("text", http.StatusText(status)).D("code", status).Tag(retry.Tag).Err()
                         case status >= 400:
                                 // Any other failure code is a hard failure.
                                 err = fmt.Errorf("http request failed: %s (HTTP %d)", http.StatusText(status), status)
                         default:
                                 // The handler may still return a retry.Error to indicate that the request
                                 // should be retried even on successful status code.
                                 return handler(resp)
                         }
 
                         return errorHandler(resp, err)
@@ skipping 40 matching lines @@
                         // Non-retriable.
                         return fmt.Errorf("unexpected Content-Type, expected \"%s\", got \"%s\"", jsonContentType, ct)
                 }
                 if out == nil {
                         // The client doesn't care about the response. Still ensure the response
                         // is valid json.
                         out = &map[string]interface{}{}
                 }
                 if err := json.NewDecoder(resp.Body).Decode(out); err != nil {
                         // Retriable.
-                        return errors.WrapTransient(fmt.Errorf("bad response %s: %s", url, err))
+                        return errors.Annotate(err).Reason("bad response %(url)s").
+                                D("url", url).Tag(retry.Tag).Err()
                 }
                 return nil
         }, nil), nil
 }
 
 // GetJSON is a shorthand. It returns the HTTP status code and error if any.
 func GetJSON(ctx context.Context, rFn retry.Factory, c *http.Client, url string, out interface{}) (int, error) {
         req, err := NewRequestJSON(ctx, c, rFn, url, "GET", nil, nil, out)
         if err != nil {
                 return 0, err
         }
         return req()
 }
 
 // PostJSON is a shorthand. It returns the HTTP status code and error if any.
 func PostJSON(ctx context.Context, rFn retry.Factory, c *http.Client, url string, headers map[string]string, in, out interface{}) (int, error) {
         req, err := NewRequestJSON(ctx, c, rFn, url, "POST", headers, in, out)
         if err != nil {
                 return 0, err
         }
         return req()
 }