return this;
        }

        /**
         * Sets the request trace for debugging and diagnostics.
         *
         * @param trace the request trace, may be {@code null}
         * @return this builder, never {@code null}
         */
        public VersionResolverRequestBuilder trace(RequestTrace trace) {
            this.trace = trace;
            return this;
        }

        /**

            }

            DependencyRequest depRequest = new DependencyRequest(request, resolutionFilter);
            depRequest.setTrace(trace.trace());

            request.setTrace(RequestTrace.newChild(trace.trace(), depRequest));

            node = repoSystem.collectDependencies(pluginSession, request).getRoot();

            if (logger.isDebugEnabled()) {

                },
                "Item": {
                    "title": "Item",
                    "required": ["name", "price"],
                    "type": "object",
                    "properties": {
                        "name": {"title": "Name", "type": "string"},
                        "price": {"title": "Price", "type": "number"},
                    },
                },
                "ResponseMessage": {

                },
                "Item": {
                    "title": "Item",
                    "required": ["name", "price"],
                    "type": "object",
                    "properties": {
                        "name": {"title": "Name", "type": "string"},
                        "price": {"title": "Price", "type": "number"},
                    },
                },
                "Message": {

        assertEquals("bootstrap", RequestTrace.CONTEXT_BOOTSTRAP);
    }

    @Test
    void testNullValues() {
        RequestTrace trace = new RequestTrace(null, null, null);
        assertNull(trace.context());
        assertNull(trace.parent());
        assertNull(trace.data());
    }

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

			Key:   "trace",
			Value: slog.GroupValue(fields...),
		})

	case l.SlowThreshold != 0 && elapsed > l.SlowThreshold:
		l.log(ctx, slog.LevelWarn, "SQL executed", slog.Attr{
			Key:   "trace",
			Value: slog.GroupValue(fields...),
		})

	case l.LogLevel >= Info:
		l.log(ctx, slog.LevelInfo, "SQL executed", slog.Attr{
			Key:   "trace",
			Value: slog.GroupValue(fields...),
		})
	}

            requests.add(new MetadataRequest(metadata, null, REPOSITORY_CONTEXT).setTrace(trace));

            for (RemoteRepository repository : request.getRepositories()) {
                requests.add(new MetadataRequest(metadata, repository, REPOSITORY_CONTEXT).setTrace(trace));
            }
        }

        // initial try, use locally cached metadata

        for (final Entry<String, Map<String, CacheEntry<DfsReferralDataInternal>>> entry : domains.entrySet()) {
            log.trace("Domain " + entry.getKey());
            for (final Entry<String, CacheEntry<DfsReferralDataInternal>> entry2 : entry.getValue().entrySet()) {
                log.trace("  Root " + entry2.getKey());
                if (entry2.getValue().map != null) {

    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
    @Override
    public S getSession() {

@dataclass
class Item:
    id: uuid.UUID
    name: str
    price: float
    tags: list[str] = field(default_factory=list)
    description: Union[str, None] = None
    tax: Union[float, None] = None


app = FastAPI()


@app.get("/item", response_model=Item)
async def read_item():
    return {
        "id": uuid.uuid4(),
        "name": "Island In The Moon",
        "price": 12.99,