[errors] Greatly simplify common/errors package.

logdog/common/storage/bigtable/logdog_bigtable_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 storage
 // data in Google BigTable data.
 package main
 
 import (
-        "bytes"
         "flag"
         "io"
         "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/errors"
         log "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/common/logging/gologger"
         "github.com/luci/luci-go/logdog/common/storage"
         "github.com/luci/luci-go/logdog/common/storage/bigtable"
@@ skipping 31 matching lines @@
 func (app *application) addFlags(fs *flag.FlagSet) {
         fs.StringVar(&app.btProject, "bt-project", "", "BigTable project name (required)")
         fs.StringVar(&app.btInstance, "bt-instance", "", "BigTable instance name (required)")
         fs.StringVar(&app.btLogTable, "bt-log-table", "", "BigTable log table name (required)")
 }
 
 func (app *application) getBigTableClient(c context.Context) (storage.Storage, error) {
         a := auth.NewAuthenticator(c, auth.SilentLogin, app.authOpts)
         tsrc, err := a.TokenSource()
         if err != nil {
-                return nil, errors.Annotate(err).Reason("failed to get token source").Err()
+                return nil, errors.Annotate(err, "failed to get token source").Err()
         }
 
         return bigtable.New(c, bigtable.Options{
                 Project:  app.btProject,
                 Instance: app.btInstance,
                 LogTable: app.btLogTable,
                 ClientOptions: []option.ClientOption{
                         option.WithTokenSource(tsrc),
                 },
                 Cache: &memory.Cache{},
@@ skipping 64 matching lines @@
         // Execute our subcommand.
         return subcommands.Run(&app, 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"))
 }
 
 func unmarshalAndDump(c context.Context, out io.Writer, data []byte, msg proto.Message) error {
         if data != nil {
                 if err := proto.Unmarshal(data, msg); err != nil {
                         log.WithError(err).Errorf(c, "Failed to unmarshal protobuf.")
                         return err
                 }
         }
 
@@ skipping 42 matching lines @@
         case cmd.project == "":
                 log.Errorf(c, "Missing required argument (-project).")
                 return 1
         case cmd.path == "":
                 log.Errorf(c, "Missing required argument (-path).")
                 return 1
         }
 
         stClient, err := app.getBigTableClient(c)
         if err != nil {
-                renderErr(c, errors.Annotate(err).Reason("failed to create storage client").Err())
+                renderErr(c, errors.Annotate(err, "failed to create storage client").Err())
                 return 1
         }
         defer stClient.Close()
 
         for round := 0; round < cmd.rounds; round++ {
                 log.Infof(c, "Get round %d.", round+1)
 
                 var innerErr error
                 err = stClient.Get(storage.GetRequest{
                         Project: cfgtypes.ProjectName(cmd.project),
@@ skipping 11 matching lines @@
                                 "index": le.StreamIndex,
                         }.Infof(c, "Fetched log entry.")
 
                         if innerErr = unmarshalAndDump(c, os.Stdout, nil, le); innerErr != nil {
                                 return false
                         }
                         return true
                 })
                 switch {
                 case innerErr != nil:
-                        renderErr(c, errors.Annotate(err).Reason("failed to process fetched log entries").Err())
+                        renderErr(c, errors.Annotate(err, "failed to process fetched log entries").Err())
                         return 1
 
                 case err != nil:
-                        renderErr(c, errors.Annotate(err).Reason("Failed to Get log entries.").Err())
+                        renderErr(c, errors.Annotate(err, "Failed to Get log entries.").Err())
                         return 1
                 }
         }
 
         return 0
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Subcommand: tail
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 27 matching lines @@
         case cmd.project == "":
                 log.Errorf(c, "Missing required argument (-project).")
                 return 1
         case cmd.path == "":
                 log.Errorf(c, "Missing required argument (-path).")
                 return 1
         }
 
         stClient, err := app.getBigTableClient(c)
         if err != nil {
-                renderErr(c, errors.Annotate(err).Reason("failed to create storage client").Err())
+                renderErr(c, errors.Annotate(err, "failed to create storage client").Err())
                 return 1
         }
         defer stClient.Close()
 
         for round := 0; round < cmd.rounds; round++ {
                 log.Infof(c, "Tail round %d.", round+1)
                 e, err := stClient.Tail(cfgtypes.ProjectName(cmd.project), types.StreamPath(cmd.path))
                 if err != nil {
-                        renderErr(c, errors.Annotate(err).Reason("failed to tail log entries").Err())
+                        renderErr(c, errors.Annotate(err, "failed to tail log entries").Err())
                         return 1
                 }
 
                 if e == nil {
                         log.Infof(c, "No log data to tail.")
                         continue
                 }
 
                 le, err := e.GetLogEntry()
                 if err != nil {
-                        renderErr(c, errors.Annotate(err).Reason("failed to unmarshal log entry").Err())
+                        renderErr(c, errors.Annotate(err, "failed to unmarshal log entry").Err())
                         return 1
                 }
 
                 log.Fields{
                         "index": le.StreamIndex,
                         "size":  len(e.D),
                 }.Debugf(c, "Dumping tail entry.")
                 if err := unmarshalAndDump(c, os.Stdout, nil, le); err != nil {
-                        renderErr(c, errors.Annotate(err).Reason("failed to dump log entry").Err())
+                        renderErr(c, errors.Annotate(err, "failed to dump log entry").Err())
                         return 1
                 }
         }
 
         return 0
 }