Merge pull request serilog#1007 from mariozski/dev

Implementation of serilog#1006

src/Serilog/Context/LogContext.cs

@@ -1,4 +1,4 @@
-// Copyright 2013-2015 Serilog Contributors
+// Copyright 2013-2015 Serilog Contributors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -150,6 +150,32 @@ public static ILogEventEnricher Clone()
             return new SafeAggregateEnricher(stack);
         }
 
+        /// <summary>
+        /// Remove all enrichers from the <see cref="LogContext"/>, returning an <see cref="IDisposable"/>
+        /// that must later be used to restore enrichers that were on the stack before <see cref="Suspend"/> was called.
+        /// </summary>
+        /// <returns>A token that must be disposed, in order, to restore properties back to the stack.</returns>
+        public static IDisposable Suspend()
+        {
+            var stack = GetOrCreateEnricherStack();
+            var bookmark = new ContextStackBookmark(stack);
+
+            Enrichers = ImmutableStack<ILogEventEnricher>.Empty;
+
+            return bookmark;
+        }
+
+        /// <summary>
+        /// Remove all enrichers from <see cref="LogContext"/> for the current async scope. 
+        /// </summary>
+        public static void Reset()
+        {
+            if (Enrichers != null && Enrichers != ImmutableStack<ILogEventEnricher>.Empty)
+            {
+                Enrichers = ImmutableStack<ILogEventEnricher>.Empty;
+            }
+        }
+
         static ImmutableStack<ILogEventEnricher> GetOrCreateEnricherStack()
         {
             var enrichers = Enrichers;
@@ -250,4 +276,4 @@ static ImmutableStack<ILogEventEnricher> Enrichers
         }
 #endif
     }
-}
+}

test/Serilog.Tests/Context/LogContextTests.cs

@@ -199,6 +199,62 @@ public async Task ContextPropertiesCrossAsyncCalls()
             }
         }
 
+        [Fact]
+        public async Task ContextEnrichersInAsyncScopeCanBeCleared()
+        {
+            LogEvent lastEvent = null;
+
+            var log = new LoggerConfiguration()
+                .Enrich.FromLogContext()
+                .WriteTo.Sink(new DelegatingSink(e => lastEvent = e))
+                .CreateLogger();
+
+            using (LogContext.Push(new PropertyEnricher("A", 1)))
+            {
+                await Task.Run(() =>
+                {
+                    LogContext.Reset();
+                    log.Write(Some.InformationEvent());
+                });
+
+                Assert.Empty(lastEvent.Properties);
+
+                // Reset should only work for current async scope, outside of it previous Context 
+                // instance should be available again.
+                log.Write(Some.InformationEvent());
+                Assert.Equal(1, lastEvent.Properties["A"].LiteralValue());
+            }
+        }
+
+        [Fact]
+        public async Task ContextEnrichersCanBeTemporarilyCleared()
+        {
+            LogEvent lastEvent = null;
+
+            var log = new LoggerConfiguration()
+                .Enrich.FromLogContext()
+                .WriteTo.Sink(new DelegatingSink(e => lastEvent = e))
+                .CreateLogger();
+
+            using (LogContext.Push(new PropertyEnricher("A", 1)))
+            {
+                using (LogContext.Suspend())
+                {
+                    await Task.Run(() =>
+                    {
+                        log.Write(Some.InformationEvent());
+                    });
+
+                    Assert.Empty(lastEvent.Properties);
+                }
+
+                // Suspend should only work for scope of using. After calling Dispose all enrichers
+                // should be restored.
+                log.Write(Some.InformationEvent());
+                Assert.Equal(1, lastEvent.Properties["A"].LiteralValue());
+            }
+        }
+
 #if APPDOMAIN
         // Must not actually try to pass context across domains,
         // since user property types may not be serializable.