type time.Duration
526 uses
time (current package)
format.go#L1511: func ParseDuration(s string) (Duration, error) {
format.go#L1602: return -Duration(d), nil
format.go#L1607: return Duration(d), nil
sleep.go#L9: func Sleep(d Duration)
sleep.go#L28: func when(d Duration) int64 {
sleep.go#L86: func NewTimer(d Duration) *Timer {
sleep.go#L134: func (t *Timer) Reset(d Duration) bool {
sleep.go#L156: func After(d Duration) <-chan Time {
sleep.go#L163: func AfterFunc(d Duration, f func()) *Timer {
tick.go#L22: func NewTicker(d Duration) *Ticker {
tick.go#L53: func (t *Ticker) Reset(d Duration) {
tick.go#L68: func Tick(d Duration) <-chan Time {
time.go#L589: type Duration int64
time.go#L592: minDuration Duration = -1 << 63
time.go#L593: maxDuration Duration = 1<<63 - 1
time.go#L608: Nanosecond Duration = 1
time.go#L620: func (d Duration) String() string {
time.go#L735: func (d Duration) Nanoseconds() int64 { return int64(d) }
time.go#L738: func (d Duration) Microseconds() int64 { return int64(d) / 1e3 }
time.go#L741: func (d Duration) Milliseconds() int64 { return int64(d) / 1e6 }
time.go#L753: func (d Duration) Seconds() float64 {
time.go#L760: func (d Duration) Minutes() float64 {
time.go#L767: func (d Duration) Hours() float64 {
time.go#L775: func (d Duration) Truncate(m Duration) Duration {
time.go#L784: func lessThanHalf(x, y Duration) bool {
time.go#L794: func (d Duration) Round(m Duration) Duration {
time.go#L819: func (t Time) Add(d Duration) Time {
time.go#L847: func (t Time) Sub(u Time) Duration {
time.go#L851: d := Duration(te - ue)
time.go#L860: d := Duration(t.sec()-u.sec())*Second + Duration(t.nsec()-u.nsec())
time.go#L874: func Since(t Time) Duration {
time.go#L887: func Until(t Time) Duration {
time.go#L1463: func (t Time) Truncate(d Duration) Time {
time.go#L1480: func (t Time) Round(d Duration) Time {
time.go#L1495: func div(t Time, d Duration) (qmod2 int, r Duration) {
time.go#L1514: r = Duration(nsec % int32(d))
time.go#L1520: r = Duration(sec%d1)*Second + Duration(nsec)
time.go#L1567: r = Duration(u0)
context
context.go#L506: func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
crypto/tls
handshake_client_tls13.go#L648: lifetime := time.Duration(msg.lifetime) * time.Second
database/sql
sql.go#L483: maxLifetime time.Duration // maximum amount of time a connection may be reused
sql.go#L484: maxIdleTime time.Duration // maximum amount of time a connection may be idle before being closed
sql.go#L538: func (dc *driverConn) expired(timeout time.Duration) bool {
sql.go#L935: func (db *DB) shortestIdleTimeLocked() time.Duration {
sql.go#L1012: func (db *DB) SetConnMaxLifetime(d time.Duration) {
sql.go#L1034: func (db *DB) SetConnMaxIdleTime(d time.Duration) {
sql.go#L1060: func (db *DB) connectionCleaner(d time.Duration) {
sql.go#L1106: func (db *DB) connectionCleanerRunLocked(d time.Duration) (time.Duration, []*driverConn) {
sql.go#L1173: WaitDuration time.Duration // The total time blocked waiting for a new connection.
sql.go#L1194: WaitDuration: time.Duration(wait),
flag
flag.go#L261: type durationValue time.Duration
flag.go#L263: func newDurationValue(val time.Duration, p *time.Duration) *durationValue {
flag.go#L277: func (d *durationValue) Get() any { return time.Duration(*d) }
flag.go#L279: func (d *durationValue) String() string { return (*time.Duration)(d).String() }
flag.go#L814: func (f *FlagSet) DurationVar(p *time.Duration, name string, value time.Duration, usage string) {
flag.go#L821: func DurationVar(p *time.Duration, name string, value time.Duration, usage string) {
flag.go#L828: func (f *FlagSet) Duration(name string, value time.Duration, usage string) *time.Duration {
flag.go#L829: p := new(time.Duration)
flag.go#L837: func Duration(name string, value time.Duration, usage string) *time.Duration {
github.com/aws/aws-sdk-go-v2/aws
credential_cache.go#L26: ExpiryWindow time.Duration
credential_cache.go#L143: var jitter time.Duration
credential_cache.go#L145: jitter = time.Duration(randFloat64 *
credential_cache.go#L211: AdjustExpiresBy(Credentials, time.Duration) (Credentials, error)
credential_cache.go#L217: func defaultAdjustExpiresBy(creds Credentials, dur time.Duration) (Credentials, error) {
from_ptr.go#L349: func ToDuration(p *time.Duration) (v time.Duration) {
from_ptr.go#L356: func ToDurationSlice(vs []*time.Duration) []time.Duration {
from_ptr.go#L363: func ToDurationMap(vs map[string]*time.Duration) map[string]time.Duration {
retryer.go#L58: RetryDelay(attempt int, opErr error) (time.Duration, error)
retryer.go#L108: func (NopRetryer) RetryDelay(int, error) (time.Duration, error) {
to_ptr.go#L283: func Duration(v time.Duration) *time.Duration {
to_ptr.go#L289: func DurationSlice(vs []time.Duration) []*time.Duration {
to_ptr.go#L295: func DurationMap(vs map[string]time.Duration) map[string]*time.Duration {
github.com/aws/aws-sdk-go-v2/aws/defaults
configuration.go#L20: ConnectTimeout *time.Duration
configuration.go#L26: TLSNegotiationTimeout *time.Duration
configuration.go#L30: func (c *Configuration) GetConnectTimeout() (time.Duration, bool) {
configuration.go#L38: func (c *Configuration) GetTLSNegotiationTimeout() (time.Duration, bool) {
github.com/aws/aws-sdk-go-v2/aws/middleware
middleware.go#L117: func GetAttemptSkew(metadata middleware.Metadata) (v time.Duration, ok bool) {
middleware.go#L118: v, ok = metadata.Get(attemptSkewKey{}).(time.Duration)
middleware.go#L123: func setAttemptSkew(metadata *middleware.Metadata, v time.Duration) {
github.com/aws/aws-sdk-go-v2/aws/retry
adaptive.go#L105: time.Duration, error,
adaptive_ratelimit.go#L58: tokenAcquired bool, waitTryAgain time.Duration,
adaptive_ratelimit.go#L148: func float64Seconds(v float64) time.Duration {
adaptive_ratelimit.go#L149: return time.Duration(v * float64(time.Second))
adaptive_ratelimit.go#L152: func secondsFloat64(v time.Duration) float64 {
jitter_backoff.go#L14: maxBackoff time.Duration
jitter_backoff.go#L23: func NewExponentialJitterBackoff(maxBackoff time.Duration) *ExponentialJitterBackoff {
jitter_backoff.go#L34: func (j *ExponentialJitterBackoff) BackoffDelay(attempt int, err error) (time.Duration, error) {
middleware.go#L27: AttemptClockSkew time.Duration
middleware.go#L70: var attemptClockSkew time.Duration
retry.go#L59: func AddWithMaxBackoffDelay(r aws.Retryer, delay time.Duration) aws.Retryer {
retry.go#L71: func (r *withMaxBackoffDelay) RetryDelay(attempt int, err error) (time.Duration, error) {
standard.go#L14: BackoffDelay(attempt int, err error) (time.Duration, error)
standard.go#L19: type BackoffDelayerFunc func(int, error) (time.Duration, error)
standard.go#L22: func (fn BackoffDelayerFunc) BackoffDelay(attempt int, err error) (time.Duration, error) {
standard.go#L31: DefaultMaxBackoff time.Duration = 20 * time.Second
standard.go#L106: MaxBackoff time.Duration
standard.go#L205: func (s *Standard) RetryDelay(attempt int, err error) (time.Duration, error) {
github.com/aws/aws-sdk-go-v2/aws/transport/http
client.go#L46: clientTimeout time.Duration
client.go#L134: func (b *BuildableClient) WithTimeout(timeout time.Duration) *BuildableClient {
client.go#L165: func (b *BuildableClient) GetTimeout() time.Duration {
timeout_read_closer.go#L22: TimeoutDur time.Duration
timeout_read_closer.go#L37: duration time.Duration
timeout_read_closer.go#L67: func AddResponseReadTimeoutMiddleware(stack *middleware.Stack, duration time.Duration) error {
timeout_read_closer.go#L73: duration time.Duration
github.com/aws/aws-sdk-go-v2/internal/sdk
time.go#L20: var Sleep func(time.Duration)
time.go#L27: var SleepWithContext func(context.Context, time.Duration) error
time.go#L32: func sleepWithContext(ctx context.Context, dur time.Duration) error {
time.go#L47: func noOpSleepWithContext(context.Context, time.Duration) error {
time.go#L51: func noOpSleep(time.Duration) {}
github.com/aws/aws-sdk-go-v2/internal/timeconv
duration.go#L6: func FloatSecondsDur(v float64) time.Duration {
duration.go#L7: return time.Duration(v * float64(time.Second))
duration.go#L11: func DurSecondsFloat(d time.Duration) float64 {
github.com/aws/aws-sdk-go-v2/service/s3
api_client.go#L644: Expires time.Duration
api_client.go#L671: func WithPresignExpires(dur time.Duration) func(*PresignOptions) {
api_client.go#L675: type withPresignExpires time.Duration
api_client.go#L678: o.Expires = time.Duration(w)
api_op_HeadBucket.go#L186: MinDelay time.Duration
api_op_HeadBucket.go#L191: MaxDelay time.Duration
api_op_HeadBucket.go#L233: func (w *BucketExistsWaiter) Wait(ctx context.Context, params *HeadBucketInput, maxWaitDur time.Duration, optFns ...func(*BucketExistsWaiterOptions)) error {
api_op_HeadBucket.go#L241: func (w *BucketExistsWaiter) WaitForOutput(ctx context.Context, params *HeadBucketInput, maxWaitDur time.Duration, optFns ...func(*BucketExistsWaiterOptions)) (*HeadBucketOutput, error) {
api_op_HeadBucket.go#L339: MinDelay time.Duration
api_op_HeadBucket.go#L344: MaxDelay time.Duration
api_op_HeadBucket.go#L386: func (w *BucketNotExistsWaiter) Wait(ctx context.Context, params *HeadBucketInput, maxWaitDur time.Duration, optFns ...func(*BucketNotExistsWaiterOptions)) error {
api_op_HeadBucket.go#L395: func (w *BucketNotExistsWaiter) WaitForOutput(ctx context.Context, params *HeadBucketInput, maxWaitDur time.Duration, optFns ...func(*BucketNotExistsWaiterOptions)) (*HeadBucketOutput, error) {
api_op_HeadObject.go#L519: MinDelay time.Duration
api_op_HeadObject.go#L524: MaxDelay time.Duration
api_op_HeadObject.go#L566: func (w *ObjectExistsWaiter) Wait(ctx context.Context, params *HeadObjectInput, maxWaitDur time.Duration, optFns ...func(*ObjectExistsWaiterOptions)) error {
api_op_HeadObject.go#L574: func (w *ObjectExistsWaiter) WaitForOutput(ctx context.Context, params *HeadObjectInput, maxWaitDur time.Duration, optFns ...func(*ObjectExistsWaiterOptions)) (*HeadObjectOutput, error) {
api_op_HeadObject.go#L677: MinDelay time.Duration
api_op_HeadObject.go#L682: MaxDelay time.Duration
api_op_HeadObject.go#L724: func (w *ObjectNotExistsWaiter) Wait(ctx context.Context, params *HeadObjectInput, maxWaitDur time.Duration, optFns ...func(*ObjectNotExistsWaiterOptions)) error {
api_op_HeadObject.go#L733: func (w *ObjectNotExistsWaiter) WaitForOutput(ctx context.Context, params *HeadObjectInput, maxWaitDur time.Duration, optFns ...func(*ObjectNotExistsWaiterOptions)) (*HeadObjectOutput, error) {
github.com/aws/aws-sdk-go-v2/service/s3/internal/customizations
presigned_expires.go#L20: Expires time.Duration
github.com/aws/smithy-go/auth/bearer
token_cache.go#L27: RefreshBeforeExpires time.Duration
token_cache.go#L38: RetrieveBearerTokenTimeout time.Duration
token_cache.go#L55: AsyncRefreshMinimumDelay time.Duration
github.com/aws/smithy-go/ptr
from_ptr.go#L571: func ToDuration(p *time.Duration) (v time.Duration) {
from_ptr.go#L582: func ToDurationSlice(vs []*time.Duration) []time.Duration {
from_ptr.go#L583: ps := make([]time.Duration, len(vs))
from_ptr.go#L594: func ToDurationMap(vs map[string]*time.Duration) map[string]time.Duration {
from_ptr.go#L595: ps := make(map[string]time.Duration, len(vs))
to_ptr.go#L473: func Duration(v time.Duration) *time.Duration {
to_ptr.go#L479: func DurationSlice(vs []time.Duration) []*time.Duration {
to_ptr.go#L480: ps := make([]*time.Duration, len(vs))
to_ptr.go#L491: func DurationMap(vs map[string]time.Duration) map[string]*time.Duration {
to_ptr.go#L492: ps := make(map[string]*time.Duration, len(vs))
github.com/aws/smithy-go/time
time.go#L122: func SleepWithContext(ctx context.Context, dur time.Duration) error {
github.com/aws/smithy-go/waiter
waiter.go#L17: func ComputeDelay(attempt int64, minDelay, maxDelay, remainingTime time.Duration) (delay time.Duration, err error) {
waiter.go#L47: delay = minDelay * time.Duration(ri)
waiter.go#L57: delay = time.Duration(d) + minDelay
github.com/go-pg/pg/v10
base.go#L49: func (db *baseDB) WithTimeout(d time.Duration) *baseDB {
base.go#L70: func (db *baseDB) retryBackoff(retry int) time.Duration {
db.go#L67: func (db *DB) WithTimeout(d time.Duration) *DB {
db.go#L134: func (db *Conn) WithTimeout(d time.Duration) *Conn {
listener.go#L226: ctx context.Context, timeout time.Duration,
options.go#L48: DialTimeout time.Duration
options.go#L52: ReadTimeout time.Duration
options.go#L55: WriteTimeout time.Duration
options.go#L64: MinRetryBackoff time.Duration
options.go#L67: MaxRetryBackoff time.Duration
options.go#L78: MaxConnAge time.Duration
options.go#L83: PoolTimeout time.Duration
options.go#L87: IdleTimeout time.Duration
options.go#L92: IdleCheckFrequency time.Duration
options.go#L247: options.DialTimeout = time.Second * time.Duration(ct)
github.com/go-pg/pg/v10/internal
internal.go#L11: func RetryBackoff(retry int, minBackoff, maxBackoff time.Duration) time.Duration {
internal.go#L20: d = minBackoff + time.Duration(rand.Int63n(int64(d)))
util.go#L9: func Sleep(ctx context.Context, dur time.Duration) error {
github.com/go-pg/pg/v10/internal/pool
conn.go#L74: ctx context.Context, timeout time.Duration, fn func(rd *ReaderContext) error,
conn.go#L98: ctx context.Context, timeout time.Duration, fn func(wb *WriteBuffer) error,
conn.go#L110: func (cn *Conn) WriteBuffer(ctx context.Context, timeout time.Duration, wb *WriteBuffer) error {
conn.go#L116: timeout time.Duration,
conn.go#L132: func (cn *Conn) deadline(ctx context.Context, timeout time.Duration) time.Time {
pool.go#L59: MaxConnAge time.Duration
pool.go#L60: PoolTimeout time.Duration
pool.go#L61: IdleTimeout time.Duration
pool.go#L62: IdleCheckFrequency time.Duration
pool.go#L437: func (p *ConnPool) reaper(frequency time.Duration) {
github.com/golang/protobuf/ptypes
duration.go#L26: func Duration(dur *durationpb.Duration) (time.Duration, error) {
duration.go#L30: d := time.Duration(dur.Seconds) * time.Second
duration.go#L35: d += time.Duration(dur.Nanos) * time.Nanosecond
duration.go#L46: func DurationProto(d time.Duration) *durationpb.Duration {
github.com/robfig/cron/v3
constantdelay.go#L8: Delay time.Duration
constantdelay.go#L14: func Every(duration time.Duration) ConstantDelaySchedule {
constantdelay.go#L19: Delay: duration - time.Duration(duration.Nanoseconds())%time.Second,
constantdelay.go#L26: return t.Add(schedule.Delay - time.Duration(t.Nanosecond())*time.Nanosecond)
spec.go#L82: t = t.Add(1*time.Second - time.Duration(t.Nanosecond())*time.Nanosecond)
spec.go#L127: t = t.Add(time.Duration(24-t.Hour()) * time.Hour)
spec.go#L129: t = t.Add(time.Duration(-t.Hour()) * time.Hour)
github.com/vmihailenco/msgpack/v5
decode.go#L254: case *time.Duration:
decode.go#L257: *v = time.Duration(vv)
decode.go#L356: func (d *Decoder) DecodeDuration() (time.Duration, error) {
decode.go#L361: return time.Duration(n), nil
encode.go#L220: case time.Duration:
encode.go#L253: func (e *Encoder) EncodeDuration(d time.Duration) error {
go.pact.im/x/clock
clock.go#L30: Schedule(d time.Duration, f func(now time.Time)) Event
clock.go#L52: Reset(d time.Duration) bool
clock.go#L70: func (c *Clock) Schedule(d time.Duration, f func(now time.Time)) Event {
runtime.go#L29: func (c *runtimeClock) Schedule(d time.Duration, f func(now time.Time)) Event {
runtime.go#L41: func (c *runtimeClock) Timer(d time.Duration) Timer {
runtime.go#L46: func (c *runtimeClock) Ticker(d time.Duration) Ticker {
runtime.go#L61: func (r runtimeTimer) Reset(d time.Duration) {
ticker.go#L18: Ticker(d time.Duration) Ticker
ticker.go#L32: Reset(d time.Duration)
ticker.go#L43: func (c *Clock) Ticker(d time.Duration) Ticker {
ticker.go#L65: resetc chan time.Duration
ticker.go#L72: func newEventTicker(c *Clock, d time.Duration) *eventTicker {
ticker.go#L76: resetc: make(chan time.Duration),
ticker.go#L94: func (t *eventTicker) Reset(d time.Duration) {
ticker.go#L101: func (t *eventTicker) start(d time.Duration) {
ticker.go#L109: func (t *eventTicker) run(d time.Duration) {
ticker.go#L135: func (t *eventTicker) reset(d time.Duration) {
timer.go#L12: Timer(d time.Duration) Timer
timer.go#L60: Reset(d time.Duration)
timer.go#L68: func (c *Clock) Timer(d time.Duration) Timer {
timer.go#L104: func (t *eventTimer) Reset(d time.Duration) {
go.pact.im/x/clock/fakeclock
fakeclock.go#L23: next(now time.Time) (time.Duration, bool)
fakeclock.go#L60: func Y2038(d time.Duration) *Clock {
fakeclock.go#L111: func (c *Clock) Add(d time.Duration) time.Time {
fakeclock.go#L137: func (c *Clock) Schedule(d time.Duration, f func(now time.Time)) clock.Event {
fakeclock.go#L147: func (c *Clock) Timer(d time.Duration) clock.Timer {
fakeclock.go#L159: func (c *Clock) Ticker(d time.Duration) clock.Ticker {
fakeclock.go#L186: func (c *Clock) reset(m moment, d time.Duration, dp *time.Duration) bool {
fakeclock.go#L257: func (t *event) Reset(d time.Duration) bool {
fakeclock.go#L262: func (t *event) next(now time.Time) (time.Duration, bool) {
fakeclock.go#L284: func (t *timer) Reset(d time.Duration) {
fakeclock.go#L289: func (t *timer) next(now time.Time) (time.Duration, bool) {
fakeclock.go#L301: d time.Duration
fakeclock.go#L315: func (t *ticker) Reset(d time.Duration) {
fakeclock.go#L323: func (t *ticker) next(now time.Time) (time.Duration, bool) {
go.pact.im/x/clock/mockclock
mockclock.go#L52: func (m *MockClock) Schedule(d time.Duration, f func(time.Time)) clock.Event {
mockclock.go#L66: func (m *MockClock) Ticker(d time.Duration) clock.Ticker {
mockclock.go#L80: func (m *MockClock) Timer(d time.Duration) clock.Timer {
ticker.go#L51: func (m *MockTicker) Reset(arg0 time.Duration) {
timer.go#L51: func (m *MockTimer) Reset(arg0 time.Duration) {
go.pact.im/x/clock/observeclock
observeclock.go#L45: func (c *Clock) Schedule(d time.Duration, f func(time.Time)) clock.Event {
observeclock.go#L52: func (c *Clock) Timer(d time.Duration) clock.Timer {
observeclock.go#L59: func (c *Clock) Ticker(d time.Duration) clock.Ticker {
go.pact.im/x/flaky
backoff.go#L17: type Backoff func(n uint) (time.Duration, bool)
backoff.go#L28: return func(n uint) (time.Duration, bool) {
backoff.go#L39: func Constant(xs ...time.Duration) Backoff {
backoff.go#L40: return func(n uint) (time.Duration, bool) {
backoff.go#L57: func Exp2(unit time.Duration) Backoff {
backoff.go#L58: return func(n uint) (time.Duration, bool) {
deadline.go#L9: func withinDeadline(ctx context.Context, d time.Duration) bool {
debounce.go#L31: w time.Duration
debounce.go#L45: func Debounce(t time.Duration) *DebounceExecutor {
debounce.go#L75: func (d *DebounceExecutor) WithWait(t time.Duration) *DebounceExecutor {
jitter.go#L15: type Jitter func(v JitterInterval) time.Duration
jitter.go#L23: return func(v JitterInterval) time.Duration {
jitter.go#L28: func randomJitter(v JitterInterval, f func(n int64) int64) time.Duration {
jitter.go#L48: return time.Duration(n)
jitter.go#L56: L time.Duration
jitter.go#L102: return func(n uint) (time.Duration, bool) {
schedule.go#L53: d time.Duration
schedule.go#L62: func Midnight(d time.Duration, loc *time.Location) Schedule {
schedule.go#L91: d time.Duration
schedule.go#L98: func Sleep(d time.Duration) Schedule {
go.pact.im/x/supervisor
restart.go#L62: func (m *Supervisor[K, P]) restart(ctx context.Context, wait time.Duration) error {
go.pact.im/x/zapjournal
encoder.go#L134: func (e *varsEncoder) AddDuration(key string, value time.Duration) {
json.go#L147: func (e *jsonEncoder) AddDuration(k string, v time.Duration) {
json.go#L152: func (e *jsonEncoder) AppendDuration(v time.Duration) {
json.go#L157: func (e *jsonEncoder) encodeDuration(v time.Duration) {
go.pact.im/x/zapjournal/tests
stubs.go#L29: func (*fakeClock) NewTicker(time.Duration) *time.Ticker {
go.uber.org/atomic
duration.go#L37: var _zeroDuration time.Duration
duration.go#L40: func NewDuration(val time.Duration) *Duration {
duration.go#L49: func (x *Duration) Load() time.Duration {
duration.go#L50: return time.Duration(x.v.Load())
duration.go#L54: func (x *Duration) Store(val time.Duration) {
duration.go#L61: func (x *Duration) CAS(old, new time.Duration) (swapped bool) {
duration.go#L66: func (x *Duration) CompareAndSwap(old, new time.Duration) (swapped bool) {
duration.go#L72: func (x *Duration) Swap(val time.Duration) (old time.Duration) {
duration.go#L73: return time.Duration(x.v.Swap(int64(val)))
duration.go#L83: var v time.Duration
duration_ext.go#L28: func (d *Duration) Add(delta time.Duration) time.Duration {
duration_ext.go#L29: return time.Duration(d.v.Add(int64(delta)))
duration_ext.go#L33: func (d *Duration) Sub(delta time.Duration) time.Duration {
duration_ext.go#L34: return time.Duration(d.v.Sub(int64(delta)))
go.uber.org/goleak
options.go#L43: maxSleep time.Duration
options.go#L94: func maxSleep(d time.Duration) Option {
options.go#L137: d := time.Duration(int(time.Microsecond) << uint(i))
go.uber.org/zap
array.go#L58: func Durations(key string, ds []time.Duration) Field {
array.go#L178: type durations []time.Duration
field.go#L382: func Duration(key string, val time.Duration) Field {
field.go#L388: func Durationp(key string, val *time.Duration) Field {
field.go#L534: case time.Duration:
field.go#L536: case *time.Duration:
field.go#L538: case []time.Duration:
go.uber.org/zap/zapcore
buffered_write_syncer.go#L94: FlushInterval time.Duration
clock.go#L36: NewTicker(time.Duration) *time.Ticker
clock.go#L46: func (systemClock) NewTicker(duration time.Duration) *time.Ticker {
encoder.go#L222: type DurationEncoder func(time.Duration, PrimitiveArrayEncoder)
encoder.go#L225: func SecondsDurationEncoder(d time.Duration, enc PrimitiveArrayEncoder) {
encoder.go#L231: func NanosDurationEncoder(d time.Duration, enc PrimitiveArrayEncoder) {
encoder.go#L237: func MillisDurationEncoder(d time.Duration, enc PrimitiveArrayEncoder) {
encoder.go#L243: func StringDurationEncoder(d time.Duration, enc PrimitiveArrayEncoder) {
encoder.go#L360: AddDuration(key string, value time.Duration)
encoder.go#L395: AppendDuration(time.Duration)
field.go#L135: enc.AddDuration(f.Key, time.Duration(f.Integer))
json_encoder.go#L138: func (enc *jsonEncoder) AddDuration(key string, val time.Duration) {
json_encoder.go#L269: func (enc *jsonEncoder) AppendDuration(val time.Duration) {
memory_encoder.go#L69: func (m MapObjectEncoder) AddDuration(k string, v time.Duration) { m.cur[k] = v }
memory_encoder.go#L164: func (s *sliceArrayEncoder) AppendDuration(v time.Duration) { s.elems = append(s.elems, v) }
sampler.go#L65: func (c *counter) IncCheckReset(t time.Time, tick time.Duration) uint64 {
sampler.go#L153: func NewSamplerWithOptions(core Core, tick time.Duration, first, thereafter int, opts ...SamplerOption) Core {
sampler.go#L173: tick time.Duration
sampler.go#L196: func NewSampler(core Core, tick time.Duration, first, thereafter int) Core {
golang.org/x/net/http2
server.go#L127: IdleTimeout time.Duration
server.go#L1432: func (sc *serverConn) shutDownIn(d time.Duration) {
transport.go#L155: ReadIdleTimeout time.Duration
transport.go#L160: PingTimeout time.Duration
transport.go#L165: WriteByteTimeout time.Duration
transport.go#L209: func (t *Transport) pingTimeout() time.Duration {
transport.go#L304: idleTimeout time.Duration // or 0 for never
transport.go#L456: timeout time.Duration
transport.go#L537: var retryBackoffHook func(time.Duration) *time.Timer
transport.go#L539: func backoffNewTimer(d time.Duration) *time.Timer {
transport.go#L571: d := time.Second * time.Duration(backoff)
transport.go#L709: func (t *Transport) expectContinueTimeout() time.Duration {
transport.go#L1161: func (cc *ClientConn) responseHeaderTimeout() time.Duration {
transport.go#L3092: func (t *Transport) idleConnTimeout() time.Duration {
golang.org/x/net/internal/timeseries
timeseries.go#L19: var timeSeriesResolutions = []time.Duration{
timeseries.go#L32: var minuteHourSeriesResolutions = []time.Duration{
timeseries.go#L92: size time.Duration // duration of the bucketed Observable
timeseries.go#L109: func (l *tsLevel) InitLevel(size time.Duration, numBuckets int, f func() Observable) {
timeseries.go#L136: func (ts *timeSeries) init(resolutions []time.Duration, f func() Observable, numBuckets int, clock Clock) {
timeseries.go#L237: if !t.Before(level.end.Add(level.size * time.Duration(ts.numBuckets))) {
timeseries.go#L338: func (ts *timeSeries) Recent(delta time.Duration) Observable {
timeseries.go#L368: if !start.Before(l.end.Add(-l.size * time.Duration(ts.numBuckets))) {
timeseries.go#L384: func (ts *timeSeries) RecentList(delta time.Duration, num int) []Observable {
timeseries.go#L398: dstInterval := finish.Sub(start) / time.Duration(num)
timeseries.go#L400: srcStart := l.end.Add(-srcInterval * time.Duration(ts.numBuckets))
timeseries.go#L408: srcStart = srcStart.Add(time.Duration(advance) * srcInterval)
golang.org/x/net/trace
events.go#L27: MaxErrAge time.Duration
events.go#L190: func (f *eventFamily) Count(now time.Time, maxErrAge time.Duration) (n int) {
events.go#L201: func (f *eventFamily) Copy(now time.Time, maxErrAge time.Duration) (els eventLogs) {
events.go#L231: Elapsed time.Duration // since previous event in log
events.go#L284: func (el *eventLog) hasRecentError(now time.Time, maxErrAge time.Duration) bool {
events.go#L296: func (el *eventLog) delta(t time.Time) (time.Duration, bool) {
trace.go#L661: type minCond time.Duration
trace.go#L663: func (m minCond) match(t *trace) bool { return t.Elapsed >= time.Duration(m) }
trace.go#L664: func (m minCond) String() string { return fmt.Sprintf("≥%gs", time.Duration(m).Seconds()) }
trace.go#L688: Elapsed time.Duration // since previous event in trace
trace.go#L729: Elapsed time.Duration // Elapsed time for this trace, zero while active.
trace.go#L768: func (tr *trace) delta(t time.Time) (time.Duration, bool) {
trace.go#L934: func elapsed(d time.Duration) string {
golang.org/x/sys/unix
syscall_linux.go#L2345: func MakeItimerval(interval, value time.Duration) Itimerval {
google.golang.org/grpc
backoff.go#L43: MaxDelay time.Duration
backoff.go#L60: MinConnectTimeout time.Duration
dialoptions.go#L64: timeout time.Duration
dialoptions.go#L75: minConnectTimeout func() time.Duration
dialoptions.go#L250: o.minConnectTimeout = func() time.Duration {
dialoptions.go#L260: func WithBackoffMaxDelay(md time.Duration) DialOption {
dialoptions.go#L373: func WithTimeout(d time.Duration) DialOption {
dialoptions.go#L400: func WithDialer(f func(string, time.Duration) (net.Conn, error)) DialOption {
dialoptions.go#L618: func withMinConnectDeadline(f func() time.Duration) DialOption {
server.go#L173: connectionTimeout time.Duration
server.go#L509: func ConnectionTimeout(d time.Duration) ServerOption {
server.go#L821: var tempDelay time.Duration // how long to sleep on accept failure
service_config.go#L132: func parseDuration(s *string) (*time.Duration, error) {
service_config.go#L146: var d time.Duration
service_config.go#L152: d = time.Duration(i) * time.Second
service_config.go#L166: d += time.Duration(f)
stream.go#L665: var dur time.Duration
stream.go#L667: dur = time.Millisecond * time.Duration(pushback)
stream.go#L675: dur = time.Duration(grpcrand.Int63n(int64(cur)))
trace.go#L60: deadline time.Duration // may be zero
google.golang.org/grpc/backoff
backoff.go#L32: BaseDelay time.Duration
backoff.go#L39: MaxDelay time.Duration
google.golang.org/grpc/internal/backoff
backoff.go#L37: Backoff(retries int) time.Duration
backoff.go#L54: func (bc Exponential) Backoff(retries int) time.Duration {
backoff.go#L72: return time.Duration(backoff)
google.golang.org/grpc/internal/binarylog
method_logger.go#L157: Timeout time.Duration
google.golang.org/grpc/internal/grpcutil
encode_duration.go#L30: func div(d, r time.Duration) int64 {
encode_duration.go#L41: func EncodeDuration(t time.Duration) string {
google.golang.org/grpc/internal/serviceconfig
serviceconfig.go#L139: Timeout *time.Duration
serviceconfig.go#L169: InitialBackoff time.Duration
serviceconfig.go#L170: MaxBackoff time.Duration
google.golang.org/grpc/internal/syscall
syscall_linux.go#L71: func SetTCPUserTimeout(conn net.Conn, timeout time.Duration) error {
google.golang.org/grpc/internal/transport
defaults.go#L31: infinity = time.Duration(math.MaxInt64)
handler_server.go#L131: timeout time.Duration
http2_client.go#L1651: func minTime(a, b time.Duration) time.Duration {
http2_client.go#L1665: timeoutLeft := time.Duration(0)
http2_client.go#L1678: timer.Reset(time.Duration(lastRead) + t.kp.Time - time.Duration(time.Now().UnixNano()))
http2_server.go#L393: timeout time.Duration
http2_server.go#L1126: kpTimeoutLeft := time.Duration(0)
http2_server.go#L1182: kpTimer.Reset(time.Duration(lastRead) + t.kp.Time - time.Duration(time.Now().UnixNano()))
http2_server.go#L1438: func getJitter(v time.Duration) time.Duration {
http2_server.go#L1445: return time.Duration(j)
http_util.go#L180: func timeoutUnitToDuration(u timeoutUnit) (d time.Duration, ok bool) {
http_util.go#L199: func decodeTimeout(s string) (time.Duration, error) {
http_util.go#L220: return time.Duration(math.MaxInt64), nil
http_util.go#L222: return d * time.Duration(t), nil
transport.go#L533: ConnectionTimeout time.Duration
google.golang.org/grpc/keepalive
keepalive.go#L37: Time time.Duration // The current default value is infinity.
keepalive.go#L41: Timeout time.Duration // The current default value is 20 seconds.
keepalive.go#L55: MaxConnectionIdle time.Duration // The current default value is infinity.
keepalive.go#L60: MaxConnectionAge time.Duration // The current default value is infinity.
keepalive.go#L63: MaxConnectionAgeGrace time.Duration // The current default value is infinity.
keepalive.go#L67: Time time.Duration // The current default value is 2 hours.
keepalive.go#L71: Timeout time.Duration // The current default value is 20 seconds.
keepalive.go#L80: MinTime time.Duration // The current default value is 5 minutes.
google.golang.org/protobuf/types/known/durationpb
duration.pb.go#L167: func New(d time.Duration) *Duration {
duration.pb.go#L176: func (x *Duration) AsDuration() time.Duration {
duration.pb.go#L179: d := time.Duration(secs) * time.Second
duration.pb.go#L180: overflow := d/time.Second != time.Duration(secs)
duration.pb.go#L181: d += time.Duration(nanos) * time.Nanosecond
duration.pb.go#L187: return time.Duration(math.MinInt64)
duration.pb.go#L189: return time.Duration(math.MaxInt64)
internal/profile
profile.go#L348: ss = append(ss, fmt.Sprintf("Duration: %v", time.Duration(p.DurationNanos)))
net
dial.go#L40: Timeout time.Duration
dial.go#L71: FallbackDelay time.Duration
dial.go#L80: KeepAlive time.Duration
dial.go#L146: timeout := timeRemaining / time.Duration(addrsRemaining)
dial.go#L159: func (d *Dialer) fallbackDelay() time.Duration {
dial.go#L332: func DialTimeout(network, address string, timeout time.Duration) (Conn, error) {
dial.go#L618: KeepAlive time.Duration
dnsclient_unix.go#L144: func (r *Resolver) exchange(ctx context.Context, server string, q dnsmessage.Question, timeout time.Duration, useTCP bool) (dnsmessage.Parser, dnsmessage.Header, error) {
dnsconfig_unix.go#L27: timeout time.Duration // wait before giving up on a query, including retries
dnsconfig_unix.go#L111: conf.timeout = time.Duration(n) * time.Second
hook.go#L25: testHookSetKeepAlive = func(time.Duration) {}
tcpsock.go#L196: func (c *TCPConn) SetKeepAlivePeriod(d time.Duration) error {
tcpsock.go#L369: func roundDurationUp(d time.Duration, to time.Duration) time.Duration {
tcpsockopt_unix.go#L15: func setKeepAlivePeriod(fd *netFD, d time.Duration) error {
net/http
client.go#L106: Timeout time.Duration
h2_bundle.go#L3828: IdleTimeout time.Duration
h2_bundle.go#L5064: func (sc *http2serverConn) shutDownIn(d time.Duration) {
h2_bundle.go#L6840: ReadIdleTimeout time.Duration
h2_bundle.go#L6845: PingTimeout time.Duration
h2_bundle.go#L6850: WriteByteTimeout time.Duration
h2_bundle.go#L6881: func (t *http2Transport) pingTimeout() time.Duration {
h2_bundle.go#L6975: idleTimeout time.Duration // or 0 for never
h2_bundle.go#L7116: timeout time.Duration
h2_bundle.go#L7223: case <-time.After(time.Second * time.Duration(backoff)):
h2_bundle.go#L7355: func (t *http2Transport) expectContinueTimeout() time.Duration {
h2_bundle.go#L7761: func (cc *http2ClientConn) responseHeaderTimeout() time.Duration {
h2_bundle.go#L9684: func (t *http2Transport) idleConnTimeout() time.Duration {
server.go#L873: func (srv *Server) tlsHandshakeTimeout() time.Duration {
server.go#L874: var ret time.Duration
server.go#L875: for _, v := range [...]time.Duration{
server.go#L2591: ReadTimeout time.Duration
server.go#L2599: ReadHeaderTimeout time.Duration
server.go#L2606: WriteTimeout time.Duration
server.go#L2612: IdleTimeout time.Duration
server.go#L2758: nextPollInterval := func() time.Duration {
server.go#L2760: interval := pollIntervalBase + time.Duration(rand.Intn(int(pollIntervalBase/10)))
server.go#L3035: var tempDelay time.Duration // how long to sleep on accept failure
server.go#L3154: func (s *Server) idleTimeout() time.Duration {
server.go#L3161: func (s *Server) readHeaderTimeout() time.Duration {
server.go#L3324: func TimeoutHandler(h Handler, dt time.Duration, msg string) Handler {
server.go#L3339: dt time.Duration
transport.go#L173: TLSHandshakeTimeout time.Duration
transport.go#L212: IdleConnTimeout time.Duration
transport.go#L218: ResponseHeaderTimeout time.Duration
transport.go#L227: ExpectContinueTimeout time.Duration
net/http/httptrace
trace.go#L254: IdleTime time.Duration
net/http/httputil
reverseproxy.go#L66: FlushInterval time.Duration
reverseproxy.go#L411: func (p *ReverseProxy) flushInterval(res *http.Response) time.Duration {
reverseproxy.go#L428: func (p *ReverseProxy) copyResponse(dst io.Writer, src io.Reader, flushInterval time.Duration) error {
reverseproxy.go#L502: latency time.Duration // non-zero; negative means to flush immediately
net/http/pprof
pprof.go#L97: func sleep(r *http.Request, d time.Duration) {
pprof.go#L142: sleep(r, time.Duration(sec)*time.Second)
pprof.go#L171: sleep(r, time.Duration(sec*float64(time.Second)))
pprof.go#L282: t := time.NewTimer(time.Duration(sec) * time.Second)
os
exec.go#L142: func (p *ProcessState) UserTime() time.Duration {
exec.go#L147: func (p *ProcessState) SystemTime() time.Duration {
exec_unix.go#L100: func (p *ProcessState) userTime() time.Duration {
exec_unix.go#L101: return time.Duration(p.rusage.Utime.Nano()) * time.Nanosecond
exec_unix.go#L104: func (p *ProcessState) systemTime() time.Duration {
exec_unix.go#L105: return time.Duration(p.rusage.Stime.Nano()) * time.Nanosecond
runtime/debug
garbage.go#L17: PauseTotal time.Duration // total pause for all collections
garbage.go#L18: Pause []time.Duration // pause history, most recent first
garbage.go#L20: PauseQuantiles []time.Duration
garbage.go#L39: stats.Pause = make([]time.Duration, 2*maxPause+3)
stubs.go#L12: func readGCStats(*[]time.Duration)
testing
benchmark.go#L39: d time.Duration
benchmark.go#L100: previousDuration time.Duration // total duration of the previous run
benchmark.go#L362: T time.Duration // The total time taken.
benchmark.go#L691: r.T += time.Duration(other.NsPerOp())
example.go#L67: func (eg *InternalExample) processRunResult(stdout string, timeSpent time.Duration, finished bool, recovered any) (passed bool) {
fuzz.go#L427: T time.Duration // The total time taken.
testing.go#L428: timeout *time.Duration
testing.go#L516: duration time.Duration
testing.go#L738: func fmtDuration(d time.Duration) string {
testing.go#L1134: nextSleep += time.Duration(rand.Int63n(int64(nextSleep)))
testing.go#L1579: func (f matchStringOnly) CoordinateFuzzing(time.Duration, int64, time.Duration, int64, int, []corpusEntry, []reflect.Type, string, string) error {
testing.go#L1631: CoordinateFuzzing(time.Duration, int64, time.Duration, int64, int, []corpusEntry, []reflect.Type, string, string) error