[errors] Greatly simplify common/errors package.

luci_config/appengine/backend/datastore/ds.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 datastore
 
 import (
         "time"
 
         "github.com/luci/luci-go/appengine/datastorecache"
@@ skipping 125 matching lines @@
                 // Always ask for full content.
                 key.Content = true
         }
 
         // Encode our caching key, and use this for our datastore cache key.
         //
         // This gets recoded in dsCacheHandler's "Refresh" to identify the cache
         // operation that is being performed.
         encKey, err := caching.Encode(&key)
         if err != nil {
-                return nil, errors.Annotate(err).Reason("failed to encode cache key").Err()
+                return nil, errors.Annotate(err, "failed to encode cache key").Err()
         }
 
         // Construct a cache handler.
         v, err := cache.Get(dc.WithHandler(c, l, 0), encKey)
         if err != nil {
                 return nil, err
         }
 
         // Decode our response.
         if v.Schema != dsCacheSchema {
-                return nil, errors.Reason("response schema (%(resp)q) doesn't match current (%(cur)q)").
-                        D("resp", v.Schema).D("cur", dsCacheSchema).Err()
+                return nil, errors.Reason("response schema (%q) doesn't match current (%q)",
+                        v.Schema, dsCacheSchema).Err()
         }
 
         cacheValue, err := caching.DecodeValue(v.Data)
         if err != nil {
-                return nil, errors.Annotate(err).Reason("failed to decode cached value").Err()
+                return nil, errors.Annotate(err, "failed to decode cached value").Err()
         }
 
         // Prune any responses that are not permitted for the supplied Authority.
         switch key.Op {
         case caching.OpGetAll:
                 if len(cacheValue.Items) > 0 {
                         // Shift over any elements that can't be accessed.
                         ptr := 0
                         for _, itm := range cacheValue.Items {
                                 if dc.accessConfigSet(c, origAuthority, itm.ConfigSet) {
@@ skipping 69 matching lines @@
         // operation. This is used for cron operations.
         loaderTimeout time.Duration
 }
 
 func (dch *dsCacheHandler) FailOpen() bool                       { return dch.failOpen }
 func (dch *dsCacheHandler) RefreshInterval([]byte) time.Duration { return dch.refreshInterval }
 func (dch *dsCacheHandler) Refresh(c context.Context, key []byte, v datastorecache.Value) (datastorecache.Value, error) {
         // Decode the key into our caching key.
         var ck caching.Key
         if err := caching.Decode(key, &ck); err != nil {
-                return v, errors.Annotate(err).Reason("failed to decode cache key").Err()
+                return v, errors.Annotate(err, "failed to decode cache key").Err()
         }
 
         var cv *caching.Value
         if v.Schema == dsCacheSchema && len(v.Data) > 0 {
                 // We have a currently-cached value, so decode it into "cv".
                 var err error
                 if cv, err = caching.DecodeValue(v.Data); err != nil {
-                        return v, errors.Annotate(err).Reason("failed to decode cache value").Err()
+                        return v, errors.Annotate(err, "failed to decode cache value").Err()
                 }
         }
 
         // Apply our timeout, if configured (influences urlfetch).
         if dch.loaderTimeout > 0 {
                 var cancelFunc context.CancelFunc
                 c, cancelFunc = clock.WithTimeout(c, dch.loaderTimeout)
                 defer cancelFunc()
         }
 
         // Perform a cache load on this value.
         cv, err := dch.loader(c, ck, cv)
         if err != nil {
-                return v, errors.Annotate(err).Reason("failed to load cache value").Err()
+                return v, errors.Annotate(err, "failed to load cache value").Err()
         }
 
         keyDesc := ck.String()
         valueDesc := cv.Description()
         log.Infof(c, "Loaded [%s]: %s", keyDesc, valueDesc)
 
         // Encode the resulting cache value.
         if v.Data, err = cv.Encode(); err != nil {
-                return v, errors.Annotate(err).Reason("failed to encode cache value").Err()
+                return v, errors.Annotate(err, "failed to encode cache value").Err()
         }
         v.Schema = dsCacheSchema
         v.Description = keyDesc + ": " + valueDesc
         return v, nil
 }
 
 func (dch *dsCacheHandler) Locker(c context.Context) datastorecache.Locker {
         if dch.lockerFunc != nil {
                 return dch.lockerFunc(c)
         }
         return nil
 }
 
 // CronLoader returns a caching.Loader implementation to be used
 // by the Cron task.
 func CronLoader(b backend.B) caching.Loader {
         return func(c context.Context, k caching.Key, v *caching.Value) (*caching.Value, error) {
                 return caching.CacheLoad(c, b, k, v)
         }
 }