Method DoSpansOnly

pkg/traceql/engine_metrics.go:1386–1479

DoSpansOnly is the same as Do but using the new span-only fetch layer.

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

// DoSpansOnly is the same as Do but using the new span-only fetch layer.
func (e *MetricsEvaluator) DoSpansOnly(ctx context.Context, f SpansetFetcher, fetcherStart, fetcherEnd uint64, maxSeries int) error {
	// 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.FetchSpans(ctx, storageReq)
	if err != nil {
		return err
	}

	defer fetch.Results.Close()

	for {
		done, err := func() (done bool, err error) {
			s, err := fetch.Results.Next(ctx)
			if err != nil {
				return true, err
			}
			if s == nil {
				return true, nil
			}

			// Acquire lock while doing engine work. It is
			// not locked above while doing storage work.
			// TODO(mdisibio): Removed batching so that the mutex lock is not held during
			// storage work and allows the secondPass callback to be called. However this
			// represents ~20% performance loss, so we need to re-add batching.
			e.mtx.Lock()
			defer e.mtx.Unlock()

			if e.checkTime {
				st := s.StartTimeUnixNanos()
				if st <= e.start || st > e.end {
					return false, nil
				}
			}