Example #1
0
        public int Run()
        {
            MachineStatusResult programResult = null;

            try
            {
                var facility = FacilityResolver.CreateFacility();

                var systemMonitor = new SystemMonitor(facility);

                var status = systemMonitor.GetSystemStatus();

                programResult = new MachineStatusResult(status);

                var processor = new JsonAssertionProcessor(programResult);
                foreach (var expectation in Expectations.Select(x => Expectation.Parse(x)))
                {
                    var expectationResult = processor.Assert(expectation);
                    if (expectationResult.Failed)
                    {
                        programResult.AddErrors(expectationResult.Errors);
                    }
                }
            }
            catch (Exception ex)
            {
                programResult = MachineStatusResult.Failure(ex);
            }
            finally
            {
                var formating = Format ? Formatting.Indented : Formatting.None;
                System.Console.WriteLine(JsonConvert.SerializeObject(programResult, formating, serializerSettings));
            }
            if (programResult == null || programResult.Error)
            {
                return(1);
            }
            else
            {
                return(0);
            }
        }
        public void AdditionalDiagnosticListenerSpan(bool addClientIp)
        {
            var agentPort      = TcpPortProvider.GetOpenPort();
            var aspNetCorePort = TcpPortProvider.GetOpenPort();
            var envVars        = ZipkinEnvVars;

            envVars["SIGNALFX_INSTRUMENTATION_ASPNETCORE_DIAGNOSTIC_LISTENERS"] = "Unused,HotChocolate.Execution,Another.Unused";

            if (addClientIp)
            {
                envVars["SIGNALFX_ADD_CLIENT_IP_TO_SERVER_SPANS"] = "true";
            }

            using (var agent = new MockZipkinCollector(agentPort))
                using (var process = StartSample(agent.Port, arguments: null, packageVersion: string.Empty, aspNetCorePort: aspNetCorePort, envVars: envVars))
                {
                    agent.SpanFilters.Add(IsNotServerLifeCheck);

                    var wh = new EventWaitHandle(false, EventResetMode.AutoReset);

                    process.OutputDataReceived += (sender, args) =>
                    {
                        if (args.Data != null)
                        {
                            if (args.Data.Contains("Now listening on:") || args.Data.Contains("Unable to start Kestrel"))
                            {
                                wh.Set();
                            }

                            Output.WriteLine($"[webserver][stdout] {args.Data}");
                        }
                    };
                    process.BeginOutputReadLine();

                    process.ErrorDataReceived += (sender, args) =>
                    {
                        if (args.Data != null)
                        {
                            Output.WriteLine($"[webserver][stderr] {args.Data}");
                        }
                    };

                    process.BeginErrorReadLine();

                    wh.WaitOne(5000);

                    var maxMillisecondsToWait = 15_000;
                    var intervalMilliseconds  = 500;
                    var intervals             = maxMillisecondsToWait / intervalMilliseconds;
                    var serverReady           = false;

                    // wait for server to be ready to receive requests
                    while (intervals-- > 0)
                    {
                        try
                        {
                            serverReady = SubmitRequest(aspNetCorePort, "/alive-check") == HttpStatusCode.OK;
                        }
                        catch
                        {
                            // ignore
                        }

                        if (serverReady)
                        {
                            break;
                        }

                        Thread.Sleep(intervalMilliseconds);
                    }

                    if (!serverReady)
                    {
                        throw new Exception("Couldn't verify the application is ready to receive requests.");
                    }

                    var testStart = DateTime.Now;

                    var paths = Expectations.Select(e => e.OriginalUri).ToArray();
                    SubmitRequests(aspNetCorePort, paths);

                    var spans =
                        agent.WaitForSpans(
                            Expectations.Count,
                            minDateTime: testStart)
                        .OrderBy(s => s.Start)
                        .ToList();

                    if (!process.HasExited)
                    {
                        process.Kill();
                    }

                    Console.WriteLine($"Spans: {spans}");

                    var expectations = addClientIp ? ExpectationsWithClientIp : Expectations;
                    SpanTestHelpers.AssertExpectationsMet(expectations, spans);
                }
        }