protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, System.Threading.CancellationToken cancellationToken) { using (var clientTrace = new ClientTrace(_serviceName, _getClientTraceRpc(request))) { if (clientTrace.Trace != null) { _injector.Inject(clientTrace.Trace.CurrentSpan, request.Headers); } var result = await clientTrace.TracedActionAsync(base.SendAsync(request, cancellationToken)).ConfigureAwait(false); if (clientTrace.Trace != null) { clientTrace.AddAnnotation(Annotations.Tag(zipkinCoreConstants.HTTP_PATH, result.RequestMessage.RequestUri.LocalPath)); clientTrace.AddAnnotation(Annotations.Tag(zipkinCoreConstants.HTTP_METHOD, result.RequestMessage.Method.Method)); if (_logHttpHost) { clientTrace.AddAnnotation(Annotations.Tag(zipkinCoreConstants.HTTP_HOST, result.RequestMessage.RequestUri.Host)); } if (!result.IsSuccessStatusCode) { clientTrace.AddAnnotation(Annotations.Tag(zipkinCoreConstants.HTTP_STATUS_CODE, ((int)result.StatusCode).ToString())); } } return(result); } }
public void HttpRequest(HttpRequestMessage request) { clientTrace = new ClientTrace(this._serviceName, request.Method.Method); if (clientTrace.Trace != null) { _injector.Inject(clientTrace.Trace.CurrentSpan, request.Headers); } }
public void ShouldNotSetCurrentTrace() { Trace.Current = null; using (var client = new ClientTrace(serviceName, rpc)) { Assert.IsNull(client.Trace); } }
public void ExceptionThrownInTracedActionAsyncShouldBeRethrownWhenCurrentTraceIsNull() { Trace.Current = null; var clientTrace = new ClientTrace(serviceName, rpc); Task <object> task = Task.Run <object>(() => throw new SomeException()); Assert.ThrowsAsync <SomeException>(() => clientTrace.TracedActionAsync(task)); }
protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, System.Threading.CancellationToken cancellationToken) { using (var clientTrace = new ClientTrace(_serviceName, request.Method.ToString())) { if (clientTrace.Trace != null) { _injector.Inject(clientTrace.Trace.CurrentSpan, request.Headers); } return(await clientTrace.TracedActionAsync(base.SendAsync(request, cancellationToken))); } }
public void ShouldCallChildWhenCurrentTraceNotNull() { var trace = Trace.Create(); Trace.Current = trace; using (var client = new ClientTrace(serviceName, rpc)) { Assert.AreEqual(trace.CurrentSpan.SpanId, client.Trace.CurrentSpan.ParentSpanId); Assert.AreEqual(trace.CurrentSpan.TraceId, client.Trace.CurrentSpan.TraceId); } }
/// <summary> /// B3SingleFormat Trace /// </summary> /// <returns></returns> public string GetTrace() { String parent = null; using (var clientTrace = new ClientTrace(_serviceName, null)) { if (clientTrace.Trace != null) { var b3Format = B3SingleFormat.WriteB3SingleFormat(clientTrace.Trace.CurrentSpan); parent = b3Format; } } return(parent); }
/// <summary> /// Invokes a server streaming call asynchronously. /// In server streaming scenario, client sends on request and server responds with a stream of responses. /// </summary> public override AsyncServerStreamingCall <TResponse> AsyncServerStreamingCall <TRequest, TResponse>(Method <TRequest, TResponse> method, string host, CallOptions options, TRequest request) { using (var clientTrace = new ClientTrace(_serviceName, "grpc")) { var trace = clientTrace.Trace; var channel = new Channel(_target, ChannelCredentials.Insecure); var call = CreateCall(channel, method, host, options, trace); try { var response = Calls.AsyncServerStreamingCall(call, request); return(response); } finally { channel.ShutdownAsync(); } } }
/// <summary> /// Invokes a simple remote call asynchronously. /// </summary> public override AsyncUnaryCall <TResponse> AsyncUnaryCall <TRequest, TResponse>(Method <TRequest, TResponse> method, string host, CallOptions options, TRequest request) { using (var clientTrace = new ClientTrace(_serviceName, "grpc")) { var trace = clientTrace.Trace; var channel = new Channel(_target, ChannelCredentials.Insecure); var call = CreateCall(channel, method, host, options, trace); try { trace.Record(Annotations.Tag("grpc.host", _target)); trace.Record(Annotations.Tag("grpc.request", JsonConvert.SerializeObject(request))); var response = Calls.AsyncUnaryCall(call, request); trace.Record(Annotations.Tag("grpc.response", JsonConvert.SerializeObject(response))); return(response); } finally { channel.ShutdownAsync(); } } }
public void ShouldLogClientAnnotations() { // Arrange dispatcher .Setup(h => h.Dispatch(It.IsAny <Record>())) .Returns(true); // Act var trace = Trace.Create(); trace.ForceSampled(); Trace.Current = trace; using (var client = new ClientTrace(serviceName, rpc)) { // Assert dispatcher .Verify(h => h.Dispatch(It.Is <Record>(m => m.Annotation is ClientSend))); dispatcher .Verify(h => h.Dispatch(It.Is <Record>(m => m.Annotation is ServiceName && ((ServiceName)m.Annotation).Service == serviceName))); dispatcher .Verify(h => h.Dispatch(It.Is <Record>(m => m.Annotation is Rpc && ((Rpc)m.Annotation).Name == rpc))); } // Assert dispatcher .Verify(h => h.Dispatch(It.Is <Record>(m => m.Annotation is ClientRecv))); }
public void ExceptionThrownInTracedActionAsyncShouldAddErrorTagAndRethrow() { var trace = Trace.Create(); trace.ForceSampled(); Trace.Current = trace; var clientTrace = new ClientTrace(serviceName, rpc); var ex = new Exception("something bad happened"); Task <int> task = Task.Run(() => { try { return(0); } finally { throw ex; } }); Assert.ThrowsAsync <Exception>(() => clientTrace.TracedActionAsync(task)); VerifyDispatcherRecordedAnnotation(new TagAnnotation("error", ex.Message)); }