Method Do

tempodb/blocklist/poller.go:140–252

Do does the doing of getting a blocklist

(parentCtx context.Context, previous *List)

// Do does the doing of getting a blocklist
func (p *Poller) Do(parentCtx context.Context, previous *List) (PerTenant, PerTenantCompacted, error) {
	start := time.Now()

	parentCtx, cancel := context.WithCancel(parentCtx)
	defer cancel()

	parentCtx, parentSpan := tracer.Start(parentCtx, "Poller.Do")
	defer parentSpan.End()

	tenants, err := p.reader.Tenants(parentCtx)
	if err != nil {
		metricBlocklistErrors.WithLabelValues("").Inc()
		return nil, nil, err
	}

	var (
		wg  = boundedwaitgroup.New(p.cfg.TenantPollConcurrency)
		mtx = sync.Mutex{}

		blocklist          = PerTenant{}
		compactedBlocklist = PerTenantCompacted{}

		tenantFailuresRemaining = atomic.NewInt32(int32(p.cfg.TolerateTenantFailures))

		link  = trace.LinkFromContext(parentCtx)
		bgCtx = context.Background()
	)

	for _, tenantID := range tenants {
		// Do not continue if we have been canceled.
		if parentCtx.Err() != nil {
			// Wait for our work to complete.
			wg.Wait()
			return nil, nil, parentCtx.Err()
		}

		// Exit early if we have exceeded our tolerance for number of failing tenants.
		if tenantFailuresRemaining.Load() < 0 {
			level.Error(p.logger).Log("msg", "exiting polling loop early because too many errors")
			break
		}

		wg.Add(1)
		go func(tenantID string) {
			defer wg.Done()

			bgCtx, bgSpan := tracer.Start(bgCtx, "Poller.Do.func")
			defer bgSpan.End()

			bgSpan.SetAttributes(attribute.String("tenant", tenantID))
			bgSpan.AddLink(link)

			var (
				consecutiveErrorsRemaining = p.cfg.TolerateConsecutiveErrors
				newBlockList               = make([]*backend.BlockMeta, 0)
				newCompactedBlockList      = make([]*backend.CompactedBlockMeta, 0)
				err                        error
			)