@Override @Nullable protected Channel channel() { if (log.isAvailable(RequestLogAvailability.REQUEST_START)) { return log.channel(); } else { return null; } }
@Override public void endRequest() { endRequest0(null); }
@Override public void endResponse(long responseEndTimeNanos) { endResponse0(null, responseEndTimeNanos); }
@Override public void responseFirstBytesTransferred(long responseFirstBytesTransferredTimeNanos) { if (isAvailabilityAlreadyUpdated(RESPONSE_FIRST_BYTES_TRANSFERRED)) { return; } responseFirstBytesTransferred0(responseFirstBytesTransferredTimeNanos); }
private void startResponse0(long responseStartTimeNanos, long responseStartTimeMicros, boolean updateAvailability) { if (isAvailabilityAlreadyUpdated(RESPONSE_START)) { return; } this.responseStartTimeNanos = responseStartTimeNanos; this.responseStartTimeMicros = responseStartTimeMicros; if (updateAvailability) { updateAvailability(RESPONSE_START); } }
@Override public void requestFirstBytesTransferred(long requestFirstBytesTransferredTimeNanos) { if (isAvailabilityAlreadyUpdated(REQUEST_FIRST_BYTES_TRANSFERRED)) { return; } requestFirstBytesTransferred0(requestFirstBytesTransferredTimeNanos); }
private void propagateRequestSideLog(RequestLog child) { child.addListener(log -> startRequest0(log.channel(), log.sessionProtocol(), null, log.requestStartTimeNanos(), log.requestStartTimeMicros(), true), REQUEST_START); child.addListener(log -> serializationFormat(log.serializationFormat()), SCHEME); child.addListener(log -> requestFirstBytesTransferred(log.requestFirstBytesTransferredTimeNanos()), REQUEST_FIRST_BYTES_TRANSFERRED); child.addListener(log -> requestHeaders(log.requestHeaders()), REQUEST_HEADERS); child.addListener(log -> requestContent(log.requestContent(), log.rawRequestContent()), REQUEST_CONTENT); child.addListener(log -> endRequest0(log.requestCause(), log.requestEndTimeNanos()), REQUEST_END); }
private void endRequest0(@Nullable Throwable requestCause, long requestEndTimeNanos) { final int flags = requestCause == null && requestContentDeferred ? FLAGS_REQUEST_END_WITHOUT_CONTENT : REQUEST_END.setterFlags(); if (isAvailable(flags)) { return; } // if the request is not started yet, call startRequest() with requestEndTimeNanos so that // totalRequestDuration will be 0 startRequest0(null, context().sessionProtocol(), null, requestEndTimeNanos, currentTimeMicros(), false); this.requestEndTimeNanos = requestEndTimeNanos; this.requestCause = requestCause; updateAvailability(flags); }
private void propagateResponseSideLog(RequestLog lastChild) { // update the available logs if the lastChild already has them if (lastChild.isAvailable(RESPONSE_START)) { startResponse0(lastChild.responseStartTimeNanos(), lastChild.responseStartTimeMicros(), true); } if (lastChild.isAvailable(RESPONSE_FIRST_BYTES_TRANSFERRED)) { responseFirstBytesTransferred(lastChild.responseFirstBytesTransferredTimeNanos()); } if (lastChild.isAvailable(RESPONSE_HEADERS)) { responseHeaders(lastChild.responseHeaders()); } if (lastChild.isAvailable(RESPONSE_CONTENT)) { responseContent(lastChild.responseContent(), lastChild.rawResponseContent()); } if (lastChild.isAvailable(RESPONSE_END)) { endResponse0(lastChild.responseCause(), lastChild.responseEndTimeNanos()); } lastChild.addListener(log -> startResponse0( log.responseStartTimeNanos(), log.responseStartTimeMicros(), true), RESPONSE_START); lastChild.addListener(log -> responseFirstBytesTransferred( log.responseFirstBytesTransferredTimeNanos()), RESPONSE_FIRST_BYTES_TRANSFERRED); lastChild.addListener(log -> responseHeaders(log.responseHeaders()), RESPONSE_HEADERS); lastChild.addListener(log -> responseContent( log.responseContent(), log.rawResponseContent()), RESPONSE_CONTENT); lastChild.addListener(log -> endResponse0( log.responseCause(), log.responseEndTimeNanos()), RESPONSE_END); }
private void endResponse0(@Nullable Throwable responseCause, long responseEndTimeNanos) { final int flags = responseCause == null && responseContentDeferred ? FLAGS_RESPONSE_END_WITHOUT_CONTENT : RESPONSE_END.setterFlags(); if (isAvailable(flags)) { return; } // if the response is not started yet, call startResponse() with responseEndTimeNanos so that // totalResponseDuration will be 0 startResponse0(responseEndTimeNanos, currentTimeMicros(), false); this.responseEndTimeNanos = responseEndTimeNanos; if (this.responseCause == null) { this.responseCause = responseCause; } updateAvailability(flags); }
@Override public long requestEndTimeNanos() { ensureAvailability(REQUEST_END); return requestEndTimeNanos; }
this.clientAddress = requireNonNull(clientAddress, "clientAddress"); log = new DefaultRequestLog(this); if (requestStartTimeSet) { log.startRequest(ch, sessionProtocol, sslSession, requestStartTimeNanos, requestStartTimeMicros); } else { log.startRequest(ch, sessionProtocol, sslSession); log.requestHeaders(request.headers()); log.requestFirstBytesTransferred();
@Override public void addListener(RequestLogListener listener, RequestLogAvailability... availabilities) { requireNonNull(listener, "listener"); requireNonNull(availabilities, "availabilities"); addListener(listener, getterFlags(availabilities)); }
@Override public boolean isAvailable(RequestLogAvailability... availabilities) { return isAvailable(getterFlags(availabilities)); }
private void startResponse0(boolean updateAvailability) { startResponse0(System.nanoTime(), currentTimeMicros(), updateAvailability); }
private void startRequest0(Channel channel, SessionProtocol sessionProtocol, @Nullable SSLSession sslSession, boolean updateAvailability) { startRequest0(channel, sessionProtocol, sslSession, System.nanoTime(), currentTimeMicros(), updateAvailability); }
EarlyRespondingRequestContext(Channel channel, MeterRegistry meterRegistry, SessionProtocol sessionProtocol, HttpMethod method, String path, @Nullable String query, Request request) { super(meterRegistry, sessionProtocol, method, path, query, request); this.channel = requireNonNull(channel, "channel"); requestLog = new DefaultRequestLog(this); }
@Override public void deferRequestContent() { if (isAvailabilityAlreadyUpdated(REQUEST_CONTENT)) { return; } requestContentDeferred = true; }
@Override public void addListener(RequestLogListener listener, RequestLogAvailability availability) { requireNonNull(listener, "listener"); requireNonNull(availability, "availability"); addListener(listener, availability.getterFlags()); }
@Override public void serializationFormat(SerializationFormat serializationFormat) { if (isAvailabilityAlreadyUpdated(SCHEME)) { return; } this.serializationFormat = requireNonNull(serializationFormat, "serializationFormat"); updateAvailability(SCHEME); }