Spring Boot + grpc logging + correlation id? - spring-boot

Question

I've got a Spring Boot app. Its a standard http rest api. I'm adding a grpc host inside of it to provide a parallel grpc experience. That part is all working fine. One of my requirements is request / response logging.
I've got a ServerInterceptor, a SimpleForwardingServerCall wrapper and a SimpleForwardingServerCallListener wrapper to trap all the places I need to log (success & failure calls).
I need to get the request body from onMessage and the status code from 2 places (one for fail, one for success) and then the elapsed time.
So long question short, I'm not sure how the threading model works in grpc, where can I store this information on a per request basis so by the time I get to onComplete() which has no params, I can access it?
I'm doing something like:
return new xxxServerCallListener<>(next.startCall(new xxxServerCall<>(call), headers), call);
So I assume a new xxxServerCallListener and xxxServerCall get created for each request and I can store stuff in there as it moves through the pipeline? Would that be the best place to store?

Answer 1

Yes, construct your own ServerCall.Listener per-RPC and store the information there.
#Override
public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
ServerCall<ReqT, RespT> call,
final Metadata headers,
ServerCallHandler<ReqT, RespT> next) {
// resp could be stored in the call class, but then it would need to be
// a named class which is more boilerplate. AtomicReference is
// convenient.
final AtomicReference<RespT> resp = new AtomicReference<>();
call = new SimpleForwardingServerCall<ReqT, RespT>(call) {
#Override public void sendMessage(RespT message) {
// We assume we're getting immutable protobufs or something similar
// that doesn't mutate. Otherwise we'd need to copy it here.
resp.set(message);
super.sendMessage(message);
}
};
return new SimpleForwardingServerCallListener<ReqT>(next.startCall(call, headers)) {
private ReqT req;
#Override public void onMessage(ReqT message) {
this.req = message;
super.onMessage(message);
}
#Override public void onCancel() {
// No point in using 'resp' as the client probably didn't use it.
// Note that sendMessage() has likely not been called so 'resp' is
// frequently null. If referencing 'resp' here, synchronizing (like
// that provided by AtomicReference) is necessary.
log(req);
super.onCancel();
}
#Override public void onComplete() {
// For properly-behaving callers (those that do not invoke
// call.sendMessage() after call.close()), this actually doesn't
// need to be synchronized as call.close() (and thus any
// sendMessage()) is guaranteed to have been called by this point.
log(req, resp.get());
super.onComplete();
}
};
}