goose/{errors,http}: fix error formatting

http/client.go

 // An HTTP Client which sends json and binary requests, handling data marshalling and response processing.
 
 package http
 
 import (
         "bytes"
         "encoding/json"
         "fmt"
         "io"
         "io/ioutil"
@@ skipping 183 matching lines @@
 
 func (c *Client) sendRateLimitedRequest(method, URL string, headers http.Header, reqData []byte,
         logger *log.Logger) (resp *http.Response, err error) {
         for i := 0; i < c.maxSendAttempts; i++ {
                 var reqReader io.Reader
                 if reqData != nil {
                         reqReader = bytes.NewReader(reqData)
                 }
                 req, err := http.NewRequest(method, URL, reqReader)
                 if err != nil {
-                        err = errors.Newf(err, URL, "failed creating the request")
+                        err = errors.Newf(err, "failed creating the request %s", URL)
                         return nil, err
                 }
                 for header, values := range headers {
                         for _, value := range values {
                                 req.Header.Add(header, value)
                         }
                 }
                 resp, err = c.Do(req)
                 if err != nil {
-                        return nil, errors.Newf(err, URL, "failed executing the request")
+                        return nil, errors.Newf(err, "failed executing the request %s", URL)
                 }
                 if resp.StatusCode != http.StatusRequestEntityTooLarge || resp.Header.Get("Retry-After") == "" {
                         return resp, nil
                 }
                 retryAfter, err := strconv.ParseFloat(resp.Header.Get("Retry-After"), 32)
                 if err != nil {
-                        return nil, errors.Newf(err, URL, "Invalid Retry-After header")
+                        return nil, errors.Newf(err, "Invalid Retry-After header %s", URL)
                 }
                 if retryAfter == 0 {
-                        return nil, errors.Newf(err, URL, "Resource limit exeeded at URL %s.", URL)
+                        return nil, errors.Newf(err, "Resource limit exeeded at URL %s", URL)
                 }
                 if logger != nil {
                         logger.Printf("Too many requests, retrying in %dms.", int(retryAfter*1000))
                 }
                 time.Sleep(time.Duration(retryAfter) * time.Second)
         }
-        return nil, errors.Newf(err, URL,
-                "Maximum number of attempts (%d) reached sending request to %s.", c.maxSendAttempts, URL)
+        return nil, errors.Newf(err, "Maximum number of attempts (%d) reached sending request to %s", c.maxSendAttempts, URL)
 }
 
 type HttpError struct {
         StatusCode      int
         Data            map[string][]string
         url             string
         responseMessage string
 }
 
 func (e *HttpError) Error() string {
@@ skipping 26 matching lines @@
         case http.StatusForbidden, http.StatusUnauthorized:
                 return errors.NewUnauthorisedf(httpError, "", "Unauthorised URL %s", URL)
         case http.StatusBadRequest:
                 dupExp, _ := regexp.Compile(".*already exists.*")
                 if dupExp.Match(errBytes) {
                         return errors.NewDuplicateValuef(httpError, "", string(errBytes))
                 }
         }
         return httpError
 }