UnhandledException and FirstChanceException events not being invoked

Question

I'm trying to create a global exception handler, and would like to have a reference to the Exception to do some special handling. Is there a way to receive exceptions like this?

I'm aware of Application.LogCallback, but it does not return the Exception object. ILogHandler.LogException() does provide the Exception, but only if Debug.LogException() is called. UnhandledException gets a callback when an exception is thrown on a different thread, but not the main thread. Sample:

 public class ExceptionHandler : MonoBehaviour, ILogHandler
 {
     private static ILogHandler defaultLogHandler;
 
     public void Start()
     {
         AppDomain.CurrentDomain.UnhandledException += OnUnhandledException;
         AppDomain.CurrentDomain.FirstChanceException += OnFirstChanceException;
         defaultLogHandler = Debug.unityLogger.logHandler;
         Debug.unityLogger.logHandler = this;
 
         GetComponent<ExceptionThrower>().ThrowExceptions();
     }
 
     public static void OnUnhandledException(object sender, UnhandledExceptionEventArgs args)
     {
         Debug.LogWarning($"---Unhandled Exception--- {(Exception)args.ExceptionObject}");
     }
 
     public static void OnFirstChanceException(object sender, FirstChanceExceptionEventArgs args)
     {
         Debug.LogWarning($"---First Chance Exception--- {args.Exception}");
     }
 
     public void LogFormat(LogType logType, Object context, string format, params object[] args)
     {
         defaultLogHandler.LogFormat(logType, context, format, args);
     }
 
     public void LogException(Exception exception, Object context)
     {
         Debug.LogWarning($"---LogException--- {exception}");
     }
 }

 public class ExceptionThrower : MonoBehaviour
 {
     public void ThrowExceptions()
     {
         this.StartCoroutine(this.ExceptionCoroutine());
 
         Debug.LogException(new Exception("Debug.LogException"));
 
         new Thread(() => 
                 {
                     try { throw new Exception("Caught Exception on spawned thread."); }
                     catch (Exception) {}
                 }).Start();
 
         new Thread(() =>
                 {
                     throw new Exception("Unhandled Exception on spawned thread.");
                 }).Start();
 
         try { throw new Exception("Caught exception on main thread."); }
         catch (Exception) {}
 
         throw new Exception("Unhandled Exception on main thread.");
     }
 
     private IEnumerator ExceptionCoroutine()
     {
         yield return null;
 
         try { throw new Exception("Caught exception on coroutine."); }
         catch (Exception) {}
 
         throw new Exception("Unhandled Exception on coroutine.");
     }
 }

 Output:
 ---LogException--- System.Exception: Debug.LogException
 Exception: Unhandled Exception on main thread.
 ---Unhandled Exception--- System.Exception: Unhandled Exception on spawned thread.
 Exception: Unhandled Exception on coroutine.

Answer 1

Yes. Still a problem. The best I have found is to detect that a main thread exception is about to be reported and do something with the report (you won't have access to the exception object, just the text).

             Application.logMessageReceived += logMsgRecv;
             Application.logMessageReceivedThreaded += logMsgRecv;
     
     ...
     
         // When Unity log receives a message, this gets an event called.  We can tell if an exception happens this way
         public void logMsgRecv(string _condition, string _stackTrace, LogType _type)
         {
             if (_type==LogType.Exception)
             {
                 ... do whatever you want ...
             }
         }

What I would mention is that, if you look at the call stack you recevied in this event calllback, it's pretty clear that Unity itself has a try/catch and their own handling inside coroutines and main thread C# execution. See here:

 (Mono JIT Code) [CrashHandler.cs:60] CrashHandler:logMsgRecv (string,string,UnityEngine.LogType)
 (Mono JIT Code) [Application.cs:121] UnityEngine.Application:CallLogCallback (string,string,UnityEngine.LogType,bool)
 (Mono JIT Code) (wrapper runtime-invoke) <Module>:runtime_invoke_void_object_object_int_byte (object,intptr,intptr,intptr)
 (mono-2.0-bdwgc) [mini-runtime.c:2809] mono_jit_runtime_invoke 
 (mono-2.0-bdwgc) [object.c:2919] do_runtime_invoke 
 (mono-2.0-bdwgc) [object.c:2966] mono_runtime_invoke 
 (Unity) scripting_method_invoke
 (Unity) ScriptingInvocation::Invoke
 (Unity) ScriptingInvocation::Invoke<ScriptingObjectPtr>
 (Unity) Application_Bindings::LogCallbackImplementation
 (Unity) DebugStringToFilePostprocessedStacktrace
 (Unity) DebugStringToFile
 (Unity) Scripting::LogException
 (Unity) MonoBehaviour::InvokeMethodOrCoroutineChecked
 (Unity) MonoBehaviour::Start

My guess is there's no such thing as an unhandled exception on the main thread, which is why you aren't going to get that callback.

Best, JH

UnhandledException and FirstChanceException events not being invoked

1 Reply

Your answer

Welcome to Unity Answers

Follow this Question

Related Questions