[errors] Greatly simplify common/errors package.

logdog/common/storage/archive/logdog_archive_test/main.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 implements a simple CLI tool to load and interact with Google
 // Storage archived data.
 package main
 
 import (
         "bytes"
         "flag"
         "io"
         "io/ioutil"
         "math"
         "os"
+        "strings"
 
         "github.com/luci/luci-go/client/authcli"
         "github.com/luci/luci-go/common/auth"
         "github.com/luci/luci-go/common/cli"
         "github.com/luci/luci-go/common/data/rand/mathrand"
         "github.com/luci/luci-go/common/data/recordio"
         "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/gcloud/gs"
         log "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/common/logging/gologger"
@@ skipping 21 matching lines @@
 
 func getApplication(base subcommands.Application) (*application, context.Context) {
         app := base.(*application)
         return app, app.Context(context.Background())
 }
 
 func (a *application) getGSClient(c context.Context) (gs.Client, error) {
         authenticator := auth.NewAuthenticator(c, auth.OptionalLogin, a.authOpts)
         transport, err := authenticator.Transport()
         if err != nil {
-                return nil, errors.Annotate(err).Reason("failed to get auth transport").Err()
+                return nil, errors.Annotate(err, "failed to get auth transport").Err()
         }
         return gs.NewProdClient(c, transport)
 }
 
 func mainImpl(c context.Context, defaultAuthOpts auth.Options, args []string) int {
         c = gologger.StdConfig.Use(c)
 
         logConfig := log.Config{
                 Level: log.Warning,
         }
@@ skipping 42 matching lines @@
         // Execute our subcommand.
         return subcommands.Run(&a, fs.Args())
 }
 
 func main() {
         mathrand.SeedRandomly()
         os.Exit(mainImpl(context.Background(), chromeinfra.DefaultAuthOptions(), os.Args[1:]))
 }
 
 func renderErr(c context.Context, err error) {
-        rerr := errors.RenderStack(err)
-
-        var buf bytes.Buffer
-        rerr.DumpTo(&buf)
-        log.Errorf(c, "Error encountered during operation: %s\n%s", err, buf.Bytes())
+        log.Errorf(c, "Error encountered during operation: %s\n%s", err,
+                strings.Join(errors.RenderStack(err), "\n"))
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Subcommand: dump-index
 ////////////////////////////////////////////////////////////////////////////////
 
 type cmdRunDumpIndex struct {
         subcommands.CommandRunBase
 
         path string
@@ skipping 109 matching lines @@
         }
         defer reader.Close()
 
         descFrame := true
         err = dumpRecordIO(c, reader, func(c context.Context, d []byte) error {
                 if descFrame {
                         descFrame = false
 
                         var desc logpb.LogStreamDescriptor
                         if err := unmarshalAndDump(c, os.Stdout, d, &desc); err != nil {
-                                return errors.Annotate(err).Reason("failed to dump log descriptor").Err()
+                                return errors.Annotate(err, "failed to dump log descriptor").Err()
                         }
                         return nil
                 }
 
                 var entry logpb.LogEntry
                 if err := unmarshalAndDump(c, os.Stdout, d, &entry); err != nil {
-                        return errors.Annotate(err).Reason("failed to dump log entry").Err()
+                        return errors.Annotate(err, "failed to dump log entry").Err()
                 }
                 return nil
         })
         if err != nil {
                 renderErr(c, err)
                 return 1
         }
 
         return 0
 }
@@ skipping 185 matching lines @@
                 switch err {
                 case nil:
                         break
 
                 case io.EOF:
                         log.Debugf(c, "Encountered EOF.")
                         eof = true
                         break
 
                 default:
-                        return errors.Annotate(err).Reason("Encountered error reading log stream.").
-                                D("frameIndex", frameIndex).Err()
+                        return errors.Annotate(err, "Encountered error reading log stream.").
+                                InternalReason("frameIndex(%d)", frameIndex).Err()
                 }
 
                 if frameSize > 0 {
                         buf.Reset()
                         buf.Grow(int(frameSize))
 
                         if _, err := buf.ReadFrom(r); err != nil {
-                                return errors.Annotate(err).Reason("Failed to buffer frame.").
-                                        D("frameIndex", frameIndex).Err()
+                                return errors.Annotate(err, "Failed to buffer frame.").
+                                        InternalReason("frameIndex(%d)", frameIndex).Err()
                         }
 
                         if err := cb(c, buf.Bytes()); err != nil {
                                 return err
                         }
                 }
 
                 log.Fields{
                         "index": frameIndex,
                         "size":  buf.Len(),
                 }.Debugf(c, "Read frame.")
                 frameIndex++
         }
         return nil
 }