[errors] Greatly simplify common/errors package.

deploytool/cmd/luci_deploy/work.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 main
 
 import (
         "bufio"
         "bytes"
         "fmt"
@@ skipping 109 matching lines @@
         case x.shouldForwardOutput:
                 cmd.Stdout = &teeWriter{os.Stdout, &x.stdout}
                 cmd.Stderr = &teeWriter{os.Stderr, &x.stderr}
 
         case log.IsLogging(c, x.outputLevel):
                 // Get our command pipes. Wrap each one in a "closeOnceReader" so that our
                 // reader goroutine can close on error and our outer loop can also close on
                 // error without conflicting.
                 stdoutPipe, err := cmd.StdoutPipe()
                 if err != nil {
-                        return -1, errors.Annotate(err).Reason("failed to create STDOUT pipe").Err()
+                        return -1, errors.Annotate(err, "failed to create STDOUT pipe").Err()
                 }
                 stdoutPipe = &closeOnceReader{ReadCloser: stdoutPipe}
                 defer stdoutPipe.Close()
 
                 stderrPipe, err := cmd.StderrPipe()
                 if err != nil {
-                        return -1, errors.Annotate(err).Reason("failed to create STDERR pipe").Err()
+                        return -1, errors.Annotate(err, "failed to create STDERR pipe").Err()
                 }
                 stderrPipe = &closeOnceReader{ReadCloser: stderrPipe}
                 defer stderrPipe.Close()
 
                 spawnMonitor := func(name string, in io.ReadCloser, tee io.Writer) {
                         wg.Add(1)
                         go func() {
                                 defer wg.Done()
                                 defer in.Close()
 
@@ skipping 52 matching lines @@
                 for i, k := range env {
                         env[i] = fmt.Sprintf("%s=%s", k, x.envMap[k])
                 }
                 cmd.Env = env
         }
 
         log.Fields{
                 "cwd": x.workdir,
         }.Debugf(c, "Running command: %s %s.", x.command, x.args)
         if err := cmd.Start(); err != nil {
-                return -1, errors.Annotate(err).Reason("failed to start command").
-                        D("command", x.command).D("args", x.args).D("cwd", x.workdir).Err()
+                return -1, errors.Annotate(err, "failed to start command").
+                        InternalReason("command(%s)/args(%v)/cwd(%s)", x.command, x.args, x.workdir).Err()
         }
 
         // Wait for our stream processing to finish.
         wg.Wait()
 
         if err := cmd.Wait(); err != nil {
                 if rc, ok := exitcode.Get(err); ok {
                         log.Fields{
                                 "returnCode": rc,
                         }.Debugf(c, "Command completed with non-zero return code: %s %s", x.command, x.args)
                         return rc, nil
                 }
 
-                return -1, errors.Annotate(err).Reason("failed to wait for command").
-                        D("command", x.command).D("args", x.args).D("cwd", x.workdir).Err()
+                return -1, errors.Annotate(err, "failed to wait for command").
+                        InternalReason("command(%s)/args(%v)/cwd(%s)", x.command, x.args, x.workdir).Err()
         }
 
         log.Debugf(c, "Command completed with zero return code: %s %s", x.command, x.args)
         return 0, nil
 }
 
 func (x *workExecutor) check(c context.Context) error {
         switch rc, err := x.run(c); {
         case err != nil:
-                return errors.Annotate(err).Err()
+                return errors.Annotate(err, "").Err()
 
         case rc != 0:
                 log.Fields{
                         "returnCode": rc,
                         "command":    x.command,
                         "args":       x.args,
                         "cwd":        x.workdir,
                 }.Errorf(c, "Command failed with error return code.\nSTDOUT:\n%s\n\nSTDERR:\n%s",
                         x.stdout.String(), x.stderr.String())
-                return errors.Reason("process exited with return code: %(returnCode)d").
-                        D("command", x.command).D("args", x.args).D("cwd", x.workdir).D("returnCode", rc).Err()
+                return errors.Reason("process exited with return code: %d", rc).
+                        InternalReason("command(%s)/args(%v)/cwd(%s)", x.command, x.args, x.workdir).Err()
 
         default:
                 return nil
         }
 }
 
 func runWork(c context.Context, workers int, tools *tools, f func(w *work) error) error {
         return parallel.RunMulti(c, workers, func(mr parallel.MultiRunner) error {
                 return f(&work{
                         Context:     c,
@@ skipping 24 matching lines @@
 // will panic.
 type teeWriter struct {
         base io.Writer
         tee  io.Writer
 }
 
 func (w *teeWriter) Write(d []byte) (amt int, err error) {
         amt, err = w.base.Write(d)
         if amt > 0 {
                 if _, ierr := w.tee.Write(d[:amt]); ierr != nil {
-                        panic(errors.Annotate(ierr).Reason("failed to write to tee writer").Err())
+                        panic(errors.Annotate(ierr, "failed to write to tee writer").Err())
                 }
         }
         return
 }