How to use brave.grpc

public Builder toBuilder() {
 return new Builder(tracing)
   .clientParser(clientParser)
   .serverParser(serverParser);
}

 /** This interceptor traces inbound calls */
 public ServerInterceptor newServerInterceptor() {
  return new TracingServerInterceptor(this);
 }
}

String readLengthPrefixed() {
 byte b1 = buf[pos++];
 if (b1 >= 0) { // negative means MSB set
  return readAsciiString(b1);
 }
 return readAsciiString(readVarint(b1));
}

/**
 * Add brave's client interceptor to the builder.
 */
@Override
public void customize(ManagedChannelBuilder<?> managedChannelBuilder) {
  managedChannelBuilder.intercept(this.grpcTracing.newClientInterceptor());
}

 @Override public void inject(TraceContext traceContext, C carrier) {
  if (carrier instanceof Metadata) {
   byte[] serialized = TraceContextBinaryFormat.toBytes(traceContext);
   ((Metadata) carrier).put(GRPC_TRACE_BIN, serialized);
   Tags tags = traceContext.findExtra(Tags.class);
   if (tags != null) ((Metadata) carrier).put(GRPC_TAGS_BIN, tags.toMap());
  }
  delegate.inject(traceContext, carrier);
 }
}

public static GrpcTracing create(Tracing tracing) {
 if (tracing == null) throw new NullPointerException("tracing == null");
 return new Builder(tracing).build();
}

@Benchmark public TraceContext parseBytes() {
 return TraceContextBinaryFormat.parseBytes(serialized, null);
}

 @Override protected Tags create(Tags parent) {
  return new Tags(parent);
 }
}

/** This interceptor traces outbound calls */
public final ClientInterceptor newClientInterceptor() {
 return new TracingClientInterceptor(this);
}

 public GrpcTracing build() {
  return new GrpcTracing(this);
 }
}

@Override public <C> Injector<C> injector(Setter<C, K> setter) {
 return new GrpcInjector<>(this, setter);
}

public static Builder newBuilder(Tracing tracing) {
 return new Builder(tracing);
}

@Override public <C> Extractor<C> extractor(Getter<C, K> getter) {
 return new GrpcExtractor<>(this, getter);
}

@Override public final <K> Propagation<K> create(KeyFactory<K> keyFactory) {
 return new GrpcPropagation<>(this, keyFactory);
}

 String readAsciiString(int length) {
  if (length == -1 || remaining() < length) return null;
  char[] string = new char[length];
  for (int i = 0; i < length; i++) {
   string[i] = (char) buf[pos++];
  }
  return new String(string);
 }
}

static Propagation.Factory newFactory(Propagation.Factory delegate) {
 if (delegate == null) throw new NullPointerException("delegate == null");
 return new Factory(delegate);
}

 /** Override the customize the span based on the start of a request. */
 protected <ReqT, RespT> void onStart(MethodDescriptor<ReqT, RespT> method, CallOptions options,
   Metadata headers, SpanCustomizer span) {
  span.name(spanName(method));
 }
}

 @Override public TraceContext decorate(TraceContext context) {
  TraceContext result = delegate.decorate(context);
  return tagsFactory.decorate(result);
 }
}

@Override protected Tags create() {
 return new Tags();
}

static Tags extractTags(Map<String, String> extracted) {
 if (extracted == null) return null;
 // Remove the incoming RPC method as we should replace it with our current server method.
 String parentMethod = extracted.remove(RPC_METHOD);
 return new Tags(extracted, parentMethod);
}