[errors] Greatly simplify common/errors package.

logdog/client/cmd/logdog_butler/subcommand_run.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 main
 
 import (
         "encoding/json"
         "io"
         "os"
@@ skipping 287 matching lines @@
 
                 // If we have configured a stream server, add it.
                 if streamServer != nil {
                         b.AddStreamServer(streamServer)
                         streamServerOwned = false
                 }
 
                 // Add our pipes as direct streams, if configured.
                 if stdout != nil {
                         if err := b.AddStream(stdout, cmd.stdout.properties()); err != nil {
-                                return errors.Annotate(err).Reason("failed to attach STDOUT pipe stream").Err()
+                                return errors.Annotate(err, "failed to attach STDOUT pipe stream").Err()
                         }
                 }
                 if stderr != nil {
                         if err := b.AddStream(stderr, cmd.stderr.properties()); err != nil {
-                                return errors.Annotate(err).Reason("failed to attach STDERR pipe stream").Err()
+                                return errors.Annotate(err, "failed to attach STDERR pipe stream").Err()
                         }
                 }
 
                 // Execute the command. The bootstrapped application will begin executing
                 // in the background.
                 if err := proc.Start(); err != nil {
-                        return errors.Annotate(err).Reason("failed to start bootstrapped process").Err()
+                        return errors.Annotate(err, "failed to start bootstrapped process").Err()
                 }
 
                 // Wait for the process' streams to finish. We must do this before Wait()
                 // on the process itself.
                 streamWG.Wait()
 
                 // Reap the process.
                 err := proc.Wait()
                 if rc, ok := exitcode.Get(err); ok {
                         if rc != 0 {
                                 log.Fields{
                                         "returnCode": rc,
                                 }.Errorf(a, "Command completed with non-zero return code.")
                         }
 
                         returnCode = rc
                         executed = true
                 } else {
                         log.WithError(err).Errorf(a, "Command failed.")
                 }
 
                 // Wait for our Butler to finish.
                 b.Activate()
                 if err := b.Wait(); err != nil {
                         if err == context.Canceled {
                                 return err
                         }
-                        return errors.Annotate(err).Reason("failed to Wait() for Butler").Err()
+                        return errors.Annotate(err, "failed to Wait() for Butler").Err()
                 }
 
                 return nil
         })
         if err != nil {
                 logAnnotatedErr(a, err, "Error running bootstrapped Butler process:")
         }
 
         if !executed {
                 return runtimeErrorReturnCode
@@ skipping 13 matching lines @@
 
 func (cmd *runCommandRun) maybeWriteResult(ctx context.Context, r *bootstrapResult.Result) error {
         if cmd.resultPath == "" {
                 return nil
         }
 
         log.Fields{
                 "path": cmd.resultPath,
         }.Debugf(ctx, "Writing bootstrap result.")
         if err := r.WriteJSON(cmd.resultPath); err != nil {
-                return errors.Annotate(err).Reason("failed to write JSON file").
-                        D("path", cmd.resultPath).Err()
+                return errors.Annotate(err, "failed to write JSON file").
+                        InternalReason("path(%s)", cmd.resultPath).Err()
         }
         return nil
 }
 
 func (cmd *runCommandRun) loadJSONArgs() ([]string, error) {
         fd, err := os.Open(cmd.jsonArgsPath)
         if err != nil {
                 return nil, err
         }
         defer fd.Close()
 
         dec := json.NewDecoder(fd)
         args := []string(nil)
         if err := dec.Decode(&args); err != nil {
                 return nil, err
         }
         return args, nil
 }
 
 // callbackReadCloser invokes a callback method when closed.
 type callbackReadCloser struct {
         io.ReadCloser
         callback func()
 }
 
 func (c *callbackReadCloser) Close() error {
         defer c.callback()
         return c.ReadCloser.Close()
 }