[errors] Greatly simplify common/errors package.

logdog/server/service/service.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 service
 
 import (
         "flag"
         "net/http"
         "net/url"
@@ skipping 165 matching lines @@
         s.addFlags(c, &s.Flags)
         if err := s.Flags.Parse(os.Args[1:]); err != nil {
                 log.WithError(err).Errorf(c, "Failed to parse command-line.")
                 return err
         }
 
         // Install logging configuration.
         c = s.loggingFlags.Set(c)
 
         if err := s.profiler.Start(); err != nil {
-                return errors.Annotate(err).Reason("failed to start profiler").Err()
+                return errors.Annotate(err, "failed to start profiler").Err()
         }
         defer s.profiler.Stop()
 
         // Cancel our Context after we're done our run loop.
         c, cancelFunc := context.WithCancel(c)
         defer cancelFunc()
 
         // Validate the runtime environment.
         if s.serviceID == "" {
                 return errors.New("no service ID was configured (-service-id)")
@@ skipping 196 matching lines @@
                 //
                 // Older Coordinator instances may provide the full URL instead of the host,
                 // in which case we will extract the host from the URL.
                 host := ccfg.ConfigServiceHost
                 if host == "" {
                         if ccfg.ConfigServiceUrl == "" {
                                 return errors.New("coordinator does not specify a config service")
                         }
                         u, err := url.Parse(ccfg.ConfigServiceUrl)
                         if err != nil {
-                                return errors.Annotate(err).Reason("failed to parse config service URL").Err()
+                                return errors.Annotate(err, "failed to parse config service URL").Err()
                         }
                         host = u.Host
                 }
 
                 if ccfg.ConfigSet == "" {
                         return errors.New("coordinator does not specify a config set")
                 }
 
                 log.Fields{
                         "host": host,
@@ skipping 15 matching lines @@
 
         // Add config caching layers.
         *c = opts.WrapBackend(*c, &client.Backend{
                 Provider: p,
         })
 
         // Load our service configuration.
         var meta cfgclient.Meta
         cset, path := s.ServiceConfigPath()
         if err := cfgclient.Get(*c, cfgclient.AsService, cset, path, textproto.Message(&s.serviceConfig), &meta); err != nil {
-                return errors.Annotate(err).Reason("failed to load service config").Err()
+                return errors.Annotate(err, "failed to load service config").Err()
         }
 
         // Create a poller for our service config.
         if s.killCheckInterval > 0 {
                 pollerC, pollerCancelFunc := context.WithCancel(*c)
 
                 poller := config.ChangePoller{
                         ConfigSet: cset,
                         Path:      path,
                         Period:    time.Duration(s.killCheckInterval),
@@ skipping 25 matching lines @@
         return cfgtypes.ProjectConfigSet(proj), svcconfig.ProjectConfigPath(s.serviceID)
 }
 
 // ProjectConfig returns the current service's project configuration for proj.
 func (s *Service) ProjectConfig(c context.Context, proj cfgtypes.ProjectName) (*svcconfig.ProjectConfig, error) {
         cset, path := s.ProjectConfigPath(proj)
 
         var pcfg svcconfig.ProjectConfig
         msg, err := s.configCache.Get(c, cset, path, &pcfg)
         if err != nil {
-                return nil, errors.Annotate(err).Reason("failed to load project config from %(cset)s.%(path)s").
-                        D("cset", cset).D("path", path).Err()
+                return nil, errors.Annotate(err, "failed to load project config from %s.%s", cset, path).Err()
         }
         return msg.(*svcconfig.ProjectConfig), nil
 }
 
 // SetShutdownFunc sets the service shutdown function.
 func (s *Service) SetShutdownFunc(f func()) {
         s.shutdownFunc.Store(f)
 }
 
 func (s *Service) shutdown() {
@@ skipping 173 matching lines @@
         authOpts.Scopes = append([]string(nil), scopes...)
         authOpts.Transport = s.unauthenticatedTransport()
 
         a = commonAuth.NewAuthenticator(c, commonAuth.SilentLogin, authOpts)
         if s.authCache == nil {
                 s.authCache = make(map[string]*commonAuth.Authenticator)
         }
         s.authCache[key] = a
         return a, nil
 }