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

appengine/datastorecache/cache.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 datastorecache
 
 import (
         "math"
         "time"
 
@@ skipping 318 matching lines @@
                                 refreshValue, delta, err = doRefresh(c, bci.h, &e, userNS)
                                 return
                         })
                         switch err {
                         case nil:
                                 // Successfully loaded.
                                 return nil
 
                         case ErrFailedToLock:
                                 // Retry after delay.
-                                return errors.WrapTransient(err)
+                                return retry.Tag.Apply(err)

[dnj, 2017/06/24 14:53:54]

I don't like "retry.Tag.Apply" as a way of expressing transience. I think
transience and the will to retry are two different-but-related concepts. I'd
recommend "retry.Transient.Apply", or just doing your transient package idea.

[iannucci, 2017/06/24 20:16:09]

Done.

 
                         default:
                                 log.WithError(err).Warningf(c, "Unexpected failure obtaining initial load lock.")
                                 return err
                         }
                 }, func(err error, d time.Duration) {
                         log.WithError(err).Debugf(c, "Failed to acquire initial refresh lock. Retrying...")
                 })
         if err != nil {
                 // If we actually acquired the lock, then this refresh was a failure, and
@@ skipping 105 matching lines @@
 // delta is a factor representing the amount of time that it takes to
 // recalculate the value. Higher delta values allow for earlier recomputation
 // for values that take longer to calculate.
 //
 // beta can be set to >1 to favor earlier recomputations; however, in practice
 // beta=1 works well.
 func xFetch(now, expiry time.Time, delta time.Duration, beta float64, rf randFunc) bool {
         offset := time.Duration(float64(delta) * beta * math.Log(rf()))
         return !now.Add(-offset).Before(expiry)
 }