public IAsyncResult BeginMethod(System.AsyncCallback callback, object state) { this.BeginMethodCount++; if (BeginMethodCount < CountToThrowAtBegin) { if (ExceptionToThrowAtBegin != null) { throw ExceptionToThrowAtBegin; } } if (ThrowFatalExceptionAtBegin == true) { if (FatalException != null) { Console.WriteLine("Throwing exception of type {0}", FatalException.GetType().ToString()); throw FatalException; } } var noOperationAction = new Action(() => { }); var asyncResult = noOperationAction.BeginInvoke(callback, state); return(asyncResult); }
public void ArchiveLogFiles(string applicationName, FileLoggerOptions options, string logFileNamePattern) { try { foreach (string LogFilePath in _FileSystem.EnumerateFiles( options.LogFileDirectory !, FileNameGenerator.GenerateWildcardFileName(applicationName, logFileNamePattern), SearchOption.TopDirectoryOnly)) { if (_LogFiles.Any(i => i.Value.FinalFullPath == LogFilePath)) { continue; } if (_FileSystem.GetFileCreationTimeUtc(LogFilePath) < DateTime.UtcNow.Date) { TryArchiveLogFile(options, LogFilePath); } } } #pragma warning disable CA1031 // Do not catch general exception types catch (Exception FatalException) #pragma warning restore CA1031 // Do not catch general exception types { Console.Error.WriteLine(FatalException.ToString()); } }
public async Task Start <TData, TStep>(TData data, Action <object> onCompletedWorkflow) where TData : new() where TStep : Step { _logger.Log(LogLevel.Trace, "Main Workflow started."); var task = _mainWorkflowManager.Start <TData, TStep>(data, onCompletedWorkflow); await task; if (task.IsCompletedSuccessfully) { _logger.Log(LogLevel.Trace, "Main Workflow completed successfully."); } if (task.IsCanceled) { _logger.Log(LogLevel.Warning & LogLevel.Trace, "Main Workflow was canceled."); } if (task.Exception != null) { _logger.LogFatalException(task.Exception); } if (task.IsFaulted) { _logger.LogFatalException(FatalException.GetFatalException("Main workflow stopped unexpected.")); } }
protected StepDependencyPack GetStepDependencyPack <T>() where T : Step { var type = typeof(T); var pack = _stepDependencyPacks.SingleOrDefault(x => x.StepType == type); if (pack == null) { throw FatalException.GetFatalException(string.Empty); } return(pack); }
private async Task ThrowOnFatalResponseAsync(HttpResponseMessage response, string requestUrl, int attemptIndex, string identity, List <HttpResponseSignature> allowlistedResponses) { if (response.IsSuccessStatusCode || response.StatusCode == HttpStatusCode.NotModified) { return; } string responseContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false); HttpStatusCode responseStatusCode = response.StatusCode; try { JObject responseContentObject = JObject.Parse(responseContent); string message = responseContentObject.SelectToken("$.message").Value <string>(); foreach (HttpResponseSignature allowlistedResponse in allowlistedResponses) { if (allowlistedResponse.statusCode == responseStatusCode && allowlistedResponse.Matches(responseStatusCode, message)) { Dictionary <string, string> allowlistedResponseProperties = new Dictionary <string, string>() { { "RequestUrl", requestUrl }, { "ResponseStatusCode", responseStatusCode.ToString() }, { "ResponseMessage", message }, }; this.telemetryClient.TrackEvent("AllowlistedResponse", allowlistedResponseProperties); return; } } } catch (Exception) { // Done as best effort, ignore since the response content is already logged. } Exception fatalException = new FatalException($"Request to url '{requestUrl}' failed with status code: '{responseStatusCode}'. Response content: '{responseContent}'."); Dictionary <string, string> properties = new Dictionary <string, string>() { { "Url", requestUrl }, { "Identity", identity }, { "ResponseContent", responseContent }, { "ResponseStatusCode", responseStatusCode.ToString() }, { "AttemptIndex", attemptIndex.ToString() }, { "Retried", false.ToString() }, { "Fatal", true.ToString() }, }; this.telemetryClient.TrackException(fatalException, "Web request failed.", properties); this.failedRequestCount++; throw fatalException; }
public IWorkflow <T> CreateWorkflow <T>(T workflowData, string key) where T : new() { FatalException.ArgumentNullException(workflowData, nameof(workflowData)); var wf = new Workflow <T> { WorkflowData = workflowData }; key = workflowData.GetType().GenerateKey(key); _workflows.Add(key, wf); return(wf); }
public void RunInBackground(Step step, string key = null) { key = step.GetType().GenerateKey(key); if (MemoryProcesses.ContainsKey(key)) { FatalException.ArgumentException($"Key already exists for background process : {key}"); } var flow = this.RunWorkflowAsync(step); MemoryProcesses.Add(key, flow); }
public async Task <TFlow> Run <TFlow, TStep>(TStep step) where TFlow : IWorkflow where TStep : Step { var result = await this.RunWorkflowAsync(step); if (result is TFlow correctResultType) { return(correctResultType); } throw FatalException.GetFatalException(""); }
public async Task <TFlow> AwaitProcessAsync <TFlow, TStep>(string key = null) where TFlow : IWorkflow where TStep : Step <TFlow> { key = typeof(TStep).GenerateKey(key); if (MemoryProcesses.TryGetValue(key, out var value)) { return(value is Task <TFlow> task ? await task : throw FatalException.GetFatalException("")); } throw FatalException.GetFatalException("");; }
public Result <string> GetErrorMessageByErrorCode(string code) { try { return(Result <String> .Succeed(ExceptionMessages.ResourceManager.GetString(code))); } catch (BaseException exc) { return(Result <string> .Failure(exc)); } catch (Exception unknownExc) { var fatalExc = new FatalException(unknownExc); return(Result <string> .Failure(fatalExc)); } }
public static bool IsNotFatal(this Exception e) { Exception exception = e; Type exceptionType = e.GetType(); if (FatalTypes.Contains(exceptionType)) { StackTrace stackTrace = new StackTrace(1, true); string stackTraceText = stackTrace.ToString(); string message = $"Exception type is fatal: {exceptionType}, {e}\n at \n{stackTraceText}"; FatalException?.Invoke(null, new FatalExceptionEventArgs(message, exception)); return(false); } return(true); }
public Result HasAccessToMenu(Guid menuId, IEnumerable <string> roleNames) { try { var res = _roleMenuRepository.HasAccessToMenu(menuId, roleNames); return(res == true?Result.Succeed() : Result.Failure()); } catch (BaseException exc) { return(Result.Failure(exc)); } catch (Exception unknownExc) { var fatalExc = new FatalException(unknownExc); return(Result.Failure(fatalExc)); } }
public virtual Result <IQueryable <T> > GetAll(ISpecification <T> spec) { try { var result = _repository.GetAll(spec); return(Result <IQueryable <T> > .Succeed(result)); } catch (BaseException exc) { return(Result <IQueryable <T> > .Failure(exc)); } catch (Exception unknownExc) { var fatalExc = new FatalException(unknownExc); return(Result <IQueryable <T> > .Failure(fatalExc)); } }
public virtual async Task <Result> EditAsync(T model) { try { await _repository.UpdateAsync(model); return(Result.Succeed()); } catch (BaseException exc) { return(Result.Failure(exc)); } catch (Exception unknownExc) { var fatalExc = new FatalException(unknownExc); return(Result.Failure(fatalExc)); } }
public IWorkflow <T> GetWorkflow <T>(string key) where T : new() { key = typeof(T).GenerateKey(key); if (_workflows.TryGetValue(key, out var value)) { if (value is IWorkflow <T> wf) { return(wf); } else { throw FatalException.GetFatalException(string.Empty); } } throw FatalException.GetFatalException(string.Empty); }
/* private string GenerateIdentificationNumberForOrganization(Organization model) * { * StringBuilder result = new StringBuilder(); * * if (model.ProductType == ProductType.CarParts.ToString()) * result.Append("CR"); * else * result.Append("DF"); * * result.Append(DateTime.Now.ToString("yyyyMMdd")); * * var lastOrganizationInThisMonth = _organizationRepository.GetAll() * .Where(m => m.CreatedDate.Year == DateTime.Now.Year && m.CreatedDate.Month == DateTime.Now.Month) * .OrderByDescending(m => m.CreatedDate) * .FirstOrDefault(); * int incrementNum = 0; * if (lastOrganizationInThisMonth != null) * { * var num = lastOrganizationInThisMonth.IdentificationNumber.Substring(lastOrganizationInThisMonth.IdentificationNumber.Length - 3, 3); * incrementNum = Convert.ToInt32(num); * } * incrementNum++; * result.Append(incrementNum.ToString().PadLeft(3, '0')); * return result.ToString(); * }*/ public async Task <Result <int> > ChangeTitleAsync(string title) { try { var res = await _organizationRepository.ChangeTitleAsync(title); return(Result <int> .Succeed(res)); } catch (BaseException exc) { return(Result <int> .Failure(exc)); } catch (Exception unknownExc) { var fatalExc = new FatalException(unknownExc); return(Result <int> .Failure(fatalExc)); } }
public virtual async Task <Result <T> > GetByIdAsync(Guid id) { try { var result = await _repository.GetByIdAsync(id); return(Result <T> .Succeed(result)); } catch (BaseException exc) { return(Result <T> .Failure(exc)); } catch (Exception unknownExc) { var fatalExc = new FatalException(unknownExc); return(Result <T> .Failure(fatalExc)); } }
/// <summary> /// Initializes a new BoxCutter for debugging. /// </summary> /// <param name="sortType">True if you want the logs written to be sorted by writer, false if you want them to be written /// chronologically. If true, the buffer has to be flushed when the game closes; if it closes unexpectedly the file may /// be empty. Also, it keeps everything written in memory; this could become massive fast.</param> /// <param name="overwriteOldLogs">True if you want the log to save to debug.log, false if you want the date and time appended /// to the filename.</param> public BoxCutter(bool sortLogs, bool overwriteOldLogs, string savePath) { #if DEBUG || TRACE string path; this.sortLogs = sortLogs; overwriteLogs = overwriteOldLogs; d = new Default(); n = new NonFatalException(); f = new FatalException(); if(overwriteOldLogs) { path = savePath + "debug.log"; if(File.Exists(path)) file = File.Open(path, FileMode.Truncate); else file = File.Open(path, FileMode.CreateNew); } else { IEnumerable<string> filenames = Directory.EnumerateFiles(savePath, "debug*.log"); int debuglogs = filenames.Count<string>(); if(debuglogs > 9) { int logstodelete = debuglogs - 9; for(int i = 0; i < logstodelete; i++) try { File.Delete(filenames.ElementAt(i)); } catch { } } path = savePath + "debug[" + DateTime.Now.ToShortDateString().Replace(@"/", @"-").Replace(@"\", @"-") + "][" + DateTime.Now.ToLongTimeString().Replace(@":", @".") + "].log"; file = File.Open(path, FileMode.Create); } writer = new StreamWriter(file); if(sortLogs) { sortedBuffer = new Dictionary<object, List<string>>(); sortedBuffer.Add(d, new List<string>()); sortedBuffer.Add(n, new List<string>()); sortedBuffer.Add(f, new List<string>()); } #endif }
public Result <IQueryable <Menu> > GetUserMenus(Guid userId) { try { var res = _menuRepository.GetUserMenus(userId); if (res.Any()) { return(Result <IQueryable <Menu> > .Succeed(res)); } return(Result <IQueryable <Menu> > .Failure()); } catch (BaseException exc) { return(Result <IQueryable <Menu> > .Failure(exc)); } catch (Exception unknownExc) { var fatalExc = new FatalException(unknownExc); return(Result <IQueryable <Menu> > .Failure(fatalExc)); } }
public Result <Menu> GetMenuByRouteDetails(string area, string controller, string action) { try { var res = _menuRepository.GetMenuByRouteDetails(area, controller, action); if (res != null) { return(Result <Menu> .Succeed(res)); } return(Result <Menu> .Failure()); } catch (BaseException exc) { return(Result <Menu> .Failure(exc)); } catch (Exception unknownExc) { var fatalExc = new FatalException(unknownExc); return(Result <Menu> .Failure(fatalExc)); } }
public void RemoveWorkflow <TF, TD>(string key) where TF : IWorkflow <TD> where TD : new() { key = typeof(TD).GenerateKey(key); if (_workflows.TryGetValue(key, out var workflow)) { if (workflow is TF) { _workflows.Remove(key); } else { throw FatalException.GetFatalException(string.Empty); } } else { throw FatalException.GetFatalException(string.Empty); } }
static void Main(string[] args) { Application.EnableVisualStyles(); //Application.VisualStyleState = System.Windows.Forms.VisualStyles.VisualStyleState.NoneEnabled; Application.SetCompatibleTextRenderingDefault(false); try { SingleInstanceApplication application = new SingleInstanceApplication(); //SingleInstanceApplication.Application.SplashScreen = new fSplash(); //SingleInstanceApplication.Application.MinimumSplashScreenDisplayTime = 5000; SingleInstanceApplication.Application.UnhandledException += new Microsoft.VisualBasic.ApplicationServices.UnhandledExceptionEventHandler(Application_UnhandledException); SingleInstanceApplication.Application.Run(args); } catch (Exception x) { FatalException x1 = new FatalException("Fatal Exception", x); UIHelper.HandleUIException(x1); x1 = null; UIHelper.AtMng = null; } }
public virtual async Task <Result> RemoveAsync(Guid id) { try { var entity = await GetByIdAsync(id); if (!entity.IsSucceed) { return(Result.Failure(entity.ExceptionMessage)); } await _repository.DeleteAsync(entity.Data); return(Result.Succeed()); } catch (BaseException exc) { return(Result.Failure(exc)); } catch (Exception unknownExc) { var fatalExc = new FatalException(unknownExc); return(Result.Failure(fatalExc)); } }
private void PerformLog(LogEntry logEntry) { RequestTelemetry requestTelemetry = null; if (logEntry.LogData.Any(ld => ld.Key == nameof(IRequestInformationProvider.DisplayUrl)) && HttpContextAccessor.HttpContext != null) { HttpContext httpContext = HttpContextAccessor.HttpContext; if (!httpContext.Items.ContainsKey(nameof(RequestTelemetry))) { throw new InvalidOperationException($"Register app insight logger using dependencyManager.{nameof(IDependencyManagerExtensions.RegisterApplicationInsights)}();"); } requestTelemetry = (RequestTelemetry)httpContext.Items[nameof(RequestTelemetry)]; IUserInformationProvider userInformationProvider = httpContext.RequestServices.GetRequiredService <IUserInformationProvider>(); if (userInformationProvider.IsAuthenticated()) { requestTelemetry.Context.User.AccountId = requestTelemetry.Context.User.AuthenticatedUserId = userInformationProvider.GetCurrentUserId(); } } List <KeyVal> keyValues = logEntry.LogData.Select(ld => { string k = ld.Key; if (k == nameof(IRequestInformationProvider.HttpMethod) || k == nameof(IRequestInformationProvider.DisplayUrl) || k == nameof(IRequestInformationProvider.UserAgent) || k == "UserId" || k == "ResponseStatusCode" || k == nameof(IRequestInformationProvider.ClientIp) || ld.Value == null) { return(null); // Already being logged by app insights! } string v = null; if (ld.Value is string valueAsStr) { v = valueAsStr; } if (k == "ClientLogs" || k == "OperationArgs") { v = Formatter.Serialize(ld.Value); } else { v = ld.Value.ToString(); } return(new KeyVal { Key = k, Value = v }); }) .Where(d => d != null) .ToList(); keyValues.Add(new KeyVal { Key = nameof(LogEntry.MemoryUsage), Value = logEntry.MemoryUsage.ToString() }); if (logEntry.AppServerDateTime.HasValue) { keyValues.Add(new KeyVal { Key = nameof(LogEntry.AppServerDateTime), Value = logEntry.AppServerDateTime.ToString() }); } keyValues.Add(new KeyVal { Key = nameof(LogEntry.Severity), Value = logEntry.Severity }); keyValues.Add(new KeyVal { Key = nameof(LogEntry.Message), Value = logEntry.Message }); if (logEntry.Id.HasValue) { keyValues.Add(new KeyVal { Key = nameof(LogEntry.Id), Value = logEntry.Id.ToString() }); } if (logEntry.AppServerThreadId.HasValue) { keyValues.Add(new KeyVal { Key = nameof(LogEntry.AppServerThreadId), Value = logEntry.AppServerThreadId.ToString() }); } if (requestTelemetry != null) { LogData userAgent = logEntry.LogData.FirstOrDefault(ld => ld.Key == nameof(IRequestInformationProvider.UserAgent)); if (userAgent != null) { requestTelemetry.Context.User.UserAgent = (string)userAgent.Value; } foreach (KeyVal keyVal in keyValues.OrderBy(kv => kv.Key)) { if (!requestTelemetry.Properties.ContainsKey(keyVal.Key)) { requestTelemetry.Properties.Add(keyVal.Key, keyVal.Value); } } } else { TelemetryClient telemetryClient = new TelemetryClient(); Dictionary <string, string> customData = new Dictionary <string, string>(); foreach (KeyVal keyVal in keyValues.OrderBy(kv => kv.Key)) { if (!customData.ContainsKey(keyVal.Key)) { customData.Add(keyVal.Key, keyVal.Value); } } Exception ex = null; try { customData.TryGetValue("ExceptionTypeAssemblyQualifiedName", out string exceptionTypeAssemblyQualifiedName); if (!string.IsNullOrEmpty(exceptionTypeAssemblyQualifiedName)) { ex = (Exception)Activator.CreateInstance(Type.GetType(exceptionTypeAssemblyQualifiedName) ?? throw new InvalidOperationException($"{exceptionTypeAssemblyQualifiedName} could not be found"), args: new object[] { logEntry.Message }); } } catch { } if (ex == null) { switch (logEntry.Severity) { case "Information": ex = new InformationException(logEntry.Message); break; case "Warning": ex = new WarningException(logEntry.Message); break; case "Error": ex = new ErrorException(logEntry.Message); break; case "Fatal": ex = new FatalException(logEntry.Message); break; default: ex = new Exception(logEntry.Message); break; } } telemetryClient.TrackException(ex, customData); } }
private void PerformLog(LogEntry logEntry) { TelemetryClient telemetryClient = null; IUserInformationProvider userInformationProvider = null; bool isPerRequestTelemetryClient = false; if (logEntry.LogData.Any(ld => ld.Key == nameof(IRequestInformationProvider.RequestUri))) { IOwinContext owinContext = OwinContext.Value; IDependencyResolver resolver = owinContext.GetDependencyResolver(); telemetryClient = resolver.Resolve <TelemetryClient>(); userInformationProvider = resolver.Resolve <IUserInformationProvider>(); isPerRequestTelemetryClient = true; } List <KeyVal> keyValues = logEntry.LogData.Select(ld => { string k = ld.Key; if (k == nameof(IRequestInformationProvider.HttpMethod) || k == nameof(IRequestInformationProvider.RequestUri) || k == nameof(IRequestInformationProvider.UserAgent) || k == "UserId" || k == "ResponseStatusCode" || k == nameof(IRequestInformationProvider.ClientIp) || ld.Value == null) { return(null); } string v = null; if (ld.Value is string valueAsStr) { v = valueAsStr; } if (k == "ClientLogs" || k == "OperationArgs") { v = Formatter.Serialize(ld.Value); } else { v = ld.Value.ToString(); } return(new KeyVal { Key = k, Value = v }); }) .Where(d => d != null) .ToList(); try { keyValues.Add(new KeyVal { Key = nameof(LogEntry.AppEnvironmentName), Value = logEntry.AppEnvironmentName }); if (logEntry.AppServerProcessId.HasValue) { keyValues.Add(new KeyVal { Key = nameof(LogEntry.AppServerProcessId), Value = logEntry.AppServerProcessId.ToString() }); } keyValues.Add(new KeyVal { Key = nameof(LogEntry.AppServerAppDomainName), Value = logEntry.AppServerAppDomainName }); keyValues.Add(new KeyVal { Key = nameof(LogEntry.AppServerOSVersion), Value = logEntry.AppServerOSVersion }); if (logEntry.AppServerDateTime.HasValue) { keyValues.Add(new KeyVal { Key = nameof(LogEntry.AppServerDateTime), Value = logEntry.AppServerDateTime.ToString() }); } keyValues.Add(new KeyVal { Key = nameof(LogEntry.AppServerName), Value = logEntry.AppServerName }); if (logEntry.AppWasInDebugMode.HasValue) { keyValues.Add(new KeyVal { Key = nameof(LogEntry.AppWasInDebugMode), Value = logEntry.AppWasInDebugMode.ToString() }); } keyValues.Add(new KeyVal { Key = nameof(LogEntry.AppServerUserAccountName), Value = logEntry.AppServerUserAccountName }); keyValues.Add(new KeyVal { Key = nameof(LogEntry.AppVersion), Value = logEntry.AppVersion }); keyValues.Add(new KeyVal { Key = nameof(LogEntry.ApplicationName), Value = logEntry.ApplicationName }); keyValues.Add(new KeyVal { Key = nameof(LogEntry.Severity), Value = logEntry.Severity }); keyValues.Add(new KeyVal { Key = nameof(LogEntry.Message), Value = logEntry.Message }); if (logEntry.Id.HasValue) { keyValues.Add(new KeyVal { Key = nameof(LogEntry.Id), Value = logEntry.Id.ToString() }); } if (logEntry.AppServerThreadId.HasValue) { keyValues.Add(new KeyVal { Key = nameof(LogEntry.AppServerThreadId), Value = logEntry.AppServerThreadId.ToString() }); } if (isPerRequestTelemetryClient == true) { if (userInformationProvider.IsAuthenticated()) { telemetryClient.Context.User.AccountId = telemetryClient.Context.User.AuthenticatedUserId = userInformationProvider.GetCurrentUserId(); } LogData userAgent = logEntry.LogData.FirstOrDefault(ld => ld.Key == nameof(IRequestInformationProvider.UserAgent)); if (userAgent != null) { telemetryClient.Context.User.UserAgent = (string)userAgent.Value; } foreach (KeyVal keyVal in keyValues.OrderBy(kv => kv.Key)) { if (!telemetryClient.Context.Properties.ContainsKey(keyVal.Key)) { telemetryClient.Context.Properties.Add(keyVal.Key, keyVal.Value); } } } else { telemetryClient = new TelemetryClient(); Dictionary <string, string> customData = new Dictionary <string, string>(); foreach (KeyVal keyVal in keyValues.OrderBy(kv => kv.Key)) { if (!customData.ContainsKey(keyVal.Key)) { customData.Add(keyVal.Key, keyVal.Value); } } Exception ex = null; try { customData.TryGetValue("ExceptionTypeAssemblyQualifiedName", out string exceptionTypeAssemblyQualifiedName); if (!string.IsNullOrEmpty(exceptionTypeAssemblyQualifiedName)) { ex = (Exception)Activator.CreateInstance(Type.GetType(exceptionTypeAssemblyQualifiedName) ?? throw new InvalidOperationException($"{exceptionTypeAssemblyQualifiedName} could not be found"), args: new object[] { logEntry.Message }); } } catch { } if (ex == null) { switch (logEntry.Severity) { case "Information": ex = new InformationException(logEntry.Message); break; case "Warning": ex = new WarningException(logEntry.Message); break; case "Error": ex = new ErrorException(logEntry.Message); break; case "Fatal": ex = new FatalException(logEntry.Message); break; default: ex = new Exception(logEntry.Message); break; } } telemetryClient.TrackException(ex, customData); } } finally { telemetryClient.Flush(); } }
private static void LogFailedTask(Task task) { FatalException?.Invoke(null, new FatalExceptionEventArgs( "RunInBackground task failed", task.Exception)); }