[errors] Greatly simplify common/errors package.

common/runtime/profiling/profiler.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 profiling
 
 import (
         "flag"
         "fmt"
         "net"
@@ skipping 77 matching lines @@
                         return errors.New("-profile-cpu requires -profile-output-dir to be set")
                 }
                 if p.ProfileHeap {
                         return errors.New("-profile-heap requires -profile-output-dir to be set")
                 }
         }
 
         if p.ProfileCPU {
                 out, err := os.Create(p.generateOutPath("cpu"))
                 if err != nil {
-                        return errors.Annotate(err).Reason("failed to create CPU profile output file").Err()
+                        return errors.Annotate(err, "failed to create CPU profile output file").Err()
                 }
                 pprof.StartCPUProfile(out)
                 p.profilingCPU = true
         }
 
         if p.BindHTTP != "" {
                 if err := p.startHTTP(); err != nil {
-                        return errors.Annotate(err).Reason("failed to start HTTP server").Err()
+                        return errors.Annotate(err, "failed to start HTTP server").Err()
                 }
         }
 
         return nil
 }
 
 func (p *Profiler) startHTTP() error {
         // Register paths: https://golang.org/src/net/http/pprof/pprof.go
         router := httprouter.New()
         router.HandlerFunc("GET", "/debug/pprof/", httpProf.Index)
         router.HandlerFunc("GET", "/debug/pprof/cmdline", httpProf.Cmdline)
         router.HandlerFunc("GET", "/debug/pprof/profile", httpProf.Profile)
         router.HandlerFunc("GET", "/debug/pprof/symbol", httpProf.Symbol)
         router.HandlerFunc("GET", "/debug/pprof/trace", httpProf.Trace)
         for _, p := range pprof.Profiles() {
                 name := p.Name()
                 router.Handler("GET", fmt.Sprintf("/debug/pprof/%s", name), httpProf.Handler(name))
         }
 
         // Bind to our profiling port.
         l, err := net.Listen("tcp4", p.BindHTTP)
         if err != nil {
-                return errors.Annotate(err).Reason("failed to bind to TCP4 address: %(addr)q").
-                        D("addr", p.BindHTTP).Err()
+                return errors.Annotate(err, "failed to bind to TCP4 address: %q", p.BindHTTP).Err()
         }
 
         server := http.Server{
                 Handler: http.HandlerFunc(router.ServeHTTP),
         }
         go func() {
                 if err := server.Serve(l); err != nil {
                         p.getLogger().Errorf("Error serving profile HTTP: %s", err)
                 }
         }()
@@ skipping 20 matching lines @@
 
 // DumpSnapshot dumps a profile snapshot to the configured output directory. If
 // no output directory is configured, nothing will happen.
 func (p *Profiler) DumpSnapshot() error {
         if p.Dir == "" {
                 return nil
         }
 
         if p.ProfileHeap {
                 if err := p.dumpHeapProfile(); err != nil {
-                        return errors.Annotate(err).Reason("failed to dump heap profile").Err()
+                        return errors.Annotate(err, "failed to dump heap profile").Err()
                 }
         }
 
         return nil
 }
 
 func (p *Profiler) dumpHeapProfile() error {
         fd, err := os.Create(p.generateOutPath("memory"))
         if err != nil {
-                return errors.Annotate(err).Reason("failed to create output file").Err()
+                return errors.Annotate(err, "failed to create output file").Err()
         }
         defer fd.Close()
 
         // Get up-to-date statistics.
         runtime.GC()
         if err := pprof.WriteHeapProfile(fd); err != nil {
-                return errors.Annotate(err).Reason("failed to write heap profile").Err()
+                return errors.Annotate(err, "failed to write heap profile").Err()
         }
         return nil
 }
 
 func (p *Profiler) generateOutPath(base string) string {
         clk := p.Clock
         if clk == nil {
                 clk = clock.GetSystemClock()
         }
         now := clk.Now()
         counter := atomic.AddUint32(&p.pathCounter, 1) - 1
         return filepath.Join(p.Dir, fmt.Sprintf("%s_%d_%d.prof", base, now.Unix(), counter))
 }
 
 func (p *Profiler) getLogger() logging.Logger {
         if p.Logger != nil {
                 return p.Logger
         }
         return logging.Null
 }