Method Do

pkg/traceql/engine_metrics.go:1266–1383

Do metrics on the given source of data and merge the results into the working set. Optionally, if provided, uses the known time range of the data for last-minute optimizations. Time range is unix nanos

(ctx context.Context, f SpansetFetcher, fetcherStart, fetcherEnd uint64, maxSeries int)

// uses the known time range of the data for last-minute optimizations. Time range is unix nanos

func (e *MetricsEvaluator) Do(ctx context.Context, f SpansetFetcher, fetcherStart, fetcherEnd uint64, maxSeries int) error {
	if !e.needsFullTrace && e.spanOnlyFetch {
		// The query can operate at a span level so attempt.
		// This is faster. If not supported then fallback to spanset level.
		err := e.DoSpansOnly(ctx, f, fetcherStart, fetcherEnd, maxSeries)
		if !errors.Is(err, util.ErrUnsupported) {
			// We ran successfully or some other error.
			// In the case of unsupported, keep going and use original SpansetFetcher.
			return err
		}
	}

	// Make a copy of the request so we can modify it.
	storageReq := *e.storageReq

	if fetcherStart > 0 && fetcherEnd > 0 &&
		// exclude special case for a block with the same start and end
		fetcherStart != fetcherEnd {
		// Dynamically decide whether to use the trace-level timestamp columns
		// for filtering.
		overlap := timeRangeOverlap(e.start, e.end, fetcherStart, fetcherEnd)

		if overlap == 0.0 {
			// This shouldn't happen but might as well check.
			// No overlap == nothing to do
			return nil
		}

		// Our heuristic is if the overlap between the given fetcher (i.e. block)
		// and the request is less than X%, use them.  Above X%, the cost of loading
		// them doesn't outweight the benefits. The default 20% was measured in
		// local benchmarking.
		if overlap < e.timeOverlapCutoff {
			storageReq.StartTimeUnixNanos = e.start
			storageReq.EndTimeUnixNanos = e.end // Should this be exclusive?
		}
	}

	fetch, err := f.Fetch(ctx, storageReq)
	if errors.Is(err, util.ErrUnsupported) {
		return nil
	}
	if err != nil {
		return err
	}

	defer fetch.Results.Close()

	seriesCount := 0

	for {
		ss, err := fetch.Results.Next(ctx)
		if err != nil {
			return err
		}
		if ss == nil {
			break
		}