[errors] Greatly simplify common/errors package.

common/system/prober/probe.go

 // Copyright 2017 The LUCI 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 prober exports Probe, which implements logic to identify a wrapper's
 // wrapped target. In addition to basic PATH/filename lookup, Prober contains
 // logic to ensure that the wrapper is not the same software as the current
 // running instance, and enables optional hard-coded wrap target paths and
 // runtime checks.
 package prober
@@ skipping 67 matching lines @@
 // If this process was invoked via symlink, the path to the symlink will be
 // returned if possible.
 func (p *Probe) ResolveSelf(argv0 string) error {
         if p.Self != "" {
                 return nil
         }
 
         // Get the authoritative executable from the system.
         exec, err := os.Executable()
         if err != nil {
-                return errors.Annotate(err).Reason("failed to get executable").Err()
+                return errors.Annotate(err, "failed to get executable").Err()
         }
 
         execStat, err := os.Stat(exec)
         if err != nil {
-                return errors.Annotate(err).Reason("failed to stat executable: %(path)s").
-                        D("path", exec).
-                        Err()
+                return errors.Annotate(err, "failed to stat executable: %s", exec).Err()
         }
 
         // Before using "os.Executable" result, which is known to resolve symlinks on
         // Linux, try and identify via argv0.
         if argv0 != "" && filesystem.AbsPath(&argv0) == nil {
                 if st, err := os.Stat(argv0); err == nil && os.SameFile(execStat, st) {
                         // argv[0] is the same file as our executable, but may be an unresolved
                         // symlink. Prefer it.
                         p.Self, p.SelfStat = argv0, st
                         return nil
@@ skipping 75 matching lines @@
                 }
                 checked[dir] = struct{}{}
 
                 path := p.checkDir(c, dir, selfDirStat, env)
                 if path != "" {
                         return path, nil
                 }
         }
 
         return "", errors.Reason("could not find target in system").
-                D("target", p.Target).
-                D("dirs", pathDirs).
-                Err()
+                InternalReason("target(%s)/dirs(%v)", p.Target, pathDirs).Err()
 }
 
 // checkDir checks "checkDir" for our Target executable. It ignores
 // executables whose target is the same file or shares the same parent directory
 // as "self".
 func (p *Probe) checkDir(c context.Context, dir string, selfDir os.FileInfo, env environ.Env) string {
         // If we have a self directory defined, ensure that "dir" isn't the same
         // directory. If it is, we will ignore this option, since we are looking for
         // something outside of the wrapper directory.
         if selfDir != nil {
@@ skipping 52 matching lines @@
                         return ""
 
                 case isWrapper:
                         logging.Debugf(c, "Candidate is a wrapper: %s", t)
                         return ""
                 }
         }
 
         return t
 }