[errors] Greatly simplify common/errors package.

luci_config/appengine/backend/memcache/cache.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 memcache implements a caching config client backend backed by
 // AppEngine's memcache service.
 package memcache
 
 import (
         "encoding/hex"
@@ skipping 25 matching lines @@
                         }
 
                         // Is the item already cached?
                         k := memcacheKey(&key)
                         mci, err := mc.GetKey(c, k)
                         switch err {
                         case nil:
                                 // Value was cached, successfully retrieved.
                                 v, err := caching.DecodeValue(mci.Value())
                                 if err != nil {
-                                        return nil, errors.Annotate(err).Reason("failed to decode cache value from %(key)q").
-                                                D("key", k).Err()
+                                        return nil, errors.Annotate(err, "failed to decode cache value from %q", k).Err()
                                 }
                                 return v, nil
 
                         case mc.ErrCacheMiss:
                                 // Value was not cached. Load from Loader and cache.
                                 v, err := l(c, key, nil)
                                 if err != nil {
                                         return nil, err
                                 }
 
                                 // Attempt to cache the value. If this fails, we'll log a warning and
                                 // move on.
                                 err = func() error {
                                         d, err := v.Encode()
                                         if err != nil {
-                                                return errors.Annotate(err).Reason("failed to encode value").Err()
+                                                return errors.Annotate(err, "failed to encode value").Err()
                                         }
 
                                         if len(d) > maxMemCacheSize {
-                                                return errors.Reason("entry exceeds memcache size (%(size)d > %(max)d)").
-                                                        D("size", len(d)).D("max", maxMemCacheSize).Err()
+                                                return errors.Reason("entry exceeds memcache size (%d > %d)", len(d), maxMemCacheSize).Err()
                                         }
 
                                         item := mc.NewItem(c, k).SetValue(d).SetExpiration(exp)
                                         if err := mc.Set(c, item); err != nil {
-                                                return errors.Annotate(err).Err()
+                                                return errors.Annotate(err, "").Err()
                                         }
                                         return nil
                                 }()
                                 if err != nil {
                                         log.Fields{
                                                 log.ErrorKey: err,
                                                 "key":        k,
                                         }.Warningf(c, "Failed to cache config.")
                                 }
 
                                 // Return the loaded value.
                                 return v, nil
 
                         default:
                                 // Unknown memcache error.
                                 log.Fields{
                                         log.ErrorKey: err,
                                         "key":        k,
                                 }.Warningf(c, "Failed to decode memcached config.")
                                 return l(c, key, nil)
                         }
                 },
         }
 }
 
 func memcacheKey(key *caching.Key) string { return hex.EncodeToString(key.ParamHash()) }