Add HTTP error annotation.

common/lhttp/client.go

 // Copyright 2015 The LUCI Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 36 matching lines @@
 // Return the same error again to continue retry behaviour, or nil to pretend
 // this error was a success.
 type ErrorHandler func(resp *http.Response, err error) error
 
 // RequestGen is a generator function to create a new request. It may be called
 // multiple times if an operation needs to be retried. The HTTP server is
 // responsible for closing the Request body, as per http.Request Body method
 // documentation.
 type RequestGen func() (*http.Request, error)
 
+var httpTagKey = errors.NewTagKey("this is an HTTP error")
+
+func applyHTTPTag(err error, status int) error {
+        return errors.TagValue{Key: httpTagKey, Value: status}.Apply(err)
+}
+
+func IsHTTPError(err error) (status int, ok bool) {
+        d, ok := errors.TagValueIn(httpTagKey, err)
+        if ok {
+                status = d.(int)
+        }
+        return
+}
+
 // NewRequest returns a retriable request.
 //
 // The handler func is responsible for closing the response Body before
 // returning. It should return retry.Error in case of retriable error, for
 // example if a TCP connection is terminated while receiving the content.
 //
 // If rFn is nil, NewRequest will use a default exponential backoff strategy
 // only for transient errors.
 //
 // If errorHandler is nil, the default error handler will drain and close the
@@ skipping 43 matching lines @@
                                         Tag(transient.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)
                         }
 
+                        err = applyHTTPTag(err, status)
                         return errorHandler(resp, err)
                 }, nil)
                 if err != nil {
-                        err = fmt.Errorf("%v (attempts: %d)", err, attempts)
+                        err = errors.Annotate(err, "gave up after %d attempts", attempts).Err()
                 }
                 return status, err
         }
 }
 
 // NewRequestJSON returns a retriable request calling a JSON endpoint.
 func NewRequestJSON(ctx context.Context, c *http.Client, rFn retry.Factory, url, method string, headers map[string]string, in, out interface{}) (func() (int, error), error) {
         var encoded []byte
         if in != nil {
                 var err error
@@ skipping 50 matching lines @@
 }
 
 // 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()
 }