/// <summary>
/// Any uncaught exceptions are thrown to here
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void CoreApplication_UnhandledErrorDetected(object sender, UnhandledErrorDetectedEventArgs e)
{
try
{
LogChannel.LogMessage("Caught the exception");
e.UnhandledError.Propagate();
}
catch (Exception ex)
{
//logChannel.LogMessage(string.Format("UnhandledErro: 0x{0:X})", ex.HResult), LoggingLevel.Critical);
LogChannel.LogMessage(string.Format("Effor Message: {0}", ex.Message));
if (LogSession != null)
{
//var filename = DateTime.Now.ToString("yyyyMMdd-HHmmssTzz") + ".etl";
var filename = DateTime.Now.ToString("yyyyMMdd") + ".etl";
var logSaveTask = LogSession
.SaveToFileAsync(logUploadFolder, filename)
.AsTask();
logSaveTask.Wait();
}
// throw;
}
}
private async void CoreApplication_UnhandledErrorDetected(object sender, UnhandledErrorDetectedEventArgs e)
{
try
{
e.UnhandledError.Propagate();
}
catch (Exception ex)
{
StorageFile file = null;
if (AnalyticsInfo.VersionInfo.DeviceFamily == "Windows.Mobile")
{
file = await ApplicationData.Current.LocalFolder.CreateFileAsync("ZSCY_Mobile_Log.txt", CreationCollisionOption.OpenIfExists);
}
else
{
file = await ApplicationData.Current.LocalFolder.CreateFileAsync("ZSCY_Log.txt", CreationCollisionOption.OpenIfExists);
}
string errorText = $"[{DateTime.Now.ToString()}]\r\n{ex.StackTrace}\r\n";
await FileIO.AppendTextAsync(file, errorText, Windows.Storage.Streams.UnicodeEncoding.Utf8);
}
finally
{
#if DEBUG
Application.Current.Exit();
#else
#endif
}
}
/// <summary>
/// Any uncaught exceptions are thrown to here
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void CoreApplication_UnhandledErrorDetected(object sender, UnhandledErrorDetectedEventArgs e)
{
try
{
LogChannel.LogMessage("Caught the exception");
e.UnhandledError.Propagate();
}
catch (Exception ex)
{
//logChannel.LogMessage(string.Format("UnhandledErro: 0x{0:X})", ex.HResult), LoggingLevel.Critical);
LogChannel.LogMessage(string.Format("Effor Message: {0}", ex.Message));
if (LogSession != null)
{
//var filename = DateTime.Now.ToString("yyyyMMdd-HHmmssTzz") + ".etl";
var filename = DateTime.Now.ToString("yyyyMMdd") + ".etl";
var logSaveTask = LogSession
.SaveToFileAsync(logUploadFolder, filename)
.AsTask();
logSaveTask.Wait();
}
// throw;
}
}
private void CoreApplication_UnhandledErrorDetected(object sender, UnhandledErrorDetectedEventArgs e)
{
CoreEventSource.Log.LogVerbose("UnhandledExceptionTelemetryModule.CoreApplication_UnhandledErrorDetected started successfully");
try
{
// intentionally propagating exception to get the exception object that crashed the app.
e.UnhandledError.Propagate();
}
catch (Exception eventException)
{
try
{
ITelemetry crashTelemetry = CreateCrashTelemetry(eventException, ExceptionHandledAt.Unhandled);
var client = ((HockeyClient)(HockeyClient.Current));
client.Track(crashTelemetry);
client.Flush();
}
catch (Exception ex)
{
CoreEventSource.Log.LogError("An exeption occured in UnhandledExceptionTelemetryModule.CoreApplication_UnhandledErrorDetected: " + ex);
}
// if we don't throw exception - app will not be crashed. We need to throw to not change the app behavior.
// known issue: stack trace will contain SDK methods from now on.
throw;
}
}
void CoreApplication_UnhandledErrorDetected(object sender, UnhandledErrorDetectedEventArgs ex)
{
try
{
ex.UnhandledError.Propagate();
}
catch (Exception e)
{
Debug.WriteLine("CoreApplication_UnhandledErrorDetected! " + e.Message + e.InnerException);
}
}
private void CoreApplication_UnhandledErrorDetected(object sender, UnhandledErrorDetectedEventArgs e)
{
try
{
_logChannel.LogMessage("Caught and unhandled exception");
e.UnhandledError.Propagate();
}
catch (Exception ex)
{
_logChannel.LogMessage($"Exception Message: {ex.Message}");
}
}
private static void UnhandledError(object sender, UnhandledErrorDetectedEventArgs eventArgs)
{
try
{
eventArgs.UnhandledError.Propagate();
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
Debug.WriteLine(ex.StackTrace);
}
}
private static void UnhandledError(object sender, UnhandledErrorDetectedEventArgs eventArgs)
{
try
{
// A breakpoint here is generally uninformative
eventArgs.UnhandledError.Propagate();
}
catch (Exception e)
{
// Set a breakpoint here:
Debug.WriteLine("Error: {0}", e);
throw;
}
}
private void CoreApplication_UnhandledErrorDetected(object sender, UnhandledErrorDetectedEventArgs e)
{
try
{
e.UnhandledError.Propagate();
}
catch (Exception ex)
{
_loggingChannel.LogMessage($"Unhandled error HResult: {ex.HResult}", LoggingLevel.Critical);
_loggingChannel.LogMessage($"Unhandled error message: {ex.Message}", LoggingLevel.Critical);
SaveFile();
}
}
private async void OnUnhandledErrorDetected(object sender, UnhandledErrorDetectedEventArgs e)
{
try
{
if (sender != null)
{
logChannel.LogMessage(sender.ToString());
}
e.UnhandledError.Propagate();
}
catch (Exception exception)
{
await Log(exception);
}
}
void CoreApplication_UnhandledErrorDetected(object sender, UnhandledErrorDetectedEventArgs e)
{
try
{
e.UnhandledError.Propagate();
}
catch (Exception ex)
{
foreach (var tracker in Trackers)
{
tracker.Send(HitBuilder.CreateException(ex.Message, true).Build());
}
var t = DispatchAsync();
throw;
}
}
private static void OnUnhandledErrorDetected(object sender, UnhandledErrorDetectedEventArgs e)
{
try
{
e.UnhandledError.Propagate();
}
catch (Exception ex)
{
var properties = new Dictionary <string, string>
{
{ "StackTrace", ex.StackTrace },
{ "Message", ex.Message },
};
TelemetryManager.TrackCrash(ex, properties);
}
}
/// <summary>
/// notify users of any errors thrown by the application
/// </summary>
/// <param name="sender">source of the exception</param>
/// <param name="e">the error</param>
private async void OnUnhandledException(object sender, UnhandledErrorDetectedEventArgs e)
{
var err = e.UnhandledError;
if (!err.Handled)
{
try
{
MessageDialog messageDialog = new MessageDialog("There was an error: {0}." + err.ToString());
// Show the message dialog
await messageDialog.ShowAsync();
}
catch (Exception)
{
// fall through
}
finally
{
Application.Current.Exit();
}
}
}
private void CoreApplication_UnhandledErrorDetected(object sender, UnhandledErrorDetectedEventArgs e)
{
CoreEventSource.Log.LogVerbose("UnhandledExceptionTelemetryModule.CoreApplication_UnhandledErrorDetected started successfully");
try
{
// intentionally propagating exception to get the exception object that crashed the app.
e.UnhandledError.Propagate();
}
catch (Exception eventException)
{
try
{
ITelemetry crashTelemetry = CreateCrashTelemetry(eventException, ExceptionHandledAt.Unhandled);
var client = ((HockeyClient)(HockeyClient.Current));
client.Track(crashTelemetry);
client.Flush();
}
catch (Exception ex)
{
CoreEventSource.Log.LogError("An exeption occured in UnhandledExceptionTelemetryModule.CoreApplication_UnhandledErrorDetected: " + ex);
}
// if we don't throw exception - app will not be crashed. We need to throw to not change the app behavior.
// known issue: stack trace will contain SDK methods from now on.
throw;
}
}
private static void UnhandledError(object sender, UnhandledErrorDetectedEventArgs eventArgs)
{
try
{
// A breakpoint here is generally uninformative
eventArgs.UnhandledError.Propagate();
}
catch (Exception e)
{
// Set a breakpoint here:
Debug.WriteLine("Error: {0}", e);
throw;
}
}
