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