*/
public record RequestTrace(
        @Nullable String context,
        @Nullable RequestTrace parent,
        @Nullable Object data) {

    public static final String CONTEXT_PLUGIN = "plugin";
    public static final String CONTEXT_PROJECT = "project";
    public static final String CONTEXT_BOOTSTRAP = "bootstrap";

    public RequestTrace(RequestTrace parent, Object data) {

            RepositorySystemSession session,
            VersionRangeResult result,
            VersionRangeRequest request,
            Metadata.Nature wantedNature) {
        RequestTrace trace = RequestTrace.newChild(request.getTrace(), request);

        Map<String, ArtifactRepository> versionIndex = new HashMap<>();

        Metadata metadata = new DefaultMetadata(

    }

    @Test
    void testChainedTraces() {
        RequestTrace root = new RequestTrace("root", null, "root-data");
        RequestTrace level1 = new RequestTrace("level1", root, "level1-data");
        RequestTrace level2 = new RequestTrace("level2", level1, "level2-data");
        RequestTrace level3 = new RequestTrace(level2, "level3-data");

        // Verify the chain
        assertNull(root.parent());

    }

    @Test
    void lookupCollectStepDataTest() {
        RequestTrace doesNotHaveIt =
                RequestTrace.newChild(null, "foo").newChild("bar").newChild("baz");
        assertNull(ReverseTreeRepositoryListener.lookupCollectStepData(doesNotHaveIt));

        final CollectStepData data = mock(CollectStepData.class);

        RequestTrace haveItFirst = RequestTrace.newChild(null, data)
                .newChild("foo")

                .artifacts(requireNonNull(artifacts, "artifacts cannot be null"))
                .build();
    }

    @NotThreadSafe
    class ArtifactInstallerRequestBuilder {
        Session session;
        RequestTrace trace;
        Collection<ProducedArtifact> artifacts = Collections.emptyList();

        ArtifactInstallerRequestBuilder() {}

        @Nonnull

    }

    @Override
    public Artifact resolve(Plugin plugin, List<RemoteRepository> repositories, RepositorySystemSession session)
            throws PluginResolutionException {
        RequestTrace trace = RequestTrace.newChild(null, plugin);

        Artifact pluginArtifact = toArtifact(plugin, session);

        try {
            DefaultRepositorySystemSession pluginSession = new DefaultRepositorySystemSession(session);

        }

        return null;
    }

    private PluginPrefixResult resolveFromRepository(
            PluginPrefixRequest request, LinkedHashMap<String, Set<String>> candidates) {
        RequestTrace trace = RequestTrace.newChild(null, request);

        List<MetadataRequest> requests = new ArrayList<>();

        for (String pluginGroup : candidates.keySet()) {
            org.eclipse.aether.metadata.Metadata metadata =

@Experimental
abstract class BaseRequest<S extends ProtoSession> implements Request<S> {

    private final S session;
    private final RequestTrace trace;

    protected BaseRequest(@Nonnull S session) {
        this(session, null);
    }

    protected BaseRequest(@Nonnull S session, RequestTrace trace) {
        this.session = requireNonNull(session, "session cannot be null");
        this.trace = trace;
    }

    @Nonnull

        this.decorators = decorators;
    }

    @Override
    public DependencyResolutionResult resolve(DependencyResolutionRequest request)
            throws DependencyResolutionException {
        final RequestTrace trace = RequestTrace.newChild(null, request);

        final DefaultDependencyResolutionResult result = new DefaultDependencyResolutionResult();

        final MavenProject project = request.getMavenProject();

import org.apache.maven.model.resolution.UnresolvableModelException;
import org.eclipse.aether.RepositorySystem;
import org.eclipse.aether.RepositorySystemSession;
import org.eclipse.aether.RequestTrace;
import org.eclipse.aether.artifact.Artifact;
import org.eclipse.aether.artifact.DefaultArtifact;
import org.eclipse.aether.impl.RemoteRepositoryManager;
import org.eclipse.aether.repository.RemoteRepository;