Unity3D unhandled exception not logging

Question

I'm using the following Loom script to execute some client/server communication in Unity3D. My problem is that I use exceptions to notify the client when errors happen on the server, these exceptions currently just quit the thread if left unhandled via the Loom script. What can I do to Debug.Log() the exception if it is unhandled, to notify the developer?

Loom script:

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System;
using System.Threading;
using System.Linq;

public class Loom : MonoBehaviour
{
    public static int maxThreads = 8;
    static int numThreads;

    private static Loom _current;
    private int _count;
    public static Loom Current
    {
        get
        {
            Initialize();
            return _current;
        }
    }

    void Awake()
    {
        _current = this;
        initialized = true;
    }

    static bool initialized;

    static void UnhandledHandler(object sender, UnhandledExceptionEventArgs args) {

        Exception e = (Exception) args.ExceptionObject;
        Debug.Log("MyHandler caught : " + e.Message);
        Debug.Log("Runtime terminating: {0}" + args.IsTerminating);

    }

    static void Initialize()
    {

        if (!initialized)
        {

            if(!Application.isPlaying)
                return;
            initialized = true;
            var g = new GameObject("Loom");
            _current = g.AddComponent<Loom>();
        }

    }

    private List<Action> _actions = new List<Action>();
    public struct DelayedQueueItem
    {
        public float time;
        public Action action;
    }
    private List<DelayedQueueItem> _delayed = new  List<DelayedQueueItem>();

    List<DelayedQueueItem> _currentDelayed = new List<DelayedQueueItem>();

    public static void QueueOnMainThread(Action action)
    {
        QueueOnMainThread( action, 0f);
    }
    public static void QueueOnMainThread(Action action, float time)
    {
        if(time != 0)
        {
            lock(Current._delayed)
            {
                Current._delayed.Add(new DelayedQueueItem { time = Time.time + time, action = action});
            }
        }
        else
        {
            lock (Current._actions)
            {
                Current._actions.Add(action);
            }
        }
    }

    public static Thread RunAsync(Action a)
    {
        Initialize();
        while(numThreads >= maxThreads)
        {
            Thread.Sleep(1);
        }
        Interlocked.Increment(ref numThreads);
        ThreadPool.QueueUserWorkItem(RunAction, a);
        return null;
    }

    private static void RunAction(object action)
    {
        try
        {
            ((Action)action)();
        }
        catch
        {
        }
        finally
        {
            Interlocked.Decrement(ref numThreads);
        }

    }


    void OnDisable()
    {
        if (_current == this)
        {

            _current = null;
        }
    }



    // Use this for initialization
    void Start()
    {

    }

    List<Action> _currentActions = new List<Action>();

    // Update is called once per frame
    void Update()
    {
        lock (_actions)
        {
            _currentActions.Clear();
            _currentActions.AddRange(_actions);
            _actions.Clear();
        }
        foreach(var a in _currentActions)
        {
            a();
        }
        lock(_delayed)
        {
            _currentDelayed.Clear();
            _currentDelayed.AddRange(_delayed.Where(d=>d.time <= Time.time));
            foreach(var item in _currentDelayed)
                _delayed.Remove(item);
        }
        foreach(var delayed in _currentDelayed)
        {
            delayed.action();
        }



    }
}

Answer 1

You can use Reporter . Normally it catches the unhandled errors and sends the stack trace, screen shot and logs as an email to the developer. But you can also trigger to send an email manually, on server error.