private static Exception createWebServiceException(Exception e) { if (!(e is Wcf.AccessDeniedException)) { TelemetryStatics.ReportError(e); } return(new FaultException(e.ToString())); }
/// <summary> /// Executes the specified method. Returns true if it is successful. If an exception occurs, this method returns false and details about the exception are emailed /// to the developers and logged. This should not be necessary in web applications, as they have their own error handling. /// Prior to calling this, you should be sure that system logic initialization has succeeded. This almost always means that ExecuteAppWithStandardExceptionHandling /// has been called somewhere up the stack. /// This method has no side effects other than those of the given method and the email/logging that occurs in the event of an error. This can be used /// repeatedly inside any application as an alternative to a try catch block. /// </summary> public static bool ExecuteBlockWithStandardExceptionHandling(Action method) { assertClassInitialized(); try { method(); return(true); } catch (Exception e) { TelemetryStatics.ReportError(e); return(false); } }
/// <summary> /// Performs cleanup activities so the application can be shut down. /// </summary> public static void CleanUp() { assertClassInitialized(); try { globalInitializer.CleanUpStatics(); AppMemoryCache.CleanUp(); } catch (Exception e) { TelemetryStatics.ReportError("An exception occurred during application cleanup:", e); } }
/// <summary> /// Executes the specified method. Returns 0 if it is successful. If an exception occurs, this method returns 1 and details about the exception are emailed /// to the developers and logged. This should only be used at the root level of a console application because it checks to ensure the system logic has /// initialized properly and its return code is designed to be useful from the command line of such an application. Throw a DoNotEmailOrLogException to /// cause this method to return 1 without emailing or logging the exception. /// </summary> public static int ExecuteAppWithStandardExceptionHandling(Action method) { assertClassInitialized(); if (secondaryInitFailed) { return(1); } try { method(); } catch (Exception e) { if (!(e is DoNotEmailOrLogException)) { TelemetryStatics.ReportError(e); } return(1); } return(0); }
/// <summary> /// Initializes the class. This includes loading application settings from the configuration file. The application name should be scoped within the system. /// For non web applications, this method must be called directly from the main executable assembly and not from a supporting library. /// /// To debug this method, create a folder called C:\AnyoneFullControl and give Everyone full control. A file will appear in that folder explaining how far /// it got in init. /// </summary> /// <param name="globalInitializer">The system's global initializer. Do not pass null.</param> /// <param name="appName"></param> /// <param name="isClientSideProgram"></param> /// <param name="useRelativeInstallationPath">Pass true to use a relative path for the installation folder. This means that the folder will be located using /// the working directory rather than the assembly path. Use with caution.</param> /// <param name="mainDataAccessStateGetter">A method that returns the current main data-access state whenever it is requested, including during this /// AppTools.Init call. Do not allow multiple threads to use the same state at the same time. If you pass null, the data-access subsystem will not be /// available in the application.</param> public static void Init( SystemInitializer globalInitializer, string appName, bool isClientSideProgram, bool useRelativeInstallationPath = false, Func <DataAccessState> mainDataAccessStateGetter = null) { var initializationLog = "Starting init"; try { if (initialized) { throw new ApplicationException("This class can only be initialized once."); } if (globalInitializer == null) { throw new ApplicationException("The system must have a global initializer and you must pass an instance of it to AppTools.Init."); } // Initialize ConfigurationStatics, including the general provider, before the exception handling block below because it's reasonable for the exception // handling to depend on this. ConfigurationStatics.Init(useRelativeInstallationPath, globalInitializer.GetType(), appName, isClientSideProgram, ref initializationLog); // Setting the initialized flag to true must be done before executing the secondary init block below so that exception handling works. initialized = true; initializationLog += Environment.NewLine + "Succeeded in primary init."; } catch (Exception e) { initializationLog += Environment.NewLine + e; StandardLibraryMethods.EmergencyLog("Initialization log", initializationLog); throw; } try { var asposeLicense = ConfigurationStatics.SystemGeneralProvider.AsposeLicenseName; if (asposeLicense.Any()) { new Aspose.Pdf.License().SetLicense(asposeLicense); new Aspose.Words.License().SetLicense(asposeLicense); } // This initialization could be performed using reflection. There is no need for AppTools to have a dependency on these classes. AppMemoryCache.Init(); BlobFileOps.Init(); DataAccessStatics.Init(); DataAccessState.Init(mainDataAccessStateGetter); EncryptionOps.Init(); HtmlBlockStatics.Init(); InstallationSupportUtility.ConfigurationLogic.Init1(); UserManagementStatics.Init(); AppTools.globalInitializer = globalInitializer; globalInitializer.InitStatics(); } catch (Exception e) { secondaryInitFailed = true; // Suppress all exceptions since they would prevent apps from knowing that primary initialization succeeded. EWF apps need to know this in order to // automatically restart themselves. Other apps could find this knowledge useful as well. try { TelemetryStatics.ReportError("An exception occurred during application initialization:", e); } catch {} } }
public static void EmailAndLogError(string prefix, Exception exception) { TelemetryStatics.ReportError(prefix, exception); }
public static void EmailAndLogError(Exception e) { TelemetryStatics.ReportError(e); }