@Override public void call( RequestT request, ResponseObserver<ResponseT> responseObserver, ApiCallContext context) { ApiTracer tracer = tracerFactory.newTracer(spanName); TracedResponseObserver<ResponseT> tracedObserver = new TracedResponseObserver<>(tracer, responseObserver); context = context.withTracer(tracer); try { innerCallable.call(request, tracedObserver, context); } catch (RuntimeException e) { tracedObserver.onError(e); throw e; } } }
/** * Calls the wrapped {@link UnaryCallable} within the context of a new trace. * * @param request the request to send. * @param context {@link ApiCallContext} to make the call with. */ @Override public ApiFuture<ResponseT> futureCall(RequestT request, ApiCallContext context) { ApiTracer tracer = tracerFactory.newTracer(spanName); TraceFinisher<ResponseT> finisher = new TraceFinisher<>(tracer); try { context = context.withTracer(tracer); ApiFuture<ResponseT> future = innerCallable.futureCall(request, context); ApiFutures.addCallback(future, finisher, MoreExecutors.directExecutor()); return future; } catch (RuntimeException e) { finisher.onFailure(e); throw e; } } }
/** * Calls the wrapped {@link UnaryCallable} within the context of a new trace. * * @param request the request to send. * @param context {@link ApiCallContext} to make the call with. */ @Override public ApiFuture<ResponseT> futureCall(RequestT request, ApiCallContext context) { ApiTracer tracer = tracerFactory.newTracer(spanName); TraceFinisher<ResponseT> finisher = new TraceFinisher<>(tracer); try { context = context.withTracer(tracer); ApiFuture<ResponseT> future = innerCallable.futureCall(request, context); ApiFutures.addCallback(future, finisher, MoreExecutors.directExecutor()); return future; } catch (RuntimeException e) { finisher.onFailure(e); throw e; } } }
@Override public ClientStream<RequestT> internalCall( ResponseObserver<ResponseT> responseObserver, ClientStreamReadyObserver<RequestT> onReady, ApiCallContext context) { ApiTracer tracer = tracerFactory.newTracer(spanName); context = context.withTracer(tracer); AtomicBoolean wasCancelled = new AtomicBoolean(); ResponseObserver<ResponseT> tracedObserver = new TracedResponseObserver<>(tracer, responseObserver, wasCancelled); ClientStreamReadyObserver<RequestT> tracedReadyObserver = new TracedClientStreamReadyObserver<>(tracer, onReady, wasCancelled); try { ClientStream<RequestT> clientStream = innerCallable.internalCall(tracedObserver, tracedReadyObserver, context); return new TracingClientStream<>(tracer, clientStream, wasCancelled); } catch (RuntimeException e) { tracer.operationFailed(e); throw e; } }
@Override public ApiFuture<ResponseT> futureCall(RequestT request, ApiCallContext context) { // NOTE: This will be invoked asynchronously outside of the original caller's thread. // So this start a top level tracer. ApiTracer tracer = tracerFactory.newRootTracer(spanName); TraceFinisher<ResponseT> finisher = new TraceFinisher<>(tracer); try { long elementCount = batchingDescriptor.countElements(request); long requestSize = batchingDescriptor.countBytes(request); tracer.batchRequestSent(elementCount, requestSize); context = context.withTracer(tracer); ApiFuture<ResponseT> future = innerCallable.futureCall(request, context); ApiFutures.addCallback(future, finisher, MoreExecutors.directExecutor()); return future; } catch (RuntimeException e) { finisher.onFailure(e); throw e; } } }