private void exportRpcResponse(Map<String, String> out, RequestLog log) { if (!log.isAvailable(RequestLogAvailability.RESPONSE_CONTENT)) { return; } final Object responseContent = log.responseContent(); if (responseContent instanceof RpcResponse) { final RpcResponse rpcRes = (RpcResponse) responseContent; if (builtIns.contains(RES_RPC_RESULT) && !rpcRes.isCompletedExceptionally()) { try { out.put(RES_RPC_RESULT.mdcKey, String.valueOf(rpcRes.get())); } catch (Exception e) { // Should never reach here because RpcResponse must be completed. throw new Error(e); } } } }
private static boolean isSuccess(RequestLog log) { if (log.responseCause() != null) { return false; } final int statusCode = log.statusCode(); if (statusCode < 100 || statusCode >= 400) { return false; } final Object responseContent = log.responseContent(); if (responseContent instanceof RpcResponse) { return !((RpcResponse) responseContent).isCompletedExceptionally(); } return true; }
private static void verifyOneWayInvocation(Class<?> expectedServiceType, String expectedParam) { await().untilAsserted(() -> { final RequestLog log = requestLogs.poll(); assertThat(log).isNotNull(); final RpcRequest req = (RpcRequest) log.requestContent(); final RpcResponse res = (RpcResponse) log.responseContent(); assertThat(req).isNotNull(); assertThat(req.serviceType()).isSameAs(expectedServiceType); assertThat(req.method()).isEqualTo("hello"); assertThat(req.params()).containsExactly(expectedParam); assertThat((Object) res).isNotNull(); assertThat(res.get()).isNull(); }); }
private static void assertNoRpcContent() throws InterruptedException { final RequestLog log = requestLogQueue.take(); assertThat(log.availabilities()).contains(RequestLogAvailability.COMPLETE); assertThat(log.requestContent()).isNull(); assertThat(log.responseContent()).isNull(); }
private static void checkRequestLogStatus(RequestLogStatusChecker checker) throws Exception { final RequestLog log = requestLogQueue.take(); assertThat(log.availabilities()).contains(RequestLogAvailability.COMPLETE); final RpcRequest rpcReq = (RpcRequest) log.requestContent(); final RpcResponse rpcRes = (RpcResponse) log.responseContent(); assertThat(rpcReq).isNull(); assertThat((Object) rpcRes).isNotNull(); assertThat(rpcRes.cause()).isNotNull(); checker.check(((StatusException) rpcRes.cause()).getStatus()); }
@Test public void cancelAfterBegin() throws Exception { final StreamRecorder<StreamingInputCallResponse> responseObserver = StreamRecorder.create(); final StreamObserver<StreamingInputCallRequest> requestObserver = asyncStub.streamingInputCall(responseObserver); requestObserver.onError(new RuntimeException()); responseObserver.awaitCompletion(); assertThat(responseObserver.getValues()).isEmpty(); assertThat(Status.fromThrowable(responseObserver.getError()).getCode()).isEqualTo(Code.CANCELLED); final RequestLog log = requestLogQueue.take(); assertThat(log.availabilities()).contains(RequestLogAvailability.COMPLETE); assertThat(log.responseContent()).isInstanceOf(RpcResponse.class); final Throwable cause = ((RpcResponse) log.responseContent()).cause(); assertThat(cause).isInstanceOf(StatusException.class); assertThat(((StatusException) cause).getStatus().getCode()).isEqualTo(Code.CANCELLED); }
private void checkRequestLog(RequestLogChecker checker) throws Exception { final RequestLog log = requestLogQueue.take(); assertThat(log.availabilities()).contains(RequestLogAvailability.COMPLETE); final RpcRequest rpcReq = (RpcRequest) log.requestContent(); final RpcResponse rpcRes = (RpcResponse) log.responseContent(); assertThat(rpcReq).isNotNull(); assertThat((Object) rpcRes).isNotNull(); assertThat(rpcReq.serviceType()).isEqualTo(GrpcLogUtil.class); final Status grpcStatus; if (rpcRes.cause() != null) { grpcStatus = ((StatusException) rpcRes.cause()).getStatus(); } else { grpcStatus = null; } checker.check(rpcReq, rpcRes, grpcStatus); }
private static void checkRequestLog(RequestLogChecker checker) throws Exception { final RequestLog log = requestLogQueue.take(); assertThat(log.availabilities()).contains(RequestLogAvailability.COMPLETE); final RpcRequest rpcReq = (RpcRequest) log.requestContent(); final RpcResponse rpcRes = (RpcResponse) log.responseContent(); assertThat(rpcReq).isNotNull(); assertThat((Object) rpcRes).isNotNull(); assertThat(rpcReq.serviceType()).isEqualTo(GrpcLogUtil.class); final Status grpcStatus; if (rpcRes.cause() != null) { grpcStatus = ((StatusException) rpcRes.cause()).getStatus(); } else { grpcStatus = null; } checker.check(rpcReq, rpcRes, grpcStatus); }
@Test(timeout = 10000) public void testMessageLogsForOneWay() throws Exception { final OnewayHelloService.Iface client = Clients.newClient(clientFactory(), getURI(Handlers.HELLO), Handlers.ONEWAYHELLO.iface(), clientOptions); recordMessageLogs = true; client.hello("trustin"); final RequestLog log = requestLogs.take(); assertThat(log.requestHeaders()).isInstanceOf(HttpHeaders.class); assertThat(log.requestContent()).isInstanceOf(RpcRequest.class); assertThat(log.rawRequestContent()).isInstanceOf(ThriftCall.class); final RpcRequest request = (RpcRequest) log.requestContent(); assertThat(request.serviceType()).isEqualTo(OnewayHelloService.Iface.class); assertThat(request.method()).isEqualTo("hello"); assertThat(request.params()).containsExactly("trustin"); final ThriftCall rawRequest = (ThriftCall) log.rawRequestContent(); assertThat(rawRequest.header().type).isEqualTo(TMessageType.ONEWAY); assertThat(rawRequest.header().name).isEqualTo("hello"); assertThat(rawRequest.args()).isInstanceOf(OnewayHelloService.hello_args.class); assertThat(((OnewayHelloService.hello_args) rawRequest.args()).getName()).isEqualTo("trustin"); assertThat(log.responseHeaders()).isInstanceOf(HttpHeaders.class); assertThat(log.responseContent()).isInstanceOf(RpcResponse.class); assertThat(log.rawResponseContent()).isNull(); final RpcResponse response = (RpcResponse) log.responseContent(); assertThat(response.get()).isNull(); }
@Test(timeout = 10000) public void testMessageLogsForException() throws Exception { final HelloService.Iface client = Clients.newClient(clientFactory(), getURI(Handlers.EXCEPTION), Handlers.EXCEPTION.iface(), clientOptions); recordMessageLogs = true; assertThatThrownBy(() -> client.hello("trustin")).isInstanceOf(TApplicationException.class); final RequestLog log = requestLogs.take(); assertThat(log.requestHeaders()).isInstanceOf(HttpHeaders.class); assertThat(log.requestContent()).isInstanceOf(RpcRequest.class); assertThat(log.rawRequestContent()).isInstanceOf(ThriftCall.class); final RpcRequest request = (RpcRequest) log.requestContent(); assertThat(request.serviceType()).isEqualTo(HelloService.Iface.class); assertThat(request.method()).isEqualTo("hello"); assertThat(request.params()).containsExactly("trustin"); final ThriftCall rawRequest = (ThriftCall) log.rawRequestContent(); assertThat(rawRequest.header().type).isEqualTo(TMessageType.CALL); assertThat(rawRequest.header().name).isEqualTo("hello"); assertThat(rawRequest.args()).isInstanceOf(HelloService.hello_args.class); assertThat(((HelloService.hello_args) rawRequest.args()).getName()).isEqualTo("trustin"); assertThat(log.responseHeaders()).isInstanceOf(HttpHeaders.class); assertThat(log.responseContent()).isInstanceOf(RpcResponse.class); assertThat(log.rawResponseContent()).isInstanceOf(ThriftReply.class); final RpcResponse response = (RpcResponse) log.responseContent(); assertThat(response.cause()).isNotNull(); final ThriftReply rawResponse = (ThriftReply) log.rawResponseContent(); assertThat(rawResponse.header().type).isEqualTo(TMessageType.EXCEPTION); assertThat(rawResponse.header().name).isEqualTo("hello"); assertThat(rawResponse.exception()).isNotNull(); }
assertThat(log.responseContent()).isInstanceOf(RpcResponse.class); assertThat(log.rawResponseContent()).isInstanceOf(ThriftReply.class); final RpcResponse response = (RpcResponse) log.responseContent(); assertThat(response.get()).isEqualTo("Hello, trustin!");
assertThat(log.responseContent()).isInstanceOf(RpcResponse.class); assertThat(log.rawResponseContent()).isInstanceOf(ThriftReply.class); final RpcResponse response = (RpcResponse) log.responseContent(); assertThat(response.cause()).isNotNull();
assertThat(log.responseContent()).isInstanceOf(RpcResponse.class); assertThat(log.rawResponseContent()).isInstanceOf(ThriftReply.class); final RpcResponse response = (RpcResponse) log.responseContent(); assertThat(response.get()).isEqualTo("Hello, Trustin!");
assertThat(log.availabilities()).contains(RequestLogAvailability.COMPLETE); assertThat(log.requestContent()).isNotNull(); assertThat(log.responseContent()).isNull(); final RpcRequest rpcReq = (RpcRequest) log.requestContent(); assertThat(rpcReq.method()).isEqualTo(
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 exportRpcResponse(Map<String, String> out, RequestLog log) { if (!log.isAvailable(RequestLogAvailability.RESPONSE_CONTENT)) { return; } final Object responseContent = log.responseContent(); if (responseContent instanceof RpcResponse) { final RpcResponse rpcRes = (RpcResponse) responseContent; if (builtIns.contains(RES_RPC_RESULT) && !rpcRes.isCompletedExceptionally()) { try { out.put(RES_RPC_RESULT.mdcKey, String.valueOf(rpcRes.get())); } catch (Exception e) { // Should never reach here because RpcResponse must be completed. throw new Error(e); } } } }
private void exportRpcResponse(Map<String, String> out, RequestLog log) { if (!log.isAvailable(RequestLogAvailability.RESPONSE_CONTENT)) { return; } final Object responseContent = log.responseContent(); if (responseContent instanceof RpcResponse) { final RpcResponse rpcRes = (RpcResponse) responseContent; if (builtIns.contains(RES_RPC_RESULT) && !rpcRes.isCompletedExceptionally()) { try { out.put(RES_RPC_RESULT.mdcKey, String.valueOf(rpcRes.get())); } catch (Exception e) { // Should never reach here because RpcResponse must be completed. throw new Error(e); } } } }