How to use

withTracer

method

in

com.google.api.gax.rpc.ApiCallContext

 @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;
  }
 }
}