Example #1
0
        public async Task <IApiStatusObject> GetStatusAsync(string url, CancellationToken cancellationToken)
        {
            var response = await _httpClient.GetAsync(url, cancellationToken);

            string content = await response.Content.ReadAsStringAsync();

            if (!response.IsSuccessStatusCode)
            {
                if (content.Length > _maxContentLength)
                {
                    content = content.Substring(0, _maxContentLength);
                }
                throw new SimpleHttpResponseException(response.StatusCode, content);
            }

            IApiStatusObject statusObject = null;

            try
            {
                statusObject = JsonConvert.DeserializeObject <ApiStatusObject>(content);
            }
            catch (Exception)
            {
                // hiding such exception, cause we can get response from our web-sites with a page content here.
            }

            return(statusObject ?? new ApiStatusObject()
            {
                Version = "undefined"
            });
        }
Example #2
0
        public async Task CheckAPIs()
        {
            List <IMonitoringObject> apisMonitoring = await GetMonitoringObjectsForProcessing(x => !string.IsNullOrEmpty(x.Url));

            DateTime    now             = DateTime.UtcNow;
            List <Task> recipientChecks = new List <Task>(apisMonitoring.Count);
            var         issues          = new ConcurrentBag <ApiHealthCheckError>();

            foreach (var monitoringItem in apisMonitoring)
            {
                var task = Task.Run(async() =>
                {
                    try
                    {
                        CancellationTokenSource cts   = new CancellationTokenSource(TimeSpan.FromSeconds(_settings.PingTimeoutInSeconds));
                        IApiStatusObject statusObject = await _isAliveService.GetStatusAsync(monitoringItem.Url, cts.Token);
                        monitoringItem.Version        = statusObject.Version;
                        monitoringItem.LastTime       = now;
                        monitoringItem.EnvInfo        = statusObject.Env;

                        HandleResilience(issues, statusObject.IssueIndicators, monitoringItem);
                    }
                    catch (OperationCanceledException)
                    {
                        GenerateError(issues, now, "Timeout", monitoringItem);
                    }
                    catch (SimpleHttpResponseException e)
                    {
                        GenerateError(issues, now, e.StatusCode.ToString(), monitoringItem);
                    }
                    catch (Exception e)
                    {
                        GenerateError(issues, now, $"Unexpected exception: {e.GetBaseException().Message}", monitoringItem);
                    }
                });

                recipientChecks.Add(task);
            }

            await Task.WhenAll(recipientChecks);

            foreach (var issue in issues)
            {
                await _apiHealthCheckErrorRepository.InsertAsync(issue);
            }

            foreach (var api in apisMonitoring)
            {
                await _monitoringService.PingAsync(api);
            }
        }