tracker2.trackers >> [tracker3]
        tracker3.trackers >> []

        def generator = new ClientBuildEventGenerator(consumer, subscriptions, [mapper], fallback)

        when:
        generator.started(operation, startEvent)

        then:
        1 * tracker1.started(operation, startEvent)
        1 * tracker2.started(operation, startEvent)

        this.trackers = ImmutableList.copyOf(trackers);
    }

    private void collectTrackers(Set<BuildOperationTracker> dest, List<? extends BuildOperationTracker> trackers) {
        for (BuildOperationTracker tracker : trackers) {
            if (!dest.contains(tracker)) {
                collectTrackers(dest, tracker.getTrackers());
                dest.add(tracker);
            }
        }
    }

import java.util.Collections;
import java.util.List;

/**
 * Tracks some state for build operations of a given type.
 */
public interface BuildOperationTracker {
    /**
     * Returns the trackers that are used by this tracker. If this tracker is required, then its trackers should be notified of
     * build operation execution. If this tracker is not required, the trackers can be ignored.
     */

    boolean isEnabled(BuildEventSubscriptions subscriptions);

    Class<DETAILS> getDetailsType();

    /**
     * Returns the trackers that are used by this mapper. If this mapper is enabled, then the trackers should be notified of
     * build operation execution. If this mapper is not enabled, the trackers can be ignored.
     */
    default List<? extends BuildOperationTracker> getTrackers() {
        return Collections.emptyList();
    }

func (wk *worker) drainRetiringTrackers() {
	// cleanup any trackers that were in the process
	// of being retired, but didn't get processed due
	// to termination
	for {
		select {
		case ft := <-wk.retireTrackerCh:
			retireTracker(ft)
		default:
			return
		}
	}
}

// make a local copy of the set of trackers to avoid contention with callers
// used only by the worker goroutine

import org.jetbrains.kotlin.analysis.api.platform.KotlinPlatformComponent

/**
 * [KotlinModificationTrackerFactory] creates modification trackers for select modification events.
 *
 * Further modification tracking is implemented with a subscription-based mechanism via [KotlinModificationTopics]. Modification trackers make the most

            [r2, r3] as Set
        }

        when:
        def result = twoStageStore.search(key)

        then:
        result == [r1, r2, r3] as Set
    }

    def "file access tracker delegates to both trackers"() {
        def fat1 = Mock(FileAccessTracker)
        def fat2 = Mock(FileAccessTracker)

        when:
        twoStageStore.getFileAccessTracker().markAccessed(file)

        then:

        }

        1 * writeStore.whereIs(key, "checksum") >> { found }

        expect:
        twoStageStore.whereIs(key, "checksum") == found
    }

    def "file access tracker delegates to both trackers"() {
        def fat1 = Mock(FileAccessTracker)
        def fat2 = Mock(FileAccessTracker)

        when:
        twoStageStore.getFileAccessTracker().markAccessed(file)

        then:

	if tracker, ok := LatencyTrackersFrom(ctx); ok {
		tracker.ResponseWriteTracker.TrackDuration(d)
	}
}

// TrackAPFQueueWaitLatency is used to track latency incurred
// by priority and fairness queues.
func TrackAPFQueueWaitLatency(ctx context.Context, d time.Duration) {
	if tracker, ok := LatencyTrackersFrom(ctx); ok {
		tracker.APFQueueWaitTracker.TrackDuration(d)
	}
}

type EndpointSliceCache struct {
	// lock protects trackerByServiceMap.
	lock sync.Mutex

	// trackerByServiceMap is the basis of this cache. It contains endpoint
	// slice trackers grouped by service name and endpoint slice name. The first
	// key represents a namespaced service name while the second key represents
	// an endpoint slice name. Since endpoints can move between slices, we