[errors] de-specialize Transient in favor of Tags.

tokenserver/appengine/impl/utils/bqlog/bqlog.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 bqlog provides a mechanism to asynchronously log rows to BigQuery.
 //
 // It uses Pull Task Queues as a temporary buffer for rows. The main use case is
 // to log events from online RPC handlers that are supposed to be fast and
 // reliable (and not depend on BigQuery latency or availability). If you need to
 // upload a large number of events at once or you are doing some offline batch
@@ skipping 26 matching lines @@
         bigquery "google.golang.org/api/bigquery/v2"
         "google.golang.org/api/googleapi"
 
         "github.com/luci/gae/service/info"
         "github.com/luci/gae/service/taskqueue"
 
         "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/common/retry"
+        "github.com/luci/luci-go/common/retry/transient"
 
         "github.com/luci/luci-go/common/tsmon/distribution"
         "github.com/luci/luci-go/common/tsmon/field"
         "github.com/luci/luci-go/common/tsmon/metric"
         "github.com/luci/luci-go/common/tsmon/types"
 
         "github.com/luci/luci-go/server/auth"
 )
 
 const (
@@ skipping 494 matching lines @@
         }
 
         if len(rows) == 0 {
                 chunk.Done(ctx)
                 return 0, nil
         }
 
         // Now actually send all the entries with retries.
         var lastResp *bigquery.TableDataInsertAllResponse
         taggedCtx := clock.Tag(ctx, "insert-retry") // used by tests
-        err := retry.Retry(taggedCtx, retry.TransientOnly(f.retryParams), func() error {
+        err := retry.Retry(taggedCtx, transient.Only(f.retryParams), func() error {
                 startTime := clock.Now(ctx)
                 var err error
                 lastResp, err = f.Insert(ctx, &bigquery.TableDataInsertAllRequest{
                         SkipInvalidRows: true, // they will be reported in lastResp.InsertErrors
                         Rows:            rows,
                 })
                 code := 0
                 status := "ok"
                 if gerr, _ := err.(*googleapi.Error); gerr != nil {
                         code = gerr.Code
                         status = fmt.Sprintf("http_%d", code)
                 } else if ctx.Err() != nil {
                         status = "timeout"
                 } else if err != nil {
                         status = "unknown"
                 }
                 dt := clock.Since(ctx, startTime)
                 bigQueryLatency.Add(ctx, float64(dt.Nanoseconds()/1e6), f.TableRef, "insertAll", status)
                 if code >= 500 {
-                        return errors.WrapTransient(err)
+                        return transient.Tag.Apply(err)
                 }
                 return err
         }, func(err error, wait time.Duration) {
                 logging.Fields{
                         logging.ErrorKey: err,
                         "wait":           wait,
                 }.Warningf(ctx, "Failed to send data to BigQuery")
         })
         if err != nil {
                 logging.WithError(err).Errorf(ctx, "Failed to send data to BigQuery")
-                if !errors.IsTransient(err) && err != context.DeadlineExceeded {
+                if !transient.Tag.In(err) && err != context.DeadlineExceeded {
                         chunk.Done(ctx)
                 }
                 return 0, err
         }
 
         if success := len(rows) - len(lastResp.InsertErrors); success > 0 {
                 flushedEntryCount.Add(ctx, int64(success), f.TableRef, "ok")
         }
 
         if len(lastResp.InsertErrors) != 0 {
@@ skipping 24 matching lines @@
 func (f *asyncFlusher) retryParams() retry.Iterator {
         return &retry.ExponentialBackoff{
                 Limited: retry.Limited{
                         Delay:    50 * time.Millisecond,
                         Retries:  50,
                         MaxTotal: 45 * time.Second,
                 },
                 Multiplier: 2,
         }
 }