Method run

tsdb/db.go:1204–1272

(ctx context.Context)

}

func (db *DB) run(ctx context.Context) {
	defer close(db.donec)

	backoff := time.Duration(0)

	for {
		select {
		case <-db.stopc:
			return
		case <-time.After(backoff):
		}

		select {
		case <-time.After(db.opts.BlockReloadInterval):
			db.cmtx.Lock()
			if err := db.reloadBlocks(); err != nil {
				db.logger.Error("reloadBlocks", "err", err)
			}
			db.cmtx.Unlock()

			select {
			case db.compactc <- struct{}{}:
			default:
			}
			// We attempt mmapping of head chunks regularly.
			db.head.mmapHeadChunks()

			numStaleSeries, numSeries := db.Head().NumStaleSeries(), db.Head().NumSeries()
			if db.autoCompact && numSeries > 0 && db.opts.staleSeriesCompactionThreshold.Load() > 0 {
				staleSeriesRatio := float64(numStaleSeries) / float64(numSeries)
				if staleSeriesRatio >= db.opts.staleSeriesCompactionThreshold.Load() {
					nextCompactionIsSoon := false
					if !db.lastHeadCompactionTime.IsZero() {
						compactionInterval := time.Duration(db.head.chunkRange.Load()) * time.Millisecond
						nextEstimatedCompactionTime := db.lastHeadCompactionTime.Add(compactionInterval)
						if time.Now().Add(10 * time.Minute).After(nextEstimatedCompactionTime) {
							// Next compaction is starting within next 10 mins.
							nextCompactionIsSoon = true
						}
					}

					if !nextCompactionIsSoon {
						if err := db.CompactStaleHead(); err != nil {
							db.logger.Error("immediate stale series compaction failed", "err", err)
						}
					}
				}
			}

		case <-db.compactc:
			db.metrics.compactionsTriggered.Inc()

			db.autoCompactMtx.Lock()
			if db.autoCompact {
				if err := db.Compact(ctx); err != nil {
					db.logger.Error("compaction failed", "err", err)
					backoff = exponential(backoff, 1*time.Second, 1*time.Minute)
				} else {