/// <summary>
        /// Parses the scraped text and returns it as a set of metrics
        /// </summary>
        /// <param name="scrapedText">The text to be parsed</param>
        /// <returns>A dictionary of metrics tretrieved keyed by metric name</returns>
        public static Dictionary <string, MetricScrapingContainer> Parse(string scrapedText)
        {
            var results = new Dictionary <string, MetricScrapingContainer>();
            var lines   = scrapedText.Split("\n", StringSplitOptions.RemoveEmptyEntries);

            MetricScrapingContainer currentContainer = null;

            foreach (var line in lines)
            {
                var trimmedLine = line.TrimStart();

                if (trimmedLine.StartsWith("# HELP"))
                {
                    if (currentContainer != null)
                    {
                        results.Add(currentContainer.MetricName, currentContainer);
                    }

                    currentContainer            = new MetricScrapingContainer();
                    currentContainer.MetricHelp = trimmedLine.Substring(trimmedLine.IndexOf(' ', 2) + 1);
                }
                else if (trimmedLine.StartsWith("# TYPE"))
                {
                    var workingType     = trimmedLine.Substring(trimmedLine.IndexOf(' ', 2) + 1);
                    var workingElements = workingType.Split(" ");

                    if (workingElements.Length > 1)
                    {
                        currentContainer.MetricName = workingElements[0];
                        currentContainer.MetricType = workingElements[1];
                    }
                }
                else
                {
                    if (double.TryParse(trimmedLine.Substring(trimmedLine.IndexOf(" ") + 1).Trim(), out var value))
                    {
                        currentContainer.MetricValue = value;
                    }
                }
            }

            if (currentContainer != null && !results.ContainsKey(currentContainer.MetricName))
            {
                results.Add(currentContainer.MetricName, currentContainer);
            }

            return(results);
        }
        public void SimpleCountIteration()
        {
            var endpoint = @"http://localhost:9610/metrics";
            var client   = new HttpClient();
            var results  = new List <bool>();
            var scraped  = new List <MetricScrapingContainer>();

            var  continueScraping = true;
            var  startScraping    = false;
            Task scraper;

            using (var factory = new MetricFactory())
            {
                factory.AddPrometheus("prometheus", 9610);

                var summary = factory.CreateSummary("Metric1", "Test metric for #1", 5, true, new string[] { "label1", "label2" });

                scraper = Task.Factory.StartNew(() =>
                {
                    while (continueScraping)
                    {
                        if (startScraping)
                        {
                            var response = client.GetAsync(endpoint).GetAwaiter().GetResult();

                            results.Add(response.IsSuccessStatusCode);

                            if (response.IsSuccessStatusCode)
                            {
                                var responseString = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
                                var metricsScraped = MetricScrapingContainer.Parse(responseString);

                                if (metricsScraped.ContainsKey("Metric1"))
                                {
                                    scraped.Add(metricsScraped["Metric1"]);
                                }
                            }

                            Task.Delay(1000).GetAwaiter().GetResult();
                        }
                        else
                        {
                            Task.Delay(10).GetAwaiter().GetResult();
                        }
                    }
                });

                for (var index = 0; index < 1500; index++)
                {
                    startScraping = true;
                    summary.Observe(_doubleValues[index % _doubleValues.Length]);
                    if (index < 1499)
                    {
                        Task.Delay(10).GetAwaiter().GetResult();
                    }
                }

                Task.Delay(1000).GetAwaiter().GetResult();
            }

            continueScraping = false;

            Assert.IsTrue(scraped.Count > 0, "Scraped value count not expected");
        }
        public void ScrapableBroker()
        {
            var endpoint = @"http://localhost:9610/metrics";
            var client   = new HttpClient();
            var results  = new List <bool>();
            var scraped  = new List <MetricScrapingContainer>();

            var  continueScraping = true;
            var  startScraping    = false;
            Task scraper;

            using (var factory = new MetricFactory())
            {
                factory.AddPrometheus("prometheus", 9610);

                var counter = factory.CreateCounter("demoCounter", "A test counter", false, null);

                scraper = Task.Factory.StartNew(() =>
                {
                    while (continueScraping)
                    {
                        if (startScraping)
                        {
                            var response = client.GetAsync(endpoint).GetAwaiter().GetResult();

                            results.Add(response.IsSuccessStatusCode);

                            if (response.IsSuccessStatusCode)
                            {
                                var responseString = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
                                var metricsScraped = MetricScrapingContainer.Parse(responseString);

                                if (metricsScraped.ContainsKey("demoCounter"))
                                {
                                    scraped.Add(metricsScraped["demoCounter"]);
                                }
                            }

                            Task.Delay(1000).GetAwaiter().GetResult();
                        }
                        else
                        {
                            Task.Delay(10).GetAwaiter().GetResult();
                        }
                    }
                });

                for (var index = 0; index <= 500; index++)
                {
                    counter.Increment();
                    startScraping = true;
                    Thread.Sleep(100);
                }

                continueScraping = false;
            }

            Assert.IsFalse(!results.Any(item => item), "There should be successful readings found");
            Assert.IsTrue(results.Count > 40, "At least 40 results should have been collected in this time");
            Assert.IsTrue(scraped.Count > 40, "At least 40 values for the counter should have been found");
        }
        public void SimpleCountIteration()
        {
            var endpoint = @"http://localhost:9610/metrics";
            var client   = new HttpClient();
            var results  = new List <bool>();
            var scraped  = new List <MetricScrapingContainer>();

            var  continueScraping = true;
            var  startScraping    = false;
            Task scraper;

            using (var factory = new MetricFactory())
            {
                factory.AddPrometheus("prometheus", 9610);

                var pulse = factory.CreatePulse("demoPulse", "A test counter", false, null);

                scraper = Task.Factory.StartNew(() =>
                {
                    while (continueScraping)
                    {
                        if (startScraping)
                        {
                            var response = client.GetAsync(endpoint).GetAwaiter().GetResult();

                            results.Add(response.IsSuccessStatusCode);

                            if (response.IsSuccessStatusCode)
                            {
                                var responseString = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
                                var metricsScraped = MetricScrapingContainer.Parse(responseString);

                                if (metricsScraped.ContainsKey("demoPulse"))
                                {
                                    scraped.Add(metricsScraped["demoPulse"]);
                                }
                            }

                            Task.Delay(1000).GetAwaiter().GetResult();
                        }
                        else
                        {
                            Task.Delay(10).GetAwaiter().GetResult();
                        }
                    }
                });

                for (var index = 0; index < 500; index++)
                {
                    pulse.Observe();
                    startScraping = true;
                    if (index < 499)
                    {
                        Task.Delay(10).GetAwaiter().GetResult();
                    }
                }

                continueScraping = false;
            }

            Assert.IsFalse(!results.Any(item => item), "There should be successful readings found");
            Assert.IsTrue(results.Count > 4, $"At least 4 results should have been collected in this time (value {results.Count})");
            Assert.IsTrue(scraped.Count > 4, $"At least 4 values for the counter should have been found (value {scraped.Count})");
            Assert.IsTrue((scraped.Max(item => item.MetricValue ?? 0)) >= 400, $"Maximum value count not expected (value {scraped.Max(item => item.MetricValue ?? 0)})");
        }