Esempio n. 1
0
        public async Task TraceSingleAsync(Func <IHostBuilder> createHostBuilder)
        {
            IHost host = null;

            try
            {
                host = 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);

                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();
                }
            }
        }
Esempio n. 2
0
        public void Log_Trace()
        {
            string traceId       = "external_trace_id";
            ulong  spanId        = 1;
            string fullTraceName = TraceTarget.ForProject(ProjectId).GetFullTraceName(traceId);

            Predicate <IEnumerable <LogEntry> > matcher = logEntries =>
            {
                LogEntry entry = logEntries.Single();
                return(entry.LogName == new LogName(ProjectId, BaseLogName).ToString() &&
                       entry.Trace == fullTraceName &&
                       entry.SpanId == $"{spanId:x16}");
            };

            var mockServiceProvider = new Mock <IServiceProvider>();
            var traceContext        = new SimpleTraceContext(traceId, spanId, true);

            mockServiceProvider.Setup(sp => sp.GetService(typeof(ITraceContext))).Returns(traceContext);

            var mockConsumer = new Mock <IConsumer <LogEntry> >();

            mockConsumer.Setup(c => c.Receive(Match.Create(matcher)));
            var logger = GetLogger(mockConsumer.Object, LogLevel.Information, serviceProvider: mockServiceProvider.Object, logName: BaseLogName);

            logger.Log(LogLevel.Error, 0, LogMessage, s_exception, Formatter);
            mockConsumer.VerifyAll();
        }
        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;

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