[errors] Greatly simplify common/errors package.

common/tsmon/iface.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 tsmon
 
 import (
         "fmt"
         "net/url"
         "strings"
@@ skipping 62 matching lines @@
 }
 
 // InitializeFromFlags configures the tsmon library from flag values.
 //
 // This will set a Target (information about what's reporting metrics) and a
 // Monitor (where to send the metrics to).
 func InitializeFromFlags(c context.Context, fl *Flags) error {
         // Load the config file, and override its values with flags.
         config, err := loadConfig(fl.ConfigFile)
         if err != nil {
-                return errors.Annotate(err).Reason("failed to load config file at [%(path)s]").
-                        D("path", fl.ConfigFile).Err()
+                return errors.Annotate(err, "failed to load config file at [%s]", fl.ConfigFile).Err()
         }
 
         if fl.Endpoint != "" {
                 config.Endpoint = fl.Endpoint
         }
         if fl.Credentials != "" {
                 config.Credentials = fl.Credentials
         }
         if fl.ActAs != "" {
                 config.ActAs = fl.ActAs
         }
 
         mon, err := initMonitor(c, config)
         switch {
         case err != nil:
-                return errors.Annotate(err).Reason("failed to initialize monitor").Err()
+                return errors.Annotate(err, "failed to initialize monitor").Err()
         case mon == nil:
                 return nil // tsmon is disabled
         }
 
         // Monitoring is enabled, so get the expensive default values for hostname,
         // etc.
         if config.AutoGenHostname {
                 fl.Target.AutoGenHostname = true
         }
         if config.Hostname != "" {
                 if fl.Target.DeviceHostname == "" {
                         fl.Target.DeviceHostname = config.Hostname
                 }
                 if fl.Target.TaskHostname == "" {
                         fl.Target.TaskHostname = config.Hostname
                 }
         }
         if config.Region != "" {
                 if fl.Target.DeviceRegion == "" {
                         fl.Target.DeviceRegion = config.Region
                 }
                 if fl.Target.TaskRegion == "" {
                         fl.Target.TaskRegion = config.Region
                 }
         }
         fl.Target.SetDefaultsFromHostname()
         t, err := target.NewFromFlags(&fl.Target)
         if err != nil {
-                return errors.Annotate(err).Reason("failed to configure target from flags").Err()
+                return errors.Annotate(err, "failed to configure target from flags").Err()
         }
 
         Initialize(c, mon, store.NewInMemory(t))
 
         state := GetState(c)
         if state.Flusher != nil {
                 logging.Infof(c, "Canceling previous tsmon auto flush")
                 state.Flusher.stop()
                 state.Flusher = nil
         }
@@ skipping 79 matching lines @@
 // newAuthenticator returns a new authenticator for HTTP requests.
 func newAuthenticator(ctx context.Context, credentials, actAs string, scopes []string) *auth.Authenticator {
         // TODO(vadimsh): Don't hardcode auth options here, pass them from outside
         // somehow.
         authOpts := chromeinfra.DefaultAuthOptions()
         authOpts.ServiceAccountJSONPath = credentials
         authOpts.Scopes = scopes
         authOpts.ActAsServiceAccount = actAs
         return auth.NewAuthenticator(ctx, auth.SilentLogin, authOpts)
 }