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