func time.Since

80 uses

	time (current package)
		time.go#L868: func Since(t Time) Duration {

	contrib.go.opencensus.io/integrations/ocsql
		observability.go#L162: 		timeSpentMs := float64(time.Since(startTime).Nanoseconds()) / 1e6

	database/sql
		sql.go#L1257: 			atomic.AddInt64(&db.waitDuration, int64(time.Since(waitStart)))
		sql.go#L1268: 			atomic.AddInt64(&db.waitDuration, int64(time.Since(waitStart)))

	github.com/aws/aws-sdk-go/aws/csm
		reporter.go#L120: 		Latency:            aws.Int(int(time.Since(r.Time) / time.Millisecond)),

	github.com/evanw/esbuild/internal/logger
		logger.go#L757: 			time.Since(start).Milliseconds(),

	github.com/evanw/esbuild/pkg/api
		serve_other.go#L125: 			go h.notifyRequest(time.Since(start), req, http.StatusServiceUnavailable)
		serve_other.go#L175: 							go h.notifyRequest(time.Since(start), req, http.StatusInternalServerError)
		serve_other.go#L203: 				go h.notifyRequest(time.Since(start), req, http.StatusInternalServerError)
		serve_other.go#L213: 			go h.notifyRequest(time.Since(start), req, http.StatusFound)
		serve_other.go#L227: 				go h.notifyRequest(time.Since(start), req, http.StatusInternalServerError)
		serve_other.go#L250: 			go h.notifyRequest(time.Since(start), req, status)
		serve_other.go#L261: 			go h.notifyRequest(time.Since(start), req, http.StatusOK)
		serve_other.go#L269: 	go h.notifyRequest(time.Since(start), req, http.StatusNotFound)

	github.com/go-redis/redis/v8
		cluster.go#L204: 		dur += uint64(time.Since(start) / time.Microsecond)
		cluster.go#L650: 		if time.Since(state.createdAt) > 10*time.Second {

	github.com/prometheus/client_golang/prometheus
		go_collector.go#L341: 	if time.Since(c.msLastTimestamp) < c.msMaxAge {
		timer.go#L49: 	d := time.Since(t.begin)

	github.com/prometheus/client_golang/prometheus/promhttp
		instrument_client.go#L95: 			obs.With(labels(code, method, r.Method, resp.StatusCode)).Observe(time.Since(start).Seconds())
		instrument_client.go#L142: 					it.GotConn(time.Since(start).Seconds())
		instrument_client.go#L150: 					it.PutIdleConn(time.Since(start).Seconds())
		instrument_client.go#L155: 					it.DNSStart(time.Since(start).Seconds())
		instrument_client.go#L160: 					it.DNSDone(time.Since(start).Seconds())
		instrument_client.go#L165: 					it.ConnectStart(time.Since(start).Seconds())
		instrument_client.go#L173: 					it.ConnectDone(time.Since(start).Seconds())
		instrument_client.go#L178: 					it.GotFirstResponseByte(time.Since(start).Seconds())
		instrument_client.go#L183: 					it.Got100Continue(time.Since(start).Seconds())
		instrument_client.go#L188: 					it.TLSHandshakeStart(time.Since(start).Seconds())
		instrument_client.go#L196: 					it.TLSHandshakeDone(time.Since(start).Seconds())
		instrument_client.go#L201: 					it.WroteHeaders(time.Since(start).Seconds())
		instrument_client.go#L206: 					it.Wait100Continue(time.Since(start).Seconds())
		instrument_client.go#L211: 					it.WroteRequest(time.Since(start).Seconds())
		instrument_server.go#L70: 			obs.With(labels(code, method, r.Method, d.Status())).Observe(time.Since(now).Seconds())
		instrument_server.go#L77: 		obs.With(labels(code, method, r.Method, 0)).Observe(time.Since(now).Seconds())
		instrument_server.go#L135: 			obs.With(labels(code, method, r.Method, status)).Observe(time.Since(now).Seconds())

	go.opencensus.io/internal
		internal.go#L36: 	return start.Add(time.Since(start))

	go.opencensus.io/plugin/ocgrpc
		stats_common.go#L133: 	elapsedTime := time.Since(d.startTime)

	go.opencensus.io/plugin/ochttp
		client_stats.go#L102: 		latencyMs := float64(time.Since(t.start)) / float64(time.Millisecond)
		server.go#L194: 			ServerLatency.M(float64(time.Since(t.start)) / float64(time.Millisecond)),

	go.opencensus.io/zpages
		rpcz.go#L208: 	ageSec := float64(time.Since(programStartTime)) / float64(time.Second)

	golang.org/x/net/http2
		transport.go#L803: 	return cc.idleTimeout != 0 && !cc.lastIdle.IsZero() && time.Since(cc.lastIdle.Round(0)) > cc.idleTimeout

	golang.org/x/net/trace
		events.go#L359: 	elapsed := time.Since(el.Start)
		trace.go#L898: 		t = time.Since(tr.Start)

	golang.org/x/pkgsite/cmd/prober
		main.go#L355: 	latency := float64(time.Since(start)) / float64(time.Millisecond)

	golang.org/x/pkgsite/internal/database
		copy.go#L58: 			log.Debugf(ctx, "CopyUpsert(%q): copied %d rows in %s", table, n, time.Since(start))
		copy.go#L70: 			log.Debugf(ctx, "CopyUpsert(%q): upserted %d rows in %s", table, ctag.RowsAffected(), time.Since(start))
		database.go#L126: 			msg := fmt.Sprintf("args=%v; elapsed=%q, start=%q, deadline=%q", args, time.Since(start), start, d)
		logging.go#L79: 		dur := time.Since(start)
		logging.go#L132: 			uid, db.opts.Isolation, time.Since(start), *errp)

	golang.org/x/pkgsite/internal/fetch
		fetch.go#L122: 		latency := float64(time.Since(start).Seconds())

	golang.org/x/pkgsite/internal/frontend
		404.go#L114: 		if fr.status == http.StatusNotFound && time.Since(fr.updatedAt) > s.taskIDChangeInterval {
		fetch.go#L135: 		recordFrontendFetchMetric(ctx, status, time.Since(start))
		fetch.go#L214: 			logf(ctx, "fetched %s@%s for %s: status=%d, err=%v; took %.3fs", modulePath, requestedVersion, fullPath, fr.status, fr.err, time.Since(start).Seconds())
		fetch.go#L416: 		if time.Since(vm.UpdatedAt) > taskIDChangeInterval {
		search.go#L324: 	elapsedHours := int(time.Since(date).Hours())

	golang.org/x/pkgsite/internal/middleware
		caching.go#L145: 	recordCacheResult(ctx, c.name, hit, time.Since(start))
		requestlog.go#L87: 			Latency: time.Since(start),
		stats.go#L58: 		SetStat(ctx, name+" ms", time.Since(start).Milliseconds())
		stats.go#L101: 		s.stats.MillisToFirstByte = time.Since(s.start).Milliseconds()
		stats.go#L113: 	s.stats.MillisToLastByte = time.Since(s.start).Milliseconds()

	golang.org/x/pkgsite/internal/postgres
		search.go#L212: 				Latency: time.Since(start),
		search.go#L234: 	latency := float64(time.Since(searchStart)) / float64(time.Millisecond)
		test_helper.go#L188: 	log.Printf("parallel test setup for %d DBs took %s", numDBs, time.Since(start))

	golang.org/x/pkgsite/internal/worker
		fetch.go#L149: 	ft.timings["db.UpsertModuleVersionState"] = time.Since(start)
		fetch.go#L212: 		ft.timings["fetch.FetchModule"] = time.Since(start)
		fetch.go#L252: 	ft.timings["db.InsertModule"] = time.Since(start)
		fetch.go#L326: 		ft.timings["worker.updatedVersionMap"] = time.Since(start)
		fetch.go#L367: 		ft.timings["worker.deleteModule"] = time.Since(start)
		server.go#L397: 		recordProcessingLag(ctx, time.Since(ot))
		server.go#L653: 			return time.Since(t).Round(time.Second)

	google.golang.org/grpc/internal/transport
		bdp_estimator.go#L111: 	rttSample := time.Since(b.sentAt).Seconds()
		http2_server.go#L988: 			val := t.kp.MaxConnectionIdle - time.Since(idle)

	net/http
		h2_bundle.go#L7306: 	return cc.idleTimeout != 0 && !cc.lastIdle.IsZero() && time.Since(cc.lastIdle.Round(0)) > cc.idleTimeout
		transport.go#L1961: 		t.IdleTime = time.Since(idleAt)

	testing
		benchmark.go#L136: 		b.duration += time.Since(b.start)
		run_example.go#L51: 		timeSpent := time.Since(start)
		testing.go#L1042: 	t.duration += time.Since(t.start)
		testing.go#L1134: 				root.duration += time.Since(root.start)
		testing.go#L1149: 		t.duration += time.Since(t.start)
		testing.go#L1163: 			t.duration += time.Since(cleanupStart)