Method ListBlocks

tempodb/backend/gcs/gcs.go:212–327

ListBlocks implements backend.Reader

(ctx context.Context, tenant string)

// ListBlocks implements backend.Reader
func (rw *readerWriter) ListBlocks(ctx context.Context, tenant string) ([]uuid.UUID, []uuid.UUID, error) {
	ctx, span := tracer.Start(ctx, "readerWriter.ListBlocks")
	defer span.End()

	var (
		wg                sync.WaitGroup
		mtx               sync.Mutex
		bb                = blockboundary.CreateBlockBoundaries(rw.cfg.ListBlocksConcurrency)
		errChan           = make(chan error, len(bb))
		keypath           = backend.KeyPathWithPrefix(backend.KeyPath{tenant}, rw.cfg.Prefix)
		minID             uuid.UUID
		maxID             uuid.UUID
		blockIDs          = make([]uuid.UUID, 0, 1000)
		compactedBlockIDs = make([]uuid.UUID, 0, 1000)
	)

	prefix := path.Join(keypath...)
	if len(prefix) > 0 {
		prefix += "/"
	}

	for i := 0; i < len(bb)-1; i++ {
		minID = uuid.UUID(bb[i])
		maxID = uuid.UUID(bb[i+1])

		wg.Add(1)
		go func(minUUID, maxUUID uuid.UUID) {
			defer wg.Done()

			var (
				query = &storage.Query{
					Prefix:      prefix,
					Delimiter:   "",
					Versions:    false,
					StartOffset: prefix + minUUID.String(),
				}
				parts []string
				id    uuid.UUID
			)

			// If max is global max, then we don't want to set an end offset to
			// ensure we reach the end.  EndOffset is exclusive.
			if maxUUID != backend.GlobalMaxBlockID {
				query.EndOffset = prefix + maxUUID.String()
			}

			iter := rw.bucket.Objects(ctx, query)

			for {
				if ctx.Err() != nil {
					return
				}

				attrs, err := iter.Next()
				if errors.Is(err, iterator.Done) {
					return
				}
				if err != nil {