Fixes 70 Some exceptions were note being caught.

Updates to #66 as well.

Author: niemyjski

Source/Extras/Plugins/20_ErrorPlugin.cs

@@ -1,4 +1,5 @@
 using System;
+using Exceptionless.Extensions;
 using Exceptionless.Extras;
 using Exceptionless.Models;
 
@@ -10,8 +11,14 @@ public void Run(EventPluginContext context) {
             if (exception == null)
                 return;
 
+            if (exception.IsProcessed()) {
+                context.Cancel = true;
+                return;
+            }
+            
             context.Event.Type = Event.KnownTypes.Error;
             context.Event.Data[Event.KnownDataKeys.Error] = exception.ToErrorModel(context.Client);
+            exception.MarkProcessed();
         }
     }
 }

Source/Platforms/Mvc/ExceptionlessModule.cs

@@ -4,13 +4,15 @@
 using System.Web.Mvc;
 using Exceptionless.Dependency;
 using Exceptionless.Web;
+using Exceptionless.Web.Extensions;
 
 namespace Exceptionless.Mvc {
     public class ExceptionlessModule : IHttpModule {
         private HttpApplication _app;
 
         public virtual void Init(HttpApplication app) {
             ExceptionlessClient.Default.Startup();
+            ExceptionlessClient.Default.RegisterHttpApplicationErrorHandler(app);
             ExceptionlessClient.Default.Configuration.AddPlugin<ExceptionlessWebPlugin>();
             ExceptionlessClient.Default.Configuration.Resolver.Register<ILastReferenceIdManager, WebLastReferenceIdManager>();
 
@@ -22,6 +24,7 @@ public virtual void Init(HttpApplication app) {
 
         public void Dispose() {
             ExceptionlessClient.Default.Shutdown();
+            ExceptionlessClient.Default.RegisterHttpApplicationErrorHandler(_app);
         }
     }
 }

Source/Shared/Extensions/ExceptionExtensions.cs

@@ -54,5 +54,32 @@ public static string GetMessage(this Exception exception) {
 
             return exception.GetInnermostException().Message;
         }
+        
+        private static readonly string _marker = "@exceptionless";
+        public static void MarkProcessed(this Exception exception) {
+            if (exception == null)
+                return;
+
+            try {
+                if (exception.Data != null) {
+                    var genericTypes = exception.Data.GetType().GetGenericArguments();
+                    exception.Data[_marker] = genericTypes.Length > 0 ? genericTypes[0].GetDefaultValue() : null;
+                }
+            } catch (Exception) { }
+
+            MarkProcessed(exception.InnerException);
+        }
+
+        public static bool IsProcessed(this Exception exception) {
+            if (exception == null)
+                return false;
+
+            try {
+                if (exception.Data != null && exception.Data.Contains(_marker))
+                    return true;
+            } catch (Exception) {}
+
+            return IsProcessed(exception.InnerException);
+        }
     }
 }

Source/Shared/Extensions/TypeExtensions.cs

@@ -35,6 +35,38 @@ public static PropertyInfo[] GetPublicProperties(this Type type) {
 
             return type.GetProperties(BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance);
         }
+        
+        public static object GetDefaultValue(this Type type) {
+            if (type == null || type.IsNullable())
+                return null;
+            
+            if (type == typeof(bool))
+                return default(bool);
+            if (type == typeof(byte))
+                return default(byte);
+            if (type == typeof(char))
+                return default(char);
+            if (type == typeof(decimal))
+                return default(decimal);
+            if (type == typeof(double))
+                return default(double);
+            if (type == typeof(float))
+                return default(float);
+            if (type == typeof(int))
+                return default(int);
+            if (type == typeof(long))
+                return default(long);
+            if (type == typeof(sbyte))
+                return default(sbyte);
+            if (type == typeof(uint))
+                return default(uint);
+            if (type == typeof(ulong))
+                return default(ulong);
+            if (type == typeof(ushort))
+                return default(ushort);
+
+            return Activator.CreateInstance(type);
+        }
 
         public static bool IsNullable(this Type type) {
             if (type.IsValueType)

Source/Shared/Plugins/Default/020_SimpleErrorPlugin.cs

@@ -10,8 +10,14 @@ public void Run(EventPluginContext context) {
             if (exception == null)
                 return;
 
+            if (exception.IsProcessed()) {
+                context.Cancel = true;
+                return;
+            }
+
             context.Event.Type = Event.KnownTypes.Error;
             context.Event.Data[Event.KnownDataKeys.SimpleError] = exception.ToSimpleErrorModel(context.Client);
+            exception.MarkProcessed();
         }
     }
 }

Source/Tests/Plugins/PluginTests.cs

@@ -58,6 +58,38 @@ public void ConfigurationDefaults_IgnoredProperties() {
             Assert.Equal("Test", context.Event.Data["Message"]);
         }
 
+        [Fact]
+        public void ErrorPlugin_DiscardDuplicates() {
+            var errorPlugins = new List<IEventPlugin> {
+                new ErrorPlugin(),
+                new SimpleErrorPlugin()
+            };
+
+            foreach (var plugin in errorPlugins) {
+                var exception = new Exception("Nested", new MyApplicationException("Test") {
+                    IgnoredProperty = "Test",
+                    RandomValue = "Test"
+                });
+
+                var client = new ExceptionlessClient();
+                var context = new EventPluginContext(client, new Event());
+                context.ContextData.SetException(exception);
+                plugin.Run(context);
+                Assert.False(context.Cancel);
+
+                IData error = context.Event.GetError() as IData ?? context.Event.GetSimpleError();
+                Assert.NotNull(error);
+
+                context = new EventPluginContext(client, new Event());
+                context.ContextData.SetException(exception);
+                plugin.Run(context);
+                Assert.True(context.Cancel);
+                
+                error = context.Event.GetError() as IData ?? context.Event.GetSimpleError();
+                Assert.Null(error);
+            }
+        }
+        
         [Fact]
         public void ErrorPlugin_IgnoredProperties() {
             var exception = new MyApplicationException("Test") {