public async Task Trace_Header() { string traceId = _traceIdFactory.NextId(); ulong spanId = _spanIdFactory.NextId(); var uri = $"/Trace/{nameof(TraceController.Trace)}/{_testId}"; var childSpanName = EntryData.GetMessage(nameof(TraceController.Trace), _testId); using (var server = new TestServer(new WebHostBuilder().UseStartup <TraceTestNoBufferLowQpsApplication>())) using (var client = server.CreateClient()) { var header = TraceHeaderContext.Create(traceId, spanId, shouldTrace: true); client.DefaultRequestHeaders.Add(TraceHeaderContext.TraceHeader, header.ToString()); var response = await client.GetAsync(uri); var trace = _polling.GetTrace(uri, _startTime); TraceEntryVerifiers.AssertParentChildSpan(trace, uri, childSpanName); Assert.Equal(traceId, trace.TraceId); var parentSpan = trace.Spans.First(s => s.Name == uri); Assert.Equal(spanId, parentSpan.ParentSpanId); Assert.True(response.Headers.Contains(TraceHeaderContext.TraceHeader)); var returnedHeader = response.Headers.GetValues(TraceHeaderContext.TraceHeader).Single(); var headerContext = TraceHeaderContext.FromHeader(returnedHeader); Assert.Equal(traceId, headerContext.TraceId); Assert.Equal(spanId, headerContext.SpanId); Assert.True(headerContext.ShouldTrace); } }
public async Task Trace_Header( Action <IWebHostBuilder> testServerConfigurator, Action <HttpRequestHeaders, string, ulong?, bool?> traceContextEmitter, Action <HttpResponseMessage, string, ulong?, bool?> assertTraceContext) { string traceId = _traceIdFactory.NextId(); ulong spanId = _spanIdFactory.NextId(); var uri = $"/Trace/{nameof(TraceController.Trace)}/{_testId}"; var childSpanName = EntryData.GetMessage(nameof(TraceController.Trace), _testId); using var server = GetTestServer <TraceTestNoBufferLowQpsApplication>(testServerConfigurator); using var client = server.CreateClient(); traceContextEmitter(client.DefaultRequestHeaders, traceId, spanId, true); var response = await client.GetAsync(uri); var trace = _polling.GetTrace(uri, _startTime); TraceEntryVerifiers.AssertParentChildSpan(trace, uri, childSpanName); Assert.Equal(traceId, trace.TraceId); var parentSpan = trace.Spans.First(s => s.Name == uri); Assert.Equal(spanId, parentSpan.ParentSpanId); assertTraceContext(response, traceId, spanId, true); }
public async Task Traces_Outgoing() { var uri = $"/TraceSamples/{nameof(TraceSamplesController.TraceOutgoing)}/{_testId}"; var response = await _client.GetAsync(uri); var trace = s_polling.GetTrace(uri, _startTime); TraceEntryVerifiers.AssertParentChildSpan(trace, uri, "https://weather.com/"); TraceEntryVerifiers.AssertSpanLabelsContains( trace.Spans.First(s => s.Name == uri), TraceEntryData.HttpGetSuccessLabels); Assert.False(response.Headers.Contains(TraceHeaderContext.TraceHeader)); }
public async Task Traces_Block() { var uri = $"/TraceSamples/{nameof(TraceSamplesController.TraceHelloWorld)}/{_testId}"; var response = await _client.GetAsync(uri); var trace = s_tracePolling.GetTrace(uri, Timestamp.FromDateTime(_startTime)); TraceEntryVerifiers.AssertParentChildSpan(trace, uri, _testId); TraceEntryVerifiers.AssertSpanLabelsContains( trace.Spans.First(s => s.Name == uri), TraceEntryData.HttpGetSuccessLabels); Assert.False(response.Headers.Contains(TraceHeaderContext.TraceHeader)); }
public async Task Traces_MethodInjection() { var uri = $"/TraceSamplesMethod/{nameof(TraceSamplesMethodController.TraceHelloWorld)}/{_testId}"; var response = await _client.GetAsync(uri); var trace = TraceEntryPolling.Default.GetTrace(uri, _startTime); TraceEntryVerifiers.AssertParentChildSpan(trace, uri, _testId); TraceEntryVerifiers.AssertSpanLabelsContains( trace.Spans.First(s => s.Name == uri), TraceEntryData.HttpGetSuccessLabels); Assert.False(response.Headers.Contains(TraceHeaderContext.TraceHeader)); }
public async Task Traces_Outgoing() { Skip.If(TestEnvironment.IsWindows(), "https://github.com/googleapis/google-cloud-dotnet/issues/5425"); var uri = $"/TraceSamples/{nameof(TraceSamplesController.TraceOutgoing)}/{_testId}"; var response = await _client.GetAsync(uri); var trace = s_polling.GetTrace(uri, _startTime); TraceEntryVerifiers.AssertParentChildSpan(trace, uri, "https://weather.com/"); TraceEntryVerifiers.AssertSpanLabelsContains( trace.Spans.First(s => s.Name == uri), TraceEntryData.HttpGetSuccessLabels); Assert.False(response.Headers.Contains(TraceHeaderContext.TraceHeader)); }
public async Task Trace_OutGoing(string methodName) { var uri = $"/Trace/{methodName}/{_testId}"; var childSpanName = EntryData.GetMessage(methodName, _testId); var outgoingSpanName = "https://google.com/"; using var server = GetTestServer <TraceTestNoBufferHighQpsApplication>(); using var client = server.CreateClient(); await client.GetAsync(uri); var trace = _polling.GetTrace(uri, _startTime); TraceEntryVerifiers.AssertParentChildSpan(trace, uri, childSpanName, outgoingSpanName); }
public async Task Trace_OutGoingClientFactory(Action <IWebHostBuilder> testServerConfigurator) { var uri = $"/Trace/{nameof(TraceController.TraceOutgoingClientFactory)}/{_testId}"; var childSpanName = EntryData.GetMessage(nameof(TraceController.TraceOutgoingClientFactory), _testId); var outgoingSpanName = "https://google.com/"; using var server = GetTestServer <TraceTestNoBufferHighQpsApplication>(testServerConfigurator); using var client = server.CreateClient(); await client.GetAsync(uri); var trace = _polling.GetTrace(uri, _startTime); TraceEntryVerifiers.AssertParentChildSpan(trace, uri, childSpanName, outgoingSpanName); }
public async Task Traces_OutgoingClientFactory() { var uri = $"/TraceSamples/{nameof(TraceSamplesController.TraceOutgoingClientFactory)}/{_testId}"; using var server = GetTestServer <TraceClientFactoryTestApplication.Startup>(); using var client = server.CreateClient(); var response = await client.GetAsync(uri); var trace = s_polling.GetTrace(uri, _startTime); TraceEntryVerifiers.AssertParentChildSpan(trace, uri, "http://weather.com/"); TraceEntryVerifiers.AssertSpanLabelsContains( trace.Spans.First(s => s.Name == uri), TraceEntryData.HttpGetSuccessLabels); Assert.False(response.Headers.Contains(TraceHeaderContext.TraceHeader)); }
public async Task Trace_Exception(Action <IWebHostBuilder> testServerConfigurator) { var uri = $"/Trace/{nameof(TraceController.ThrowException)}/{_testId}"; var childSpanName = EntryData.GetMessage(nameof(TraceController.ThrowException), _testId); using var server = GetTestServer <TraceTestNoBufferHighQpsApplication>(testServerConfigurator); using var client = server.CreateClient(); await Assert.ThrowsAnyAsync <Exception>(() => client.GetAsync(uri)); var trace = _polling.GetTrace(uri, _startTime); TraceEntryVerifiers.AssertParentChildSpan(trace, uri, childSpanName); TraceEntryVerifiers.AssertContainsStackTrace(trace.Spans.First(s => s.Name == uri), nameof(TraceController), nameof(TraceController.ThrowException)); }
private static async Task TestTrace(string testId, DateTimeOffset startTime, HttpClient client) { var uri = $"/Trace/{nameof(TraceController.Trace)}/{testId}"; var childSpanName = EntryData.GetMessage(nameof(TraceController.Trace), testId); var response = await client.GetAsync(uri); var trace = TraceEntryPolling.Default.GetTrace(uri, startTime); TraceEntryVerifiers.AssertParentChildSpan(trace, uri, childSpanName); TraceEntryVerifiers.AssertSpanLabelsContains( trace.Spans.First(s => s.Name == uri), TraceEntryData.HttpGetSuccessLabels); Assert.False(response.Headers.Contains(TraceHeaderContext.TraceHeader)); }
public async Task Trace_OutGoing() { // We don't test custom trace context with TraceHeaderPropagatingHandler because it's // pre IHttpClientFactory and has associated lifetime issues. var uri = $"/Trace/{nameof(TraceController.TraceOutgoing)}/{_testId}"; var childSpanName = EntryData.GetMessage(nameof(TraceController.TraceOutgoing), _testId); var outgoingSpanName = "https://google.com/"; using var server = GetTestServer <TraceTestNoBufferHighQpsApplication>(); using var client = server.CreateClient(); await client.GetAsync(uri); var trace = _polling.GetTrace(uri, _startTime); TraceEntryVerifiers.AssertParentChildSpan(trace, uri, childSpanName, outgoingSpanName); }
public async Task Trace_WebServerHosted_Outgoing() { var service = $"/api/Trace/TraceOutgoing/{_testId}"; var childSpanName = EntryData.GetMessage("TraceOutgoing", _testId); var outgoingSpanName = "https://google.com/"; using (HttpClient httpClient = new HttpClient()) { httpClient.BaseAddress = PublishedServiceBaseAddress; await httpClient.GetAsync(service); } var trace = _polling.GetTrace(service, _startTime); TraceEntryVerifiers.AssertParentChildSpan(trace, service, childSpanName, outgoingSpanName); }
public async Task Trace_StackTrace() { var uri = $"/Trace/{nameof(TraceController.TraceStackTrace)}/{_testId}"; var childSpanName = EntryData.GetMessage(nameof(TraceController.TraceStackTrace), _testId); using var server = GetTestServer <TraceTestNoBufferHighQpsApplication>(); using var client = server.CreateClient(); await client.GetAsync(uri); var trace = _polling.GetTrace(uri, _startTime); TraceEntryVerifiers.AssertParentChildSpan(trace, uri, childSpanName); TraceEntryVerifiers.AssertContainsStackTrace(trace.Spans.First(s => s.Name == childSpanName), nameof(TraceController), nameof(TraceController.TraceStackTrace), nameof(TraceEntryData), nameof(TraceEntryData.CreateStackTrace)); }
public async Task TraceIncomingAsync() { IHost host = null; // Hides that we use different classes so that we can have multiple CreateHostBuilder methods. Func <IHostBuilder> CreateHostBuilder = DefaultHostBuilder.CreateHostBuilder; try { // Sample: Start host = CreateHostBuilder().Build(); await host.StartAsync(); // End sample object request = null; // Sample: IncomingContext ITraceContext traceContext = GetTraceContextFromIncomingRequest(request); var tracerFactory = host.Services.GetRequiredService <Func <ITraceContext, IManagedTracer> >(); IManagedTracer tracer = tracerFactory(traceContext); ContextTracerManager.SetCurrentTracer(tracer); // End sample // Let's just start a span with the test ID so we can find it faster. // But we don't show this in sample code. using (tracer.StartSpan(_testId)) { // Sample: Trace IManagedTracer currentTracer = host.Services.GetRequiredService <IManagedTracer>(); using (currentTracer.StartSpan("testing_tracing")) { Console.WriteLine("Using Cloud Trace from a non ASP.NET Core app"); } // End sample } var trace = TraceEntryPolling.Default.GetTrace(_testId, _startTime); TraceEntryVerifiers.AssertParentChildSpan(trace, _testId, "testing_tracing"); Assert.Equal(traceContext.TraceId, trace.TraceId); } finally { if (host is object) { await host.StopAsync(); } } }
public async Task Trace(Action <IWebHostBuilder> testServerConfigurator) { var uri = $"/Trace/{nameof(TraceController.Trace)}/{_testId}"; var childSpanName = EntryData.GetMessage(nameof(TraceController.Trace), _testId); using var server = GetTestServer <TraceTestNoBufferHighQpsApplication>(testServerConfigurator); using var client = server.CreateClient(); var response = await client.GetAsync(uri); var trace = _polling.GetTrace(uri, _startTime); TraceEntryVerifiers.AssertParentChildSpan(trace, uri, childSpanName); TraceEntryVerifiers.AssertSpanLabelsContains( trace.Spans.First(s => s.Name == uri), TraceEntryData.HttpGetSuccessLabels); AssertNoTraceHeaders(response); }
public async Task TraceAsync() { // Naming it like an instance variable so that it looks like that on sample code. IHost _host = null; try { // Sample: Start _host = CreateHostBuilder().Build(); await _host.StartAsync(); // End sample // Sample: IncomingContext ITraceContext traceContext = GetTraceContextFromIncomingRequest(); var tracerFactory = _host.Services.GetRequiredService <Func <ITraceContext, IManagedTracer> >(); IManagedTracer tracer = tracerFactory(traceContext); ContextTracerManager.SetCurrentTracer(tracer); // End sample // Let's just start a span with the test ID so we can find it faster. // But we don't show this in sample code. using (tracer.StartSpan(_testId)) { // Sample: Trace IManagedTracer currentTracer = _host.Services.GetRequiredService <IManagedTracer>(); using (currentTracer.StartSpan("standalone_tracing")) { Console.WriteLine("Using Cloud Trace from a non ASP.NET Core app"); } // End sample } var trace = s_polling.GetTrace(_testId, _startTime); TraceEntryVerifiers.AssertParentChildSpan(trace, _testId, "standalone_tracing"); Assert.Equal(traceContext.TraceId, trace.TraceId); } finally { if (_host != null) { await _host.StopAsync(); } } }
public async Task Trace_Label(Action <IWebHostBuilder> testServerConfigurator) { var uri = $"/Trace/{nameof(TraceController.TraceLabels)}/{_testId}"; var childSpanName = EntryData.GetMessage(nameof(TraceController.TraceLabels), _testId); using var server = GetTestServer <TraceTestNoBufferHighQpsApplication>(testServerConfigurator); using var client = server.CreateClient(); await client.GetAsync(uri); var trace = _polling.GetTrace(uri, _startTime); TraceEntryVerifiers.AssertParentChildSpan(trace, uri, childSpanName); TraceEntryVerifiers.AssertSpanLabelsContains(trace.Spans.First(s => s.Name == childSpanName), new Dictionary <string, string> { { TraceEntryData.TraceLabel, TraceEntryData.TraceLabelValue } }); }
public async Task Trace_WebServerHosted_StackTrace() { var service = $"/api/Trace/TraceStackTrace/{_testId}"; var childSpanName = EntryData.GetMessage("TraceStackTrace", _testId); using (HttpClient httpClient = new HttpClient()) { httpClient.BaseAddress = PublishedServiceBaseAddress; await httpClient.GetAsync(service); } var trace = _polling.GetTrace(service, _startTime); TraceEntryVerifiers.AssertParentChildSpan(trace, service, childSpanName); TraceEntryVerifiers.AssertContainsStackTrace(trace.Spans.First(s => s.Name == childSpanName), "TraceController", "TraceStackTrace", nameof(TraceEntryData), nameof(TraceEntryData.CreateStackTrace)); }
public async Task Trace_DummyNameProvider(Action <IWebHostBuilder> testServerConfigurator) { var uri = $"/Trace/{nameof(TraceController.Trace)}/{_testId}"; // our dummy provider prefixes with /Dummy var expectedTraceName = $"/Dummy{uri}"; var childSpanName = EntryData.GetMessage(nameof(TraceController.Trace), _testId); using var server = GetTestServer <TraceTestCustomNameProviderNoBufferHighQpsApplication>(testServerConfigurator); using var client = server.CreateClient(); var response = await client.GetAsync(uri); var trace = _polling.GetTrace(expectedTraceName, _startTime); TraceEntryVerifiers.AssertParentChildSpan(trace, expectedTraceName, childSpanName); TraceEntryVerifiers.AssertSpanLabelsContains( trace.Spans.First(s => s.Name == expectedTraceName), TraceEntryData.HttpGetSuccessLabels); AssertNoTraceHeaders(response); }
public async Task Trace() { var uri = $"/Trace/{nameof(TraceController.Trace)}/{_testId}"; var childSpanName = EntryData.GetMessage(nameof(TraceController.Trace), _testId); using (var server = new TestServer(new WebHostBuilder().UseStartup <TraceTestNoBufferHighQpsApplication>())) using (var client = server.CreateClient()) { var response = await client.GetAsync(uri); var trace = _polling.GetTrace(uri, _startTime); TraceEntryVerifiers.AssertParentChildSpan(trace, uri, childSpanName); TraceEntryVerifiers.AssertSpanLabelsContains( trace.Spans.First(s => s.Name == uri), TraceEntryData.HttpGetSuccessLabels); Assert.False(response.Headers.Contains(TraceHeaderContext.TraceHeader)); } }
private static async Task TestTrace(string testId, DateTime startTime, HttpClient client) { var uri = $"/Trace/{nameof(TraceController.Trace)}/{testId}"; var childSpanName = EntryData.GetMessage(nameof(TraceController.Trace), testId); var response = await client.GetAsync(uri); // Give the polling a little extra time to find the trace as // trace processing can sometimes take time and the default buffer is a // timed buffer. var polling = new TraceEntryPolling(TimeSpan.FromSeconds(20)); var trace = polling.GetTrace(uri, Timestamp.FromDateTime(startTime)); TraceEntryVerifiers.AssertParentChildSpan(trace, uri, childSpanName); TraceEntryVerifiers.AssertSpanLabelsContains( trace.Spans.First(s => s.Name == uri), TraceEntryData.HttpGetSuccessLabels); Assert.False(response.Headers.Contains(TraceHeaderContext.TraceHeader)); }
public async Task Trace_OutGoingClientFactory_WithLabels(Action <IWebHostBuilder> testServerConfigurator) { var uri = $"/Trace/{nameof(TraceController.TraceOutgoingClientFactoryWithLabels)}/{_testId}"; var childSpanName = EntryData.GetMessage(nameof(TraceController.TraceOutgoingClientFactory), _testId); var outgoingSpanName = "https://google.com/"; using var server = GetTestServer <TraceTestNoBufferHighQpsApplication>(builder => { testServerConfigurator?.Invoke(builder); builder.ConfigureServices(services => services .AddHttpClient("outgoing_with_labels", c => c.BaseAddress = new Uri("https://google.com/")) .AddOutgoingGoogleTraceHandler(sp => _customLabels)); }); using var client = server.CreateClient(); await client.GetAsync(uri); var trace = TraceEntryPolling.Default.GetTrace(uri, _startTime); TraceEntryVerifiers.AssertParentChildSpan(trace, uri, childSpanName, outgoingSpanName); TraceEntryVerifiers.AssertSpanLabelsContains(trace.Spans.First(span => span.Name == outgoingSpanName), _customLabels); }
public async Task Trace_OutGoing() { // We don't test custom trace context with TraceHeaderPropagatingHandler because it's // pre IHttpClientFactory and has associated lifetime issues. var uri = $"/Trace/{nameof(TraceController.TraceOutgoing)}/{_testId}"; var childSpanName = EntryData.GetMessage(nameof(TraceController.TraceOutgoing), _testId); var outgoingSpanName = "https://google.com/"; using var server = GetTestServer <TraceTestNoBufferHighQpsApplication>( builder => builder.ConfigureServices( services => services.TryAddSingleton( #pragma warning disable CS0618 // Type or member is obsolete new TraceHeaderPropagatingHandler(ContextTracerManager.GetCurrentTracer)))); #pragma warning restore CS0618 // Type or member is obsolete using var client = server.CreateClient(); await client.GetAsync(uri); var trace = TraceEntryPolling.Default.GetTrace(uri, _startTime); TraceEntryVerifiers.AssertParentChildSpan(trace, uri, childSpanName, outgoingSpanName); }
public async Task Trace_TraceFallbackPredicate(Action <IWebHostBuilder> testServerConfigurator) { var tracedId = $"fallback{_testId}"; var tracedUri = $"/Trace/{nameof(TraceController.Trace)}/{tracedId}"; var tracedChildSpanName = EntryData.GetMessage(nameof(TraceController.Trace), tracedId); var nonTracedUri = $"/Trace/{nameof(TraceController.Trace)}/{_testId}"; using var server = GetTestServer <TraceTestFallbackPredicate>(testServerConfigurator); using var client = server.CreateClient(); var nonTracedTask = client.GetAsync(nonTracedUri); var tracedTask = client.GetAsync(tracedUri); await Task.WhenAll(nonTracedTask, tracedTask); Assert.Null(TraceEntryPolling.NoEntry.GetTrace(nonTracedUri, _startTime, expectTrace: false)); var trace = TraceEntryPolling.Default.GetTrace(tracedUri, _startTime); TraceEntryVerifiers.AssertParentChildSpan(trace, tracedUri, tracedChildSpanName); TraceEntryVerifiers.AssertSpanLabelsContains( trace.Spans.First(s => s.Name == tracedUri), TraceEntryData.HttpGetSuccessLabels); }
public async Task Trace_WebServerHosted() { var service = $"/api/Trace/Trace/{_testId}"; var childSpanName = EntryData.GetMessage("Trace", _testId); HttpResponseMessage response; using (HttpClient httpClient = new HttpClient()) { httpClient.BaseAddress = PublishedServiceBaseAddress; response = await httpClient.GetAsync(service); } var trace = _polling.GetTrace(service, _startTime); TraceEntryVerifiers.AssertParentChildSpan(trace, service, childSpanName); TraceEntryVerifiers.AssertSpanLabelsContains( trace.Spans.First(s => s.Name == service), TraceEntryData.HttpGetSuccessLabels); Assert.False(response.Headers.Contains(TraceHeaderContext.TraceHeader)); }
public async Task Trace_WebServerHosted_Label() { var service = $"/api/Trace/TraceLabels/{_testId}"; var childSpanName = EntryData.GetMessage("TraceLabels", _testId); using (HttpClient httpClient = new HttpClient()) { httpClient.BaseAddress = PublishedServiceBaseAddress; await httpClient.GetAsync(service); } var trace = _polling.GetTrace(service, _startTime); TraceEntryVerifiers.AssertParentChildSpan(trace, service, childSpanName); TraceEntryVerifiers.AssertSpanLabelsContains( trace.Spans.First(s => s.Name == childSpanName), new Dictionary <string, string> { { TraceEntryData.TraceLabel, TraceEntryData.TraceLabelValue } }); }
public async Task TraceSingleAsync() { IHost host = null; try { host = TroubleshootingHostBuilder.CreateHostBuilder().Build(); await host.StartAsync(); // Sample: SingleContext ITraceContext traceContext = new SimpleTraceContext(null, null, true); var tracerFactory = host.Services.GetRequiredService <Func <ITraceContext, IManagedTracer> >(); IManagedTracer tracer = tracerFactory(traceContext); ContextTracerManager.SetCurrentTracer(tracer); // End sample // Let's just start a span with the test ID so we can find it faster. // But we don't show this in sample code. using (tracer.StartSpan(_testId)) { // Sample: RunIn IManagedTracer currentTracer = host.Services.GetRequiredService <IManagedTracer>(); currentTracer.RunInSpan( () => Console.WriteLine("Using Cloud Trace from a non ASP.NET Core app"), "testing_tracing"); // End sample } var trace = TraceEntryPolling.Default.GetTrace(_testId, _startTime); TraceEntryVerifiers.AssertParentChildSpan(trace, _testId, "testing_tracing"); } finally { if (host is object) { await host.StopAsync(); } } }
public async Task TraceOutgoingAsync() { IHost host = null; try { host = OutgoingHostBuilder.CreateHostBuilder().Build(); await host.StartAsync(); ITraceContext traceContext = new SimpleTraceContext(null, null, true); var tracerFactory = host.Services.GetRequiredService <Func <ITraceContext, IManagedTracer> >(); IManagedTracer tracer = tracerFactory(traceContext); ContextTracerManager.SetCurrentTracer(tracer); // Let's just start a span with the test ID so we can find it faster. // But we don't show this in sample code. using (tracer.StartSpan(_testId)) { // Sample: TraceOutgoingClientFactory IHttpClientFactory clientFactory = host.Services.GetRequiredService <IHttpClientFactory>(); var httpClient = clientFactory.CreateClient("tracesOutgoing"); // Any code that makes outgoing requests. var response = await httpClient.GetAsync("http://weather.com/"); // End sample } var trace = TraceEntryPolling.Default.GetTrace(_testId, _startTime); TraceEntryVerifiers.AssertParentChildSpan(trace, _testId, "http://weather.com/"); } finally { if (host is object) { await host.StopAsync(); } } }
public async Task TraceSingleAsync() { IHost host = null; // Hides that we use different classes so that we can have multiple CreateHostBuilder methods. Func <IHostBuilder> CreateHostBuilder = DefaultHostBuilder.CreateHostBuilder; try { // Sample: Start host = CreateHostBuilder().Build(); await host.StartAsync(); // End sample ITraceContext traceContext = new SimpleTraceContext(null, null, true); var tracerFactory = host.Services.GetRequiredService <Func <ITraceContext, IManagedTracer> >(); IManagedTracer tracer = tracerFactory(traceContext); ContextTracerManager.SetCurrentTracer(tracer); using (tracer.StartSpan(_testId)) { IManagedTracer currentTracer = host.Services.GetRequiredService <IManagedTracer>(); currentTracer.RunInSpan( () => Console.WriteLine("Using Cloud Trace from a non ASP.NET Core app"), "testing_tracing"); } var trace = TraceEntryPolling.Default.GetTrace(_testId, _startTime); TraceEntryVerifiers.AssertParentChildSpan(trace, _testId, "testing_tracing"); } finally { if (host is object) { await host.StopAsync(); } } }