public void InnerHandler_Set()
{
var mockTracer = new Mock <IManagedTracer>();
var traceHandler = new TraceHeaderPropagatingHandler(() => mockTracer.Object);
Assert.NotNull(traceHandler.InnerHandler);
}
public void InnerHandler_Set()
{
#pragma warning disable CS0618 // Type or member is obsolete
var traceHandler = new TraceHeaderPropagatingHandler(() => new FakeManagedTracer(null, null));
#pragma warning restore CS0618 // Type or member is obsolete
Assert.NotNull(traceHandler.InnerHandler);
}
// End sample
// Sample: TraceOutgoing
/// <summary>
/// Add a handler to trace outgoing requests and to propagate the trace header.
/// The <see cref="TraceHeaderPropagatingHandler"/> is populated by dependency injection
/// thanks to the use of the <see cref="FromServicesAttribute"/> attribute.
/// </summary>
public async Task <HttpResponseMessage> TraceOutgoing([FromServices] TraceHeaderPropagatingHandler traceHeaderHandler)
{
using (var httpClient = new HttpClient(traceHeaderHandler))
{
// Any code that makes outgoing requests.
return(await httpClient.GetAsync("https://weather.com/"));
}
}
// End sample
// Sample: TraceOutgoing
/// <summary>
/// The <see cref="TraceHeaderPropagatingHandler"/> is populated by dependency injection.
/// </summary>
public async Task <HttpResponseMessage> TraceOutgoing(TraceHeaderPropagatingHandler traceHeaderHandler)
{
// Add a handler to trace outgoing requests and to propagate the trace header.
using (var httpClient = new HttpClient(traceHeaderHandler))
{
return(await httpClient.GetAsync("https://weather.com/"));
}
}
// This incoming HTTP request should be captured by Trace.
public IActionResult Index([FromServices] IManagedTracer tracer)
{
using (tracer.StartSpan(nameof(Index)))
{
var traceHeaderHandler = new TraceHeaderPropagatingHandler(() => tracer);
var response = TraceOutgoing(traceHeaderHandler);
ViewData["text"] = response.Result.ToString();
return(View());
}
}
// Sample: TraceOutgoing
public async Task <HttpResponseMessage> TraceOutgoing(IManagedTracer tracer)
{
// Add a handler to trace outgoing requests and to propagate the trace header.
var traceHeaderHandler = TraceHeaderPropagatingHandler.Create(tracer);
using (var httpClient = HttpClientFactory.Create(traceHeaderHandler))
{
return(await httpClient.GetAsync("https://weather.com/"));
}
}
// This outgoing HTTP request should be captured by Trace.
public async Task <string> TraceOutgoing(TraceHeaderPropagatingHandler traceHeaderHandler)
{
// Add a handler to trace outgoing requests and to propagate the trace header.
using (var httpClient = new HttpClient(traceHeaderHandler))
{
string url = "https://www.googleapis.com/discovery/v1/apis";
using (var response = await httpClient.GetAsync(url))
{
return(await response.Content.ReadAsStringAsync());
}
}
}
public async Task <HttpResponseMessage> TraceOutgoing()
{
// Sample: TraceOutgoing
// Add a handler to trace outgoing requests and to propagate the trace header.
var traceHeaderHandler = TraceHeaderPropagatingHandler.Create(CloudTrace.CurrentTracer);
using (var httpClient = new HttpClient(traceHeaderHandler))
{
return(await httpClient.GetAsync("https://weather.com/"));
}
// End sample
}
public async Task SendAsync_NoTrace()
{
var mockTracer = new Mock <IManagedTracer>();
var fakeHandler = new FakeDelegatingHandler();
var traceHandler = new TraceHeaderPropagatingHandler(() => mockTracer.Object, fakeHandler);
using (var httpClient = new HttpClient(traceHandler))
{
await httpClient.GetAsync("https://www.google.com");
}
mockTracer.Verify(t => t.StartSpan(It.IsAny <string>(), null), Times.Never());
}
public async Task SendAsync_NoTrace()
{
var managedTracer = new FakeManagedTracer(null, null);
var traceHandler = new TraceHeaderPropagatingHandler(() => managedTracer, new BounceBackRequestHandler());
using var httpClient = new HttpClient(traceHandler);
var response = await httpClient.GetAsync("https://www.google.com");
AssertDoesNotContainGoogleTraceHeader(response.RequestMessage);
AssertDoesNotContainTraceProperties(response.RequestMessage);
managedTracer.AssertNoRanInSpan();
}
public async Task SendAsync_Trace_Default()
{
var managedTracer = new FakeManagedTracer(TraceId, SpanId);
var traceHandler = new TraceHeaderPropagatingHandler(() => managedTracer, new BounceBackRequestHandler());
var url = "https://www.google.com/";
using var httpClient = new HttpClient(traceHandler);
var response = await httpClient.GetAsync(url);
AssertContainsGoogleTraceHeader(response.RequestMessage);
AssertDoesNotContainTraceProperties(response.RequestMessage);
managedTracer.AssertSingleRanInSpan(url);
}
public async Task SendAsync_Trace()
{
var mockTracer = GetSetUpTracer();
var fakeHandler = new FakeDelegatingHandler(headerContext);
var traceHandler = TraceHeaderPropagatingHandler.Create(mockTracer.Object, fakeHandler);
var requestUri = new Uri("https://www.google.com");
using (var httpClient = new HttpClient(traceHandler))
{
await httpClient.GetAsync(requestUri);
}
mockTracer.Verify(t => t.StartSpan(requestUri.ToString(), null), Times.Once());
mockTracer.Verify(t => t.EndSpan(), Times.Once());
}
public async Task SendAsync_TraceException()
{
var mockTracer = GetSetUpTracer();
var fakeHandler = new FakeDelegatingHandler(headerContext, throwException: true);
var traceHandler = TraceHeaderPropagatingHandler.Create(mockTracer.Object, fakeHandler);
var requestUri = new Uri("https://www.google.com");
using (var httpClient = new HttpClient(traceHandler))
{
await Assert.ThrowsAsync <DivideByZeroException>(() => httpClient.GetAsync(requestUri));
}
mockTracer.Verify(t => t.StartSpan(requestUri.ToString(), null), Times.Once());
mockTracer.Verify(t => t.SetStackTrace(It.IsAny <StackTrace>()), Times.Once());
mockTracer.Verify(t => t.EndSpan(), Times.Once());
}
/// <summary>
/// Creates a <see cref="TraceHeaderPropagatingHandler"/> and traces the sending of a
/// GET request to the given Uri. The trace is wrapped in a parent span.
/// </summary>
/// <param name="rootSpanName">The name of the root span that will wrap the span
/// that traces the request.</param>
/// <param name="uri">The Uri to request.</param>
/// <param name="exceptionExpected">True if an exception from the request to the Uri is expected.</param>
private async Task TraceOutGoingRequest(string rootSpanName, string uri, bool exceptionExpected)
{
using (_tracer.StartSpan(rootSpanName))
using (var traceHeaderHandler = new TraceHeaderPropagatingHandler(() => _tracer))
using (var httpClient = new HttpClient(traceHeaderHandler))
{
try
{
await httpClient.GetAsync(uri);
Assert.False(exceptionExpected);
}
catch (Exception e) when(exceptionExpected && !(e is Xunit.Sdk.XunitException))
{
}
}
}
public async Task SendAsync_Trace_Custom()
{
var managedTracer = new FakeManagedTracer(TraceId, SpanId);
#pragma warning disable CS0618 // Type or member is obsolete
var traceHandler = new TraceHeaderPropagatingHandler(
#pragma warning restore CS0618 // Type or member is obsolete
() => managedTracer, SetOutgoingHttpTraceContext, new BounceBackRequestHandler());
var url = "https://www.google.com/";
using var httpClient = new HttpClient(traceHandler);
var response = await httpClient.GetAsync(url);
AssertContainsTraceProperties(response.RequestMessage);
AssertDoesNotContainGoogleTraceHeader(response.RequestMessage);
managedTracer.AssertSingleRanInSpan(url);
}
public async Task SendAsync_Trace()
{
var mockTracer = GetSetUpTracer();
var fakeHandler = new FakeDelegatingHandler(headerContext);
var traceHandler = new TraceHeaderPropagatingHandler(() => mockTracer.Object, fakeHandler);
var requestUri = new Uri("https://www.google.com");
var requestUriString = requestUri.ToString();
mockTracer.Setup(t => t.RunInSpanAsync(
It.IsAny <Func <Task <HttpResponseMessage> > >(), requestUri.ToString(), null))
.Returns(Task.FromResult(new HttpResponseMessage()));
using (var httpClient = new HttpClient(traceHandler))
{
await httpClient.GetAsync(requestUri);
}
mockTracer.VerifyAll();
}
public async Task <IActionResult> PostAsync(
[FromBody] WeatherForecastModel model,
CancellationToken cancellationToken)
{
using (_tracer.StartSpan("save"))
{
try
{
//These two lines are for example
var traceHeaderHandler = new TraceHeaderPropagatingHandler(() => _tracer);
var response = TraceOutgoing(traceHeaderHandler);
await _storageLogic.SaveToFileAsync(model, cancellationToken);
return(Ok());
}
catch (Exception e)
{
_logger.LogError(e, "Service Error, attention!!!!");
return(StatusCode(StatusCodes.Status500InternalServerError,
e.Message));
}
}
}
public async Task <string> TraceOutgoing(string id, [FromServices] IManagedTracer tracer, [FromServices] TraceHeaderPropagatingHandler propagatingHandler)
{
string message = EntryData.GetMessage(nameof(TraceOutgoing), id);
using (tracer.StartSpan(message))
using (var httpClient = new HttpClient(propagatingHandler))
{
await httpClient.GetAsync("https://google.com/");
}
return(message);
}
public PropagationController([FromServices] IManagedTracer tracer, [FromServices] TraceHeaderPropagatingHandler propagatingHandler)
{
_tracer = tracer;
_propagatingHandler = propagatingHandler;
}
public void InnerHandler_Set()
{
var traceHandler = new TraceHeaderPropagatingHandler(() => new FakeManagedTracer(null, null));
Assert.NotNull(traceHandler.InnerHandler);
}
