[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 560 matching lines @@
                         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 retry.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 !retry.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,
         }
 }