Annotee: Use WithError.

client/cmd/logdog_annotee/main.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package main
 
 import (
         "encoding/json"
         "errors"
         "flag"
@@ skipping 117 matching lines @@
         }
         a := application{
                 Context:            ctx,
                 annotationInterval: clockflag.Duration(defaultAnnotationInterval),
         }
 
         // Determine bootstrapped process arguments.
         var err error
         a.bootstrap, err = bootstrap.Get()
         if err != nil {
-                log.Fields{
-                        log.ErrorKey: err,
-                }.Warningf(a, "Could not get LogDog Butler bootstrap information.")
+                log.WithError(err).Warningf(a, "Could not get LogDog Butler bootstrap information.")
         }
 
         fs := &flag.FlagSet{}
         logFlags.AddFlags(fs)
         a.addToFlagSet(fs)
         if err := fs.Parse(args); err != nil {
-                log.Fields{
-                        log.ErrorKey: err,
-                }.Errorf(a, "Failed to parse flags.")
+                log.WithError(err).Errorf(a, "Failed to parse flags.")
                 return configErrorReturnCode
         }
         a.Context = logFlags.Set(a.Context)
 
         client, err := a.getStreamClient()
         if err != nil {
-                log.Fields{
-                        log.ErrorKey: err,
-                }.Errorf(a, "Failed to get stream client instance.")
+                log.WithError(err).Errorf(a, "Failed to get stream client instance.")
                 return configErrorReturnCode
         }
 
         prefix := types.StreamName(a.prefix)
         if prefix == "" && a.bootstrap != nil {
                 prefix = a.bootstrap.Prefix
         }
 
         args = fs.Args()
         if a.jsonArgsPath != "" {
@@ skipping 35 matching lines @@
                 },
 
                 Annotate: executor.AnnotationMode(a.annotate),
                 Stdin:    os.Stdin,
         }
         if a.tee {
                 e.TeeStdout = os.Stdout
                 e.TeeStderr = os.Stderr
         }
         if err := e.Run(a, args); err != nil {
-                log.Fields{
-                        log.ErrorKey: err,
-                }.Errorf(a, "Failed during execution.")
+                log.WithError(err).Errorf(a, "Failed during execution.")
                 return runtimeErrorReturnCode
         }
 
         // Display a summary!
         if a.printSummary {
                 for _, s := range e.Steps() {
                         fmt.Printf("=== Annotee: %q ===\n", s.StepComponent.Name)
                         fmt.Println(proto.MarshalTextString(s))
                 }
         }
 
         return e.ReturnCode()
 }
 
 func main() {
         os.Exit(mainImpl(os.Args[1:]))
 }