BREAKING: Enrichments renamed to plugins.

We updated the major version to reflect this breaking change.

Author: niemyjski

Source/Extras/Enrichments/ErrorEnrichment.cs

@@ -51,10 +51,10 @@
     <Compile Include="..\GlobalAssemblyInfo.cs">
       <Link>Properties\GlobalAssemblyInfo.cs</Link>
     </Compile>
-    <Compile Include="Enrichments\ErrorEnrichment.cs" />
-    <Compile Include="Enrichments\PrivateInformationEnrichment.cs" />
-    <Compile Include="Enrichments\TraceLogEnrichment.cs" />
-    <Compile Include="Enrichments\VersionEnrichment.cs" />
+    <Compile Include="Plugins\ErrorPlugin.cs" />
+    <Compile Include="Plugins\PrivateInformationPlugin.cs" />
+    <Compile Include="Plugins\TraceLogPlugin.cs" />
+    <Compile Include="Plugins\VersionPlugin.cs" />
     <Compile Include="ExceptionlessSection.cs" />
     <Compile Include="Extensions\EventBuilderExtensions.cs" />
     <Compile Include="Extensions\ExceptionlessClientExtensions.cs" />

Source/Extras/Enrichments/PrivateInformationEnrichment.cs

@@ -2,7 +2,7 @@
 using System.Diagnostics;
 using System.Linq;
 using Exceptionless.Diagnostics;
-using Exceptionless.Enrichments.Default;
+using Exceptionless.Plugins.Default;
 
 namespace Exceptionless {
     public static class EventBuilderExtensions {
@@ -12,8 +12,8 @@ public static class EventBuilderExtensions {
         /// <param name="builder">The event builder object.</param>
         /// <param name="listener">The listener.</param>
         /// <param name="maxEntriesToInclude"></param>
-        public static EventBuilder AddRecentTraceLogEntries(this EventBuilder builder, ExceptionlessTraceListener listener = null, int maxEntriesToInclude = TraceLogEnrichment.DefaultMaxEntriesToInclude) {
-            TraceLogEnrichment.AddRecentTraceLogEntries(builder.Target, listener, maxEntriesToInclude);
+        public static EventBuilder AddRecentTraceLogEntries(this EventBuilder builder, ExceptionlessTraceListener listener = null, int maxEntriesToInclude = TraceLogPlugin.DefaultMaxEntriesToInclude) {
+            TraceLogPlugin.AddRecentTraceLogEntries(builder.Target, listener, maxEntriesToInclude);
             return builder;
         }
     }

Source/Extras/Exceptionless.Extras.csproj

@@ -1,7 +1,7 @@
 using System;
 using System.Threading.Tasks;
 using Exceptionless.Dependency;
-using Exceptionless.Enrichments;
+using Exceptionless.Plugins;
 using Exceptionless.Extras.Extensions;
 using Exceptionless.Extras.Submission;
 using Exceptionless.Logging;
@@ -14,10 +14,10 @@ public static void Startup(this ExceptionlessClient client, AppDomain appDomain
             client.Configuration.Resolver.Register<ISubmissionClient, SubmissionClient>();
             client.Configuration.Resolver.Register<IEnvironmentInfoCollector, EnvironmentInfoCollector>();
             client.Configuration.ReadAllConfig();
-            client.Configuration.UseErrorEnrichment();
-            client.Configuration.UseTraceLogEntriesEnrichment();
-            client.Configuration.AddEnrichment<VersionEnrichment>();
-            client.Configuration.AddEnrichment<PrivateInformationEnrichment>();
+            client.Configuration.UseErrorPlugin();
+            client.Configuration.UseTraceLogEntriesPlugin();
+            client.Configuration.AddPlugin<VersionPlugin>();
+            client.Configuration.AddPlugin<PrivateInformationPlugin>();
 
             client.RegisterAppDomainUnhandledExceptionHandler(appDomain);
             client.RegisterTaskSchedulerUnobservedTaskExceptionHandler();

Source/Extras/Extensions/EventBuilderExtensions.cs

@@ -1,13 +1,12 @@
 using System;
-using System.Collections.Generic;
 using System.Configuration;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Reflection;
 using Exceptionless.Dependency;
 using Exceptionless.Diagnostics;
-using Exceptionless.Enrichments.Default;
+using Exceptionless.Plugins.Default;
 using Exceptionless.Extras;
 using Exceptionless.Extras.Storage;
 using Exceptionless.Extras.Utility;
@@ -20,9 +19,9 @@ public static class ExceptionlessExtraConfigurationExtensions {
         /// Reads the Exceptionless configuration from the app.config or web.config file.
         /// </summary>
         /// <param name="config">The configuration object you want to apply the attribute settings to.</param>
-        public static void UseErrorEnrichment(this ExceptionlessConfiguration config) {
-            config.RemoveEnrichment<SimpleErrorEnrichment>();
-            config.AddEnrichment<Enrichments.ErrorEnrichment>();
+        public static void UseErrorPlugin(this ExceptionlessConfiguration config) {
+            config.RemovePlugin<SimpleErrorPlugin>();
+            config.AddPlugin<Plugins.ErrorPlugin>();
         }
 
         public static void UseIsolatedStorage(this ExceptionlessConfiguration config) {
@@ -47,16 +46,16 @@ public static void UseIsolatedStorageLogger(this ExceptionlessConfiguration conf
             config.Resolver.Register<IExceptionlessLog>(log);
         }
 
-        public static void UseTraceLogEntriesEnrichment(this ExceptionlessConfiguration config, int? defaultMaxEntriesToInclude = null) {
-            int maxEntriesToInclude = config.Settings.GetInt32(TraceLogEnrichment.MaxEntriesToIncludeKey, defaultMaxEntriesToInclude ?? 0);
+        public static void UseTraceLogEntriesPlugin(this ExceptionlessConfiguration config, int? defaultMaxEntriesToInclude = null) {
+            int maxEntriesToInclude = config.Settings.GetInt32(TraceLogPlugin.MaxEntriesToIncludeKey, defaultMaxEntriesToInclude ?? 0);
 
             if (!Trace.Listeners.OfType<ExceptionlessTraceListener>().Any())
                 Trace.Listeners.Add(new ExceptionlessTraceListener(maxEntriesToInclude));
 
-            if (!config.Settings.ContainsKey(TraceLogEnrichment.MaxEntriesToIncludeKey) && defaultMaxEntriesToInclude.HasValue)
-                config.Settings.Add(TraceLogEnrichment.MaxEntriesToIncludeKey, maxEntriesToInclude.ToString());
+            if (!config.Settings.ContainsKey(TraceLogPlugin.MaxEntriesToIncludeKey) && defaultMaxEntriesToInclude.HasValue)
+                config.Settings.Add(TraceLogPlugin.MaxEntriesToIncludeKey, maxEntriesToInclude.ToString());
 
-            config.AddEnrichment(typeof(TraceLogEnrichment).Name, c => new TraceLogEnrichment(c));
+            config.AddPlugin(typeof(TraceLogPlugin).Name, 70, c => new TraceLogPlugin(c));
         }
 
         public static void ReadAllConfig(this ExceptionlessConfiguration config, params Assembly[] configAttributesAssemblies) {

Source/Extras/Extensions/ExceptionlessClientExtensions.cs

@@ -0,0 +1,24 @@
+using System;
+using Exceptionless.Extras;
+using Exceptionless.Logging;
+using Exceptionless.Models;
+
+namespace Exceptionless.Plugins {
+    [Priority(40)]
+    public class ErrorPlugin : IEventPlugin {
+        private readonly IExceptionlessLog _log;
+
+        public ErrorPlugin(IExceptionlessLog log) {
+            _log = log;
+        }
+
+        public void Run(EventPluginContext context) {
+            var exception = context.Data.GetException();
+            if (exception == null)
+                return;
+
+            context.Event.Type = Event.KnownTypes.Error;
+            context.Event.Data[Event.KnownDataKeys.Error] = exception.ToErrorModel(_log);
+        }
+    }
+}

Source/Extras/Extensions/ExceptionlessExtraConfigurationExtensions.cs

@@ -0,0 +1,15 @@
+using System;
+
+namespace Exceptionless.Plugins {
+    [Priority(60)]
+    public class PrivateInformationPlugin : IEventPlugin {
+        public void Run(EventPluginContext context) {
+            if (!context.Client.Configuration.IncludePrivateInformation)
+                return;
+
+            var user = context.Event.GetUserIdentity();
+            if (user == null || String.IsNullOrEmpty(user.Identity))
+                context.Event.SetUserIdentity(Environment.UserName);
+        }
+    }
+}

Source/Extras/Plugins/ErrorPlugin.cs

@@ -7,32 +7,28 @@
 using Exceptionless.Models;
 using Exceptionless.Models.Collections;
 
-namespace Exceptionless.Enrichments.Default {
-    public class TraceLogEnrichment : IEventEnrichment, IDisposable {
+namespace Exceptionless.Plugins.Default {
+    [Priority(70)]
+    public class TraceLogPlugin : IEventPlugin, IDisposable {
         public const string MaxEntriesToIncludeKey = "TraceLogLimit";
         public const int DefaultMaxEntriesToInclude = 25;
 
         private readonly ExceptionlessConfiguration _configuration;
         private readonly ExceptionlessTraceListener _listener; 
 
-        public TraceLogEnrichment(ExceptionlessConfiguration config, ExceptionlessTraceListener listener = null) {
+        public TraceLogPlugin(ExceptionlessConfiguration config, ExceptionlessTraceListener listener = null) {
             _configuration = config;
             _configuration.Settings.Changed += OnSettingsChanged;
             _listener = listener ?? Trace.Listeners.OfType<ExceptionlessTraceListener>().FirstOrDefault();
         }
 
-        /// <summary>
-        /// Enrich the event with additional information.
-        /// </summary>
-        /// <param name="context">Context information.</param>
-        /// <param name="ev">Event to enrich.</param>
-        public void Enrich(EventEnrichmentContext context, Event ev) {
+        public void Run(EventPluginContext context) {
             try {
                 int maxEntriesToInclude = context.Client.Configuration.Settings.GetInt32(MaxEntriesToIncludeKey, DefaultMaxEntriesToInclude);
                 if (maxEntriesToInclude > 0)
-                    AddRecentTraceLogEntries(ev, _listener, maxEntriesToInclude);
+                    AddRecentTraceLogEntries(context.Event, _listener, maxEntriesToInclude);
             } catch (Exception ex) {
-                context.Log.FormattedError(typeof(TraceLogEnrichment), ex, "Error adding trace information: {0}", ex.Message);
+                context.Log.FormattedError(typeof(TraceLogPlugin), ex, "Error adding trace information: {0}", ex.Message);
             }
         }
 

Source/Extras/Plugins/PrivateInformationPlugin.cs

@@ -4,17 +4,18 @@
 using Exceptionless.Extras;
 using Exceptionless.Models;
 
-namespace Exceptionless.Enrichments {
-    public class VersionEnrichment : IEventEnrichment {
+namespace Exceptionless.Plugins {
+    [Priority(80)]
+    public class VersionPlugin : IEventPlugin {
         private static bool _checkedForVersion;
 
-        public void Enrich(EventEnrichmentContext context, Event ev) {
-            if (ev.Data.ContainsKey(Event.KnownDataKeys.Version))
+        public void Run(EventPluginContext context) {
+            if (context.Event.Data.ContainsKey(Event.KnownDataKeys.Version))
                 return;
 
             object value;
             if (context.Client.Configuration.DefaultData.TryGetValue(Event.KnownDataKeys.Version, out value) && value is string) {
-                ev.Data[Event.KnownDataKeys.Version] = value;
+                context.Event.Data[Event.KnownDataKeys.Version] = value;
                 return;
             }
 
@@ -30,7 +31,7 @@ public void Enrich(EventEnrichmentContext context, Event ev) {
             if (String.IsNullOrEmpty(version))
                 return;
 
-            ev.Data[Event.KnownDataKeys.Version] = context.Client.Configuration.DefaultData[Event.KnownDataKeys.Version] = version;
+            context.Event.Data[Event.KnownDataKeys.Version] = context.Client.Configuration.DefaultData[Event.KnownDataKeys.Version] = version;
         }
 
         private string GetVersionFromAssembly(Assembly assembly) {