private async Task <MonitoringResult> TestAbbyyExecute(IRequestClient <AbbyyOcrTestRequest> requestClient) { var watch = new Stopwatch(); MonitoringResult result; try { watch.Start(); var testResponse = (await requestClient.GetResponse <AbbyyOcrTestResponse>(new AbbyyOcrTestRequest())).Message; watch.Stop(); result = new MonitoringResult { MonitoredServices = "Abbyy Execute", Status = testResponse.Success ? HeartbeatStatus.Ok.ToString() : HeartbeatStatus.Nok.ToString(), Message = testResponse.Success ? "Ok" : "Nok, Error: " + testResponse.Error, ExecutionTime = watch.ElapsedMilliseconds }; } catch (Exception ex) { result = new MonitoringResult { MonitoredServices = "Abbyy Execute", Status = HeartbeatStatus.Nok.ToString(), Message = $"Viaduc service call failed. Exception: {ex.Message}", ExecutionTime = watch.ElapsedMilliseconds }; } return(result); }
/// <summary> /// Updates the monitoring result of a failure, including all the degradation which will be updated /// </summary> /// <param name="failure">Failure which is changed</param> /// <param name="monitoringResult">Requests an update of the failure</param> public void UpdateMonitoringResult(IFailure failure, MonitoringResult monitoringResult) { // Checks, if the failure has changed MonitoringResult oldResult; if (_failureStatus.TryGetValue(failure, out oldResult)) { if (oldResult == monitoringResult) { // No change of failure... so just return return; } } _failureStatus[failure] = monitoringResult; // Go through all rulesets where the capability is dependent on the failure var alreadyUpdated = new HashSet <ICapability>(); foreach (var ruleSet in _rules.Values) { UpdateDegradation(ruleSet.Capability, alreadyUpdated); /* * foreach (var rule in ruleSet.Rules * .OfType<FailureRule>() * .Where(x=> x.Failure.Equals(failure))) * { * if (rule.Failure.Equals(failure)) * { * UpdateDegradation(ruleSet.Capability, alreadyUpdated); * } * }*/ } }
private async Task <MonitoringResult> TestDir(IRequestClient <DirCheckRequest> requestClient) { var result = new MonitoringResult { MonitoredServices = "DIR" }; var watch = new Stopwatch(); try { watch.Start(); var response = (await requestClient.GetResponse <DirCheckResponse>(new DirCheckRequest())).Message; watch.Stop(); if (response.Ok) { result.Status = HeartbeatStatus.Ok.ToString(); result.Message = $"Ok, Product Version: {response.ProductVersion}, Product Name: {response.ProductName}, Repository Name: {response.RepositoryName}"; } else { result.Status = HeartbeatStatus.Nok.ToString(); result.Message = "Nok"; } } catch (Exception ex) { result.Status = HeartbeatStatus.Nok.ToString(); result.Message = $"Viaduc service call failed which execute the test. Exception: {ex.Message}"; } result.ExecutionTime = watch.ElapsedMilliseconds; return(result); }
// public void TryGetMonitoringResult(string application, Action<MonitoringServiceResult, ExternalApiInfoList> callback) // { // try // { // if (callback == null) // { // throw new ArgumentNullException("callback"); // } // // if (string.IsNullOrEmpty(application)) // { // throw new ArgumentException("'application' can not be null or empty string"); // } // // Guid id; // if (Guid.TryParse(application, out id) == false) // { // log.WarnFormat("TryGetExternalApiInfo: Invalid Application ID format: {0}. No external API info loaded for app ID {1}.", application, id); // callback(MonitoringServiceResult.Error, null); // return; // } // // this.TryGetMonitoringResultAsync(id, asyncRequestState => OnGetMonitoringResult(asyncRequestState, callback)); // return; // } // catch (Exception ex) // { // log.Error(ex); // } // // log.WarnFormat("AccountService.GetApplication: No external API info loaded for app ID {0}.", application); // callback(MonitoringServiceResult.Error, null); // } #endregion #region Private Methods #region Async Mode Code private static void OnGetMonitorResultForVerifing(AsyncRequestState asyncRequestState, Action <MonitoringResult, object> callback, object state) { MonitoringResult result; var appId = asyncRequestState.AppId.ToString(); try { switch (asyncRequestState.ResultCode) { case MonitoringServiceResult.Ok: // account = new ApplicationAccount(appId, asyncRequestState.ResultCode, asyncRequestState.RequestResult); result = new MonitoringResult(appId, asyncRequestState.ResultCode, asyncRequestState.RequestResult, null); break; case MonitoringServiceResult.NotFound: // account = new ApplicationAccount(appId, asyncRequestState.ResultCode, false, ErrorMessages.InvalidAppId); result = new MonitoringResult(appId, asyncRequestState.ResultCode, null, "Invalid AppId"); break; default: // account = new ApplicationAccount(appId, asyncRequestState.ResultCode, allowOnFailure, asyncRequestState.ErrorMessage); result = new MonitoringResult(appId, asyncRequestState.ResultCode, null, asyncRequestState.ErrorMessage); break; } } catch (Exception e) { log.Warn(e); // account = new ApplicationAccount(appId, AccountServiceResult.Error, allowOnFailure, e.Message); result = new MonitoringResult(appId, MonitoringServiceResult.Error, null, e.Message); } callback(result, state); }
/// <summary> /// This method can be called by the inherited methods which define a specific failure /// </summary> /// <param name="failure">Failure, whose status shall be updated</param> /// <param name="result">The monitoring result of the failure</param> protected void ReportMonitoringResult(IFailure failure, MonitoringResult result) { if (Degrader == null) { throw new InvalidOperationException("Degrader is not set"); } Degrader.UpdateMonitoringResult(failure, result); }
public void Construct() { Assert.Throws <ArgumentNullException>(() => new MonitoringResult(null, "Test", bitmap)); Assert.Throws <ArgumentNullException>(() => new MonitoringResult(new FileInfo("XX1"), "Test", null)); var result = new MonitoringResult(new FileInfo("XX1"), "Test", bitmap); Assert.AreEqual("Test", result.Class); Assert.AreEqual("XX1", result.File.Name); Assert.IsNotNull(result.Preview); }
/// <summary> /// Antes de iniciar a execução /// </summary> /// <param name="context"></param> public void OnActionExecuting(ActionExecutingContext context) { result = new MonitoringResult { Action = context.ActionDescriptor.DisplayName, Date = DateTime.UtcNow, Parameters = context.ActionArguments, }; stopwatch.Start(); }
public async Task Consume(ConsumeContext <TestElasticsearchRequest> context) { var watch = new Stopwatch(); var result = new MonitoringResult { MonitoredServices = "Elasticsearch" }; try { watch.Start(); var testResponse = await dbAccess.GetElasticIndexHealth(); if (testResponse.IsReadOnly) { result.Status = HeartbeatStatus.Nok.ToString(); result.Message = "Error, Index is set to readonly!"; } else if (testResponse.Health == "red") { result.Status = HeartbeatStatus.Nok.ToString(); result.Message = "Error, Index health-status is red!"; } else if (testResponse.Status != "open") { result.Status = HeartbeatStatus.Nok.ToString(); result.Message = $"Error, Index status is {testResponse.Status}"; } else { result.Status = HeartbeatStatus.Ok.ToString(); result.Message = $"Ok, Health: {testResponse.Health}, " + $"Status: {testResponse.Status}, " + $"IsReadOnly: {testResponse.IsReadOnly}, " + $"DocsCount: {testResponse.DocsCount}"; } } catch (Exception ex) { result.Status = HeartbeatStatus.Nok.ToString(); Log.Error(ex, "Error when getting Index-Health-Status"); result.Message = "Error: Unknown Error when accessing Elastic (see Log)"; } finally { watch.Stop(); result.ExecutionTime = watch.ElapsedMilliseconds; } await context.RespondAsync(new TestElasticsearchResponse { MonitoringResult = result }); }
private async void _doWork(object sender, ElapsedEventArgs e) { Log.Logger.ForContext(typeof(MonitoringWorker)).Information("MonitoringWorker waking up..."); var endpoints = new List <MonitoredEndpoint>(); //var results = new List<MonitoringResult>(); using (var scope = _scopeFactory.CreateScope()) { var dbContext = scope.ServiceProvider.GetRequiredService <DatabaseContext>(); endpoints = await dbContext.MonitoredEndpoint.ToListAsync(); } foreach (var endpoint in endpoints) { var timeStamp = DateTime.Now; if (!TimeTest(endpoint, timeStamp)) { continue; } endpoint.DateOfLastCheck = timeStamp; MonitoringResult result = new MonitoringResult(); result.DateOfCheck = timeStamp; result.MonitoredEndpoint = endpoint; try { var request = new HttpRequestMessage(HttpMethod.Get, new UriBuilder(endpoint.Url).Uri); var client = _clientFactory.CreateClient(); try { var response = await client.SendAsync(request); int statusCodeInt = ResolveStatusCode(response); result.ReturnedPayload = await ExtractPayloadAsync(response); } catch (Exception ex) { result.ReturnedPayload = "SERVICE EXCEPTION: " + MySql.Data.MySqlClient.MySqlHelper.EscapeString(ex.Message); } } catch (Exception ex) { Log.Logger.ForContext(typeof(MonitoringWorker)).Error(ex, String.Format("ERROR SENDING REQUEST TO ENDPOINT ID {0}", endpoint.Id)); } await SaveMonitoringResultAsync(endpoint, result); } }
public void ApplyChange() { var file = Path.Combine(TestContext.CurrentContext.TestDirectory, @"Data\Data.txt"); var result = new MonitoringResult(new FileInfo(file), "Test", bitmap); Path.Combine(TestContext.CurrentContext.TestDirectory, "Test").EnsureDirectoryExistence(); bool completed = false; result.MoveRequest += (sender, args) => completed = true; result.ApplyChange(new DirectoryInfo(TestContext.CurrentContext.TestDirectory)); Assert.IsTrue(completed); }
public async Task StartAsync(MonitoringEntity entity) { var result = new MonitoringResult { CreatedDate = _dateTimeProvider.Now, MonitoringEntityId = entity.Id }; result.SetData(new PingMonitoringResultData(await GetIpStatus(entity))); _monitoringResultRepository.Create(result); await _monitoringResultRepository.SaveChangesAsync(); }
public SiteHealth Map(MonitoringResult result) { if (result == null) { throw new ArgumentNullException(nameof(result)); } if (result.Data == null) { throw new ArgumentNullException(nameof(result.Data)); } var typedData = result.GetData <PingMonitoringResultData>(); return(typedData.IpStatus == IPStatus.Success ? SiteHealth.Good : SiteHealth.Bad); }
private async Task <MonitoringResult> TestRabbitMq() { var result = new MonitoringResult { MonitoredServices = "RabbitMQ" }; var watch = new Stopwatch(); var baseUri = WebHelper.GetStringSetting("rabbitMqManagementUri", string.Empty); try { watch.Start(); var uriBuilder = new UriBuilder(baseUri); uriBuilder.Path = "api/healthchecks/node"; var response = await rabbitMqHttpClient.GetAsync(uriBuilder.Uri); var responseString = await response.Content.ReadAsStringAsync(); var responseJson = JsonConvert.DeserializeObject <RabbitMcHealthCheckResponse>(responseString); if (responseJson.Status == "ok") { result.Message = "Ok, Health checks done"; result.Status = HeartbeatStatus.Ok.ToString(); } else { result.Message = $"Nok, Reason from RabbitMQ: {responseJson.Reason}"; result.Status = HeartbeatStatus.Nok.ToString(); } watch.Stop(); } catch (Exception ex) { result.Message = $"Nok, Exception: {ex.Message}"; result.Status = HeartbeatStatus.Nok.ToString(); } result.Message += $", Request uri: {baseUri}"; result.ExecutionTime = watch.ElapsedMilliseconds; return(result); }
private async Task <bool> OwnerTestAsync(MonitoringResult monitoringResult) { try { var resultOwner = await _context.MonitoredEndpoint.FirstOrDefaultAsync(x => x.Id == monitoringResult.MonitoredEndpointForeignKey); if (resultOwner.Id != _owner.Data.Id) { return(false); } return(true); } catch (Exception ex) { _logger.LogError("ERROR RESOLVING OWNER", ex); throw ex; } }
private async Task <MonitoringResult> TestAbbyyLicence( IRequestClient <DocumentConverterInfoRequest, DocumentConverterInfoResponse> requestClient) { var watch = new Stopwatch(); MonitoringResult result; try { watch.Start(); var infoResponse = await requestClient.Request(new DocumentConverterInfoRequest()); watch.Stop(); result = new MonitoringResult { MonitoredServices = "Abbyy Licence", Status = infoResponse.PagesRemaining > 0 ? HeartbeatStatus.Ok.ToString() : HeartbeatStatus.Nok.ToString(), ExecutionTime = watch.ElapsedMilliseconds }; if (infoResponse.PagesRemaining == null) { result.Message = "Nok, Information missing. Abbyy not installed?"; } else { result.Message = infoResponse.PagesRemaining > 0 ? "Ok" : "Nok"; result.Message += $", Remaining pages: {infoResponse.PagesRemaining}"; } } catch (Exception ex) { result = new MonitoringResult { MonitoredServices = "Abbyy Licence", Status = HeartbeatStatus.Nok.ToString(), Message = $"Viaduc service call failed. Exception: {ex.Message}", ExecutionTime = watch.ElapsedMilliseconds }; } return(result); }
private void HandleGetMonitoringResult(MonitoringResult monitoringResult, IRestRequestContext context) { if (monitoringResult.MonitoringServiceResult == MonitoringServiceResult.Ok) { if (log.IsDebugEnabled) { log.DebugFormat("HandleGetMonitoringResult, response for app {0}: {1}", monitoringResult.ApplicationId, monitoringResult.Status); } context.SendResponse(monitoringResult.Status); } else { if (log.IsDebugEnabled) { log.DebugFormat("HandleGetMonitoringResult, MonitoringServiceResult {0}: {1}", monitoringResult.MonitoringServiceResult, monitoringResult.DebugMessage); } context.SendResponse("An error occured"); } }
private async Task <MonitoringResult> TestAisDb(IRequestClient <AisDbCheckRequest, AisDbCheckResponse> requestClient) { var watch = new Stopwatch(); MonitoringResult result; try { watch.Start(); var response = await requestClient.Request(new AisDbCheckRequest()); watch.Stop(); result = new MonitoringResult { MonitoredServices = "AIS DB", ExecutionTime = watch.ElapsedMilliseconds }; if (response.Ok) { result.Status = HeartbeatStatus.Ok.ToString(); result.Message = $"Ok, DB Version = {response.DbVersion}"; } else { result.Status = HeartbeatStatus.Nok.ToString(); result.Message = $"Nok, Exception: {response.Exception.Message}"; } } catch (Exception ex) { result = new MonitoringResult { MonitoredServices = "AIS DB", Status = HeartbeatStatus.Nok.ToString(), Message = $"Viaduc service call failed which execute the test. Exception: {ex.Message}", ExecutionTime = watch.ElapsedMilliseconds }; } return(result); }
/// <inheritdoc /> public void AddRule(IFailure failure, MonitoringResult monitoringResult, ICapability targetCapability, int targetValue) { if (targetCapability.Degrader != null && targetCapability.Degrader != this) { throw new InvalidOperationException("Target Capability is already assigned to another degrader"); } var ruleSet = GetRuleSetFor(targetCapability, true); if (ruleSet == null) { throw new ArgumentNullException(nameof(ruleSet)); } ruleSet.Rules.Add( new FailureRule { Failure = failure, ConditionValue = monitoringResult, TargetCapability = targetValue }); }
private async Task <MonitoringResult> TestElasticsearch(IRequestClient <TestElasticsearchRequest> requestClient) { MonitoringResult result; try { var response = await requestClient.GetResponse <TestElasticsearchResponse>(new TestElasticsearchRequest()); result = response.Message.MonitoringResult; } catch (Exception ex) { result = new MonitoringResult { MonitoredServices = "Elasticsearch", Status = HeartbeatStatus.Nok.ToString(), Message = $"Viaduc service call failed which execute the test. Exception: {ex.Message}" }; } return(result); }
private MonitoringResult TestDb() { var connectionString = ManagementSettingsViaduc.Instance.SqlConnectionString; var watch = new Stopwatch(); watch.Start(); var data = new UserDataAccess(connectionString); var testResult = data.TestDbAccess(); watch.Stop(); string message; if (testResult <= 0) { message = "DB Version not found"; } else if (testResult == 9999) { message = "DB Upgrade failed"; } else { message = "Ok"; } var result = new MonitoringResult { MonitoredServices = "DB", Status = testResult > 0 && testResult != 9999 ? HeartbeatStatus.Ok.ToString() : HeartbeatStatus.Nok.ToString(), ExecutionTime = watch.ElapsedMilliseconds, Message = $"{message}, DB Version = {testResult}" }; return(result); }
public static List <MonitoringResult> GenerateMonitoringResult(int count, MonitoredEndpoint endpoint, User owner, int startId = 1) { var result = new List <MonitoringResult>(); count += startId; for (int i = startId; i < count; i++) { MonitoringResult monitoringResult = new MonitoringResult() { Id = i, DateOfCheck = DateTime.Now, ReturnedHttpStatusCode = 100, ReturnedPayload = String.Format("Payload for id {0}", i), MonitoredEndpointForeignKey = endpoint.Id, MonitoredEndpoint = endpoint }; result.Add(monitoringResult); } return(result); }
/// <summary> /// Query all the monitored devices for data received by the hub /// </summary> /// <returns></returns> public List<MonitoringResult> Monitor(string deviceId, int lastMaxSample = -1, int timeOut = 1) { if (_internalCallCount == 0) timeOut = FIRST_CALL_TIMEOUT_SECONDS; if (_monitoringResults == null) _monitoringResults = new Dictionary<string, List<MonitoringResult>>(); try { int i = 0; while(i < 2) // On the first call we need to execute the loop twice for some unknown Azure IoTHub { foreach (var e in _eventHubReceivers) { if (deviceId == e.Key.DeviceId) { // TODO: we need to get all the data from the start time var eventDatas = _eventHubReceivers[e.Key].Receive(MAX_SAMPLE_TO_ASK_FOR_SINCE_START_TIME, TimeSpan.FromSeconds(timeOut)); foreach (var eventData in eventDatas) { var data = Encoding.UTF8.GetString(eventData.GetBytes()); DateTime enqueuedTime = eventData.EnqueuedTimeUtc.ToLocalTime(); var mr = new MonitoringResult {DeviceId = e.Key.DeviceId, EnqueuedTime = enqueuedTime}; mr.Properties = AzureIoTDevice.Deserialize<Dictionary<string, object>>(data); if (!_monitoringResults.ContainsKey(deviceId)) _monitoringResults.Add(deviceId, new List<MonitoringResult>()); _monitoringResults[deviceId].Add(mr); } if (this._cancellationTokenSource != null) this._cancellationTokenSource.Token.ThrowIfCancellationRequested(); } } i++; if (_internalCallCount == 0) Thread.Sleep(1000); // Looks like waiting 1 second and re trying make a difference else break; } } catch (Exception ex) { if (this._cancellationTokenSource != null && this._cancellationTokenSource.Token.IsCancellationRequested) { Console.WriteLine("Exiting monitoring"); // Exit mode } else { Console.WriteLine(ex.ToString()); FailedState = true; } } _internalCallCount++; if (_monitoringResults.ContainsKey(deviceId)) { // The data is order by : if we ask the 32 since the specified startTime // We get the first 32 since the specified startTime and not the last // For assume that we got all the sample since the specified startTime and // and only key the LAST lastMaxSample while (_monitoringResults[deviceId].Count > lastMaxSample) { //_monitoringResults[deviceId].RemoveAt(_monitoringResults[deviceId].Count-1); _monitoringResults[deviceId].RemoveAt(0); } return _monitoringResults[deviceId]; } else return new List<MonitoringResult>(); }
public void GetMonitoringResultCallback(MonitoringResult monitoringResult, object state) { var context = (IRestRequestContext)state; fiber.Enqueue(() => HandleGetMonitoringResult(monitoringResult, context)); }
/// <summary> /// Construtor /// </summary> /// <param name="log">logger para monitoramento de endpoints</param> public Monitoring(ILogger <Monitoring> log) { this.log = log; result = new MonitoringResult(); stopwatch = new Stopwatch(); }
private async Task <bool> SaveMonitoringResultAsync(MonitoredEndpoint endpoint, MonitoringResult monitoringResult) { var result = false; try { using (var scope = _scopeFactory.CreateScope()) { var dbContext = scope.ServiceProvider.GetRequiredService <DatabaseContext>(); dbContext.MonitoredEndpoint.Update(endpoint); dbContext.MonitoringResult.Add(monitoringResult); await dbContext.SaveChangesAsync(); result = true; } } catch (Exception ex) { Log.Logger.ForContext(typeof(MonitoringWorker)).Error(ex, String.Format("ERROR SAVING CHANGES TO DB FOR ENDPOINT ID {0}", endpoint.Id)); } return(result); }