public void DoubleInitializeTest()
{
var target = new MyTarget();
target.Initialize(CommonCfg);
target.Initialize(CommonCfg);
// initialize was called once
Assert.AreEqual(1, target.InitializeCount);
Assert.AreEqual(1, target.InitializeCount + target.FlushCount + target.CloseCount + target.WriteCount + target.WriteCount2 + target.WriteCount3);
}
public void AutoFlushTargetWrapperSyncTest1()
{
var myTarget = new MyTarget();
var wrapper = new AutoFlushTargetWrapper
{
WrappedTarget = myTarget,
};
myTarget.Initialize(null);
wrapper.Initialize(null);
var logEvent = new LogEventInfo();
Exception lastException = null;
bool continuationHit = false;
AsyncContinuation continuation =
ex =>
{
lastException = ex;
continuationHit = true;
};
wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
Assert.IsTrue(continuationHit);
Assert.IsNull(lastException);
Assert.AreEqual(1, myTarget.FlushCount);
Assert.AreEqual(1, myTarget.WriteCount);
continuationHit = false;
wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
Assert.IsTrue(continuationHit);
Assert.IsNull(lastException);
Assert.AreEqual(2, myTarget.WriteCount);
Assert.AreEqual(2, myTarget.FlushCount);
}
public void InitializeTest()
{
var target = new MyTarget();
target.Initialize(null);
// initialize was called once
Assert.Equal(1, target.InitializeCount);
Assert.Equal(1, target.InitializeCount + target.FlushCount + target.CloseCount + target.WriteCount + target.WriteCount2 + target.WriteCount3);
}
public void DoubleCloseTest()
{
var target = new MyTarget();
using (target.Initialize(CommonCfg))
{
}
// initialize and close were called once each
Assert.AreEqual(1, target.InitializeCount);
Assert.AreEqual(1, target.CloseCount);
Assert.AreEqual(2, target.InitializeCount + target.FlushCount + target.CloseCount + target.WriteCount + target.WriteCount2 + target.WriteCount3);
}
public void DoubleCloseTest()
{
var target = new MyTarget();
target.Initialize(null);
target.Close();
target.Close();
// initialize and close were called once each
Assert.Equal(1, target.InitializeCount);
Assert.Equal(1, target.CloseCount);
Assert.Equal(2, target.InitializeCount + target.FlushCount + target.CloseCount + target.WriteCount + target.WriteCount2 + target.WriteCount3);
}
public void FlushTest()
{
var target = new MyTarget();
List<Exception> exceptions = new List<Exception>();
target.Initialize(CommonCfg);
target.Flush(exceptions.Add);
// flush was called
Assert.AreEqual(1, target.FlushCount);
Assert.AreEqual(2, target.InitializeCount + target.FlushCount + target.CloseCount + target.WriteCount + target.WriteCount2 + target.WriteCount3);
Assert.AreEqual(1, exceptions.Count);
exceptions.ForEach(Assert.IsNull);
}
public void PostFilteringTargetWrapperUsingDefaultFilterTest()
{
var target = new MyTarget();
var wrapper = new PostFilteringTargetWrapper()
{
WrappedTarget = target,
Rules =
{
// if we had any warnings, log debug too
new FilteringRule("level >= LogLevel.Warn", "level >= LogLevel.Debug"),
// when there is an error, emit everything
new FilteringRule
{
Exists = "level >= LogLevel.Error",
Filter = "true",
},
},
// by default log info and above
DefaultFilter = "level >= LogLevel.Info",
};
wrapper.Initialize(null);
target.Initialize(null);
var exceptions = new List<Exception>();
var events = new []
{
new LogEventInfo(LogLevel.Debug, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "Logger2", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Debug, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Trace, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "Logger3", "Hello").WithContinuation(exceptions.Add),
};
wrapper.WriteAsyncLogEvents(events);
// make sure all Info events went through
Assert.Equal(3, target.Events.Count);
Assert.Same(events[1].LogEvent, target.Events[0]);
Assert.Same(events[2].LogEvent, target.Events[1]);
Assert.Same(events[5].LogEvent, target.Events[2]);
Assert.Equal(events.Length, exceptions.Count);
}
public void RoundRobinGroupTargetSyncTest1()
{
var myTarget1 = new MyTarget();
var myTarget2 = new MyTarget();
var myTarget3 = new MyTarget();
var wrapper = new RoundRobinGroupTarget()
{
Targets = { myTarget1, myTarget2, myTarget3 },
};
myTarget1.Initialize(null);
myTarget2.Initialize(null);
myTarget3.Initialize(null);
wrapper.Initialize(null);
List<Exception> exceptions = new List<Exception>();
// no exceptions
for (int i = 0; i < 10; ++i)
{
wrapper.WriteAsyncLogEvent(LogEventInfo.CreateNullEvent().WithContinuation(exceptions.Add));
}
Assert.Equal(10, exceptions.Count);
foreach (var e in exceptions)
{
Assert.Null(e);
}
Assert.Equal(4, myTarget1.WriteCount);
Assert.Equal(3, myTarget2.WriteCount);
Assert.Equal(3, myTarget3.WriteCount);
Exception flushException = null;
var flushHit = new ManualResetEvent(false);
wrapper.Flush(ex => { flushException = ex; flushHit.Set(); });
flushHit.WaitOne();
if (flushException != null)
{
Assert.True(false, flushException.ToString());
}
Assert.Equal(1, myTarget1.FlushCount);
Assert.Equal(1, myTarget2.FlushCount);
Assert.Equal(1, myTarget3.FlushCount);
}
public void InitializeFailedTest()
{
var target = new MyTarget();
target.ThrowOnInitialize = true;
LogManager.ThrowExceptions = true;
Assert.Throws<InvalidOperationException>(() => target.Initialize(null));
// after exception in Initialize(), the target becomes non-functional and all Write() operations
var exceptions = new List<Exception>();
target.WriteAsyncLogEvent(LogEventInfo.CreateNullEvent().WithContinuation(exceptions.Add));
Assert.Equal(0, target.WriteCount);
Assert.Equal(1, exceptions.Count);
Assert.NotNull(exceptions[0]);
Assert.Equal("Target " + target + " failed to initialize.", exceptions[0].Message);
Assert.Equal("Init error.", exceptions[0].InnerException.Message);
}
public void RetryingTargetWrapperTest1()
{
var target = new MyTarget();
var wrapper = new RetryingTargetWrapper()
{
WrappedTarget = target,
RetryCount = 10,
RetryDelayMilliseconds = 1,
};
wrapper.Initialize(null);
target.Initialize(null);
var exceptions = new List <Exception>();
var events = new []
{
new LogEventInfo(LogLevel.Debug, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "Logger2", "Hello").WithContinuation(exceptions.Add),
};
wrapper.WriteAsyncLogEvents(events);
// make sure all events went through
Assert.Equal(3, target.Events.Count);
Assert.Same(events[0].LogEvent, target.Events[0]);
Assert.Same(events[1].LogEvent, target.Events[1]);
Assert.Same(events[2].LogEvent, target.Events[2]);
Assert.Equal(events.Length, exceptions.Count);
// make sure there were no exception
foreach (var ex in exceptions)
{
Assert.Null(ex);
}
}
public void AsyncTargetWrapperSyncTest1()
{
var myTarget = new MyTarget();
var targetWrapper = new AsyncTargetWrapper
{
WrappedTarget = myTarget,
};
targetWrapper.Initialize(null);
myTarget.Initialize(null);
var logEvent = new LogEventInfo();
Exception lastException = null;
ManualResetEvent continuationHit = new ManualResetEvent(false);
Thread continuationThread = null;
AsyncContinuation continuation =
ex =>
{
lastException = ex;
continuationThread = Thread.CurrentThread;
continuationHit.Set();
};
targetWrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
// continuation was not hit
continuationHit.WaitOne();
Assert.AreNotSame(continuationThread, Thread.CurrentThread);
Assert.IsNull(lastException);
Assert.AreEqual(1, myTarget.WriteCount);
continuationHit.Reset();
targetWrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
continuationHit.WaitOne();
Assert.AreNotSame(continuationThread, Thread.CurrentThread);
Assert.IsNull(lastException);
Assert.AreEqual(2, myTarget.WriteCount);
}
public void PostFilteringTargetWrapperNoFiltersDefined()
{
var target = new MyTarget();
var wrapper = new PostFilteringTargetWrapper()
{
WrappedTarget = target,
};
wrapper.Initialize(null);
target.Initialize(null);
var exceptions = new List <Exception>();
var events = new[]
{
new LogEventInfo(LogLevel.Debug, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "Logger2", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Debug, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Trace, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "Logger3", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Error, "Logger1", "Hello").WithContinuation(exceptions.Add),
};
wrapper.WriteAsyncLogEvents(events);
// make sure all events went through
Assert.Equal(7, target.Events.Count);
Assert.Same(events[0].LogEvent, target.Events[0]);
Assert.Same(events[1].LogEvent, target.Events[1]);
Assert.Same(events[2].LogEvent, target.Events[2]);
Assert.Same(events[3].LogEvent, target.Events[3]);
Assert.Same(events[4].LogEvent, target.Events[4]);
Assert.Same(events[5].LogEvent, target.Events[5]);
Assert.Same(events[6].LogEvent, target.Events[6]);
Assert.Equal(events.Length, exceptions.Count);
}
public void FilteringTargetWrapperSyncTest2()
{
var myMockCondition = new MyMockCondition(false);
var myTarget = new MyTarget();
var wrapper = new FilteringTargetWrapper
{
WrappedTarget = myTarget,
Condition = myMockCondition,
};
myTarget.Initialize(null);
wrapper.Initialize(null);
var logEvent = new LogEventInfo();
Exception lastException = null;
bool continuationHit = false;
AsyncContinuation continuation =
ex =>
{
lastException = ex;
continuationHit = true;
};
wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
Assert.Equal(1, myMockCondition.CallCount);
Assert.True(continuationHit);
Assert.Null(lastException);
Assert.Equal(0, myTarget.WriteCount);
Assert.Equal(1, myMockCondition.CallCount);
continuationHit = false;
wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
Assert.True(continuationHit);
Assert.Null(lastException);
Assert.Equal(0, myTarget.WriteCount);
Assert.Equal(2, myMockCondition.CallCount);
}
public void RetryingTargetWrapperTest1()
{
var target = new MyTarget();
var wrapper = new RetryingTargetWrapper()
{
WrappedTarget = target,
RetryCount = 10,
RetryDelayMilliseconds = 1,
};
wrapper.Initialize(null);
target.Initialize(null);
var exceptions = new List<Exception>();
var events = new []
{
new LogEventInfo(LogLevel.Debug, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "Logger2", "Hello").WithContinuation(exceptions.Add),
};
wrapper.WriteAsyncLogEvents(events);
// make sure all events went through
Assert.AreEqual(3, target.Events.Count);
Assert.AreSame(events[0].LogEvent, target.Events[0]);
Assert.AreSame(events[1].LogEvent, target.Events[1]);
Assert.AreSame(events[2].LogEvent, target.Events[2]);
Assert.AreEqual(events.Length, exceptions.Count, "Some continuations were not invoked.");
// make sure there were no exception
foreach (var ex in exceptions)
{
Assert.IsNull(ex);
}
}
public void BufferingAutoFlushWrapperTest()
{
var testTarget = new MyTarget();
var bufferingTargetWrapper = new BufferingTargetWrapper(testTarget, 100);
var autoFlushOnLevelWrapper = new AutoFlushTargetWrapper(bufferingTargetWrapper);
autoFlushOnLevelWrapper.Condition = "level > LogLevel.Info";
testTarget.Initialize(null);
bufferingTargetWrapper.Initialize(null);
autoFlushOnLevelWrapper.Initialize(null);
AsyncContinuation continuation = ex => { };
autoFlushOnLevelWrapper.WriteAsyncLogEvent(LogEventInfo.Create(LogLevel.Trace, "*", "test").WithContinuation(continuation));
Assert.Equal(0, testTarget.WriteCount);
Assert.Equal(0, testTarget.FlushCount);
autoFlushOnLevelWrapper.WriteAsyncLogEvent(LogEventInfo.Create(LogLevel.Fatal, "*", "test").WithContinuation(continuation));
Assert.Equal(2, testTarget.WriteCount);
Assert.Equal(1, testTarget.FlushCount);
autoFlushOnLevelWrapper.WriteAsyncLogEvent(LogEventInfo.Create(LogLevel.Trace, "*", "Please FlushThis").WithContinuation(continuation));
Assert.Equal(2, testTarget.WriteCount);
Assert.Equal(1, testTarget.FlushCount);
}
public void FilteringTargetWrapperSyncTest1()
{
var myMockCondition = new MyMockCondition(true);
var myTarget = new MyTarget();
var wrapper = new FilteringTargetWrapper
{
WrappedTarget = myTarget,
Condition = myMockCondition,
};
myTarget.Initialize(null);
wrapper.Initialize(null);
var logEvent = new LogEventInfo();
Exception lastException = null;
bool continuationHit = false;
AsyncContinuation continuation =
ex =>
{
lastException = ex;
continuationHit = true;
};
wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
Assert.Equal(1, myMockCondition.CallCount);
Assert.True(continuationHit);
Assert.Null(lastException);
Assert.Equal(1, myTarget.WriteCount);
continuationHit = false;
wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
Assert.True(continuationHit);
Assert.Null(lastException);
Assert.Equal(2, myTarget.WriteCount);
Assert.Equal(2, myMockCondition.CallCount);
}
public void RepeatingTargetWrapperTest1()
{
var target = new MyTarget();
var wrapper = new RepeatingTargetWrapper()
{
WrappedTarget = target,
RepeatCount = 3,
};
wrapper.Initialize(null);
target.Initialize(null);
var exceptions = new List <Exception>();
var events = new[]
{
new LogEventInfo(LogLevel.Debug, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "Logger2", "Hello").WithContinuation(exceptions.Add),
};
wrapper.WriteAsyncLogEvents(events);
// make sure all events went through and were replicated 3 times
Assert.Equal(9, target.Events.Count);
Assert.Same(events[0].LogEvent, target.Events[0]);
Assert.Same(events[0].LogEvent, target.Events[1]);
Assert.Same(events[0].LogEvent, target.Events[2]);
Assert.Same(events[1].LogEvent, target.Events[3]);
Assert.Same(events[1].LogEvent, target.Events[4]);
Assert.Same(events[1].LogEvent, target.Events[5]);
Assert.Same(events[2].LogEvent, target.Events[6]);
Assert.Same(events[2].LogEvent, target.Events[7]);
Assert.Same(events[2].LogEvent, target.Events[8]);
Assert.Equal(events.Length, exceptions.Count);
}
public void AsyncTargetWrapperSyncTest1()
{
var myTarget = new MyTarget();
var targetWrapper = new AsyncTargetWrapper
{
WrappedTarget = myTarget,
};
targetWrapper.Initialize(null);
myTarget.Initialize(null);
var logEvent = new LogEventInfo();
Exception lastException = null;
ManualResetEvent continuationHit = new ManualResetEvent(false);
Thread continuationThread = null;
AsyncContinuation continuation =
ex =>
{
lastException = ex;
continuationThread = Thread.CurrentThread;
continuationHit.Set();
};
targetWrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
// continuation was not hit
Assert.True(continuationHit.WaitOne(2000));
Assert.NotSame(continuationThread, Thread.CurrentThread);
Assert.Null(lastException);
Assert.Equal(1, myTarget.WriteCount);
continuationHit.Reset();
targetWrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
continuationHit.WaitOne();
Assert.NotSame(continuationThread, Thread.CurrentThread);
Assert.Null(lastException);
Assert.Equal(2, myTarget.WriteCount);
}
public void RepeatingTargetWrapperTest1()
{
var target = new MyTarget();
var wrapper = new RepeatingTargetWrapper()
{
WrappedTarget = target,
RepeatCount = 3,
};
wrapper.Initialize(null);
target.Initialize(null);
var exceptions = new List<Exception>();
var events = new[]
{
new LogEventInfo(LogLevel.Debug, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "Logger2", "Hello").WithContinuation(exceptions.Add),
};
wrapper.WriteAsyncLogEvents(events);
// make sure all events went through and were replicated 3 times
Assert.Equal(9, target.Events.Count);
Assert.Same(events[0].LogEvent, target.Events[0]);
Assert.Same(events[0].LogEvent, target.Events[1]);
Assert.Same(events[0].LogEvent, target.Events[2]);
Assert.Same(events[1].LogEvent, target.Events[3]);
Assert.Same(events[1].LogEvent, target.Events[4]);
Assert.Same(events[1].LogEvent, target.Events[5]);
Assert.Same(events[2].LogEvent, target.Events[6]);
Assert.Same(events[2].LogEvent, target.Events[7]);
Assert.Same(events[2].LogEvent, target.Events[8]);
Assert.Equal(events.Length, exceptions.Count);
}
public void InitializeFailedTest()
{
var target = new MyTarget();
target.ThrowOnInitialize = true;
try
{
target.Initialize(null);
Assert.Fail("Expected exception.");
}
catch (InvalidOperationException)
{
}
// after exception in Initialize(), the target becomes non-functional and all Write() operations
var exceptions = new List <Exception>();
target.WriteAsyncLogEvent(LogEventInfo.CreateNullEvent().WithContinuation(exceptions.Add));
Assert.AreEqual(0, target.WriteCount);
Assert.AreEqual(1, exceptions.Count);
Assert.IsNotNull(exceptions[0]);
Assert.AreEqual("Target " + target + " failed to initialize.", exceptions[0].Message);
Assert.AreEqual("Init error.", exceptions[0].InnerException.Message);
}
public void MultipleConditionalAutoFlushWrappersTest()
{
var testTarget = new MyTarget();
var autoFlushOnLevelWrapper = new AutoFlushTargetWrapper(testTarget);
autoFlushOnLevelWrapper.Condition = "level > LogLevel.Info";
var autoFlushOnMessageWrapper = new AutoFlushTargetWrapper(autoFlushOnLevelWrapper);
autoFlushOnMessageWrapper.Condition = "contains('${message}','FlushThis')";
testTarget.Initialize(null);
autoFlushOnLevelWrapper.Initialize(null);
autoFlushOnMessageWrapper.Initialize(null);
AsyncContinuation continuation = ex => { };
autoFlushOnMessageWrapper.WriteAsyncLogEvent(LogEventInfo.Create(LogLevel.Trace, "*", "test").WithContinuation(continuation));
Assert.Equal(1, testTarget.WriteCount);
Assert.Equal(0, testTarget.FlushCount);
autoFlushOnMessageWrapper.WriteAsyncLogEvent(LogEventInfo.Create(LogLevel.Fatal, "*", "test").WithContinuation(continuation));
Assert.Equal(2, testTarget.WriteCount);
Assert.Equal(1, testTarget.FlushCount);
autoFlushOnMessageWrapper.WriteAsyncLogEvent(LogEventInfo.Create(LogLevel.Trace, "*", "Please FlushThis").WithContinuation(continuation));
Assert.Equal(3, testTarget.WriteCount);
Assert.Equal(2, testTarget.FlushCount);
}
public void BufferingTargetWrapperSyncTest1()
{
var myTarget = new MyTarget();
var targetWrapper = new BufferingTargetWrapper
{
WrappedTarget = myTarget,
BufferSize = 10,
};
myTarget.Initialize(null);
targetWrapper.Initialize(null);
int totalEvents = 100;
var continuationHit = new bool[totalEvents];
var lastException = new Exception[totalEvents];
var continuationThread = new Thread[totalEvents];
int hitCount = 0;
CreateContinuationFunc createAsyncContinuation =
eventNumber =>
ex =>
{
lastException[eventNumber] = ex;
continuationThread[eventNumber] = Thread.CurrentThread;
continuationHit[eventNumber] = true;
Interlocked.Increment(ref hitCount);
};
// write 9 events - they will all be buffered and no final continuation will be reached
int eventCounter = 0;
for (int i = 0; i < 9; ++i)
{
targetWrapper.WriteAsyncLogEvent(new LogEventInfo().WithContinuation(createAsyncContinuation(eventCounter++)));
}
Assert.AreEqual(0, hitCount);
Assert.AreEqual(0, myTarget.WriteCount);
// write one more event - everything will be flushed
targetWrapper.WriteAsyncLogEvent(new LogEventInfo().WithContinuation(createAsyncContinuation(eventCounter++)));
Assert.AreEqual(10, hitCount);
Assert.AreEqual(1, myTarget.BufferedWriteCount);
Assert.AreEqual(10, myTarget.BufferedTotalEvents);
Assert.AreEqual(10, myTarget.WriteCount);
for (int i = 0; i < hitCount; ++i)
{
Assert.AreSame(Thread.CurrentThread, continuationThread[i]);
Assert.IsNull(lastException[i]);
}
// write 9 more events - they will all be buffered and no final continuation will be reached
for (int i = 0; i < 9; ++i)
{
targetWrapper.WriteAsyncLogEvent(new LogEventInfo().WithContinuation(createAsyncContinuation(eventCounter++)));
}
// no change
Assert.AreEqual(10, hitCount);
Assert.AreEqual(1, myTarget.BufferedWriteCount);
Assert.AreEqual(10, myTarget.BufferedTotalEvents);
Assert.AreEqual(10, myTarget.WriteCount);
Exception flushException = null;
var flushHit = new ManualResetEvent(false);
targetWrapper.Flush(
ex =>
{
flushException = ex;
flushHit.Set();
});
Thread.Sleep(1000);
flushHit.WaitOne();
Assert.IsNull(flushException);
// make sure remaining events were written
Assert.AreEqual(19, hitCount);
Assert.AreEqual(2, myTarget.BufferedWriteCount);
Assert.AreEqual(19, myTarget.BufferedTotalEvents);
Assert.AreEqual(19, myTarget.WriteCount);
Assert.AreEqual(1, myTarget.FlushCount);
// flushes happen on the same thread
for (int i = 10; i < hitCount; ++i)
{
Assert.IsNotNull(continuationThread[i]);
Assert.AreSame(Thread.CurrentThread, continuationThread[i], "Invalid thread #" + i);
Assert.IsNull(lastException[i]);
}
// flush again - should just invoke Flush() on the wrapped target
flushHit.Reset();
targetWrapper.Flush(
ex =>
{
flushException = ex;
flushHit.Set();
});
flushHit.WaitOne();
Assert.AreEqual(19, hitCount);
Assert.AreEqual(2, myTarget.BufferedWriteCount);
Assert.AreEqual(19, myTarget.BufferedTotalEvents);
Assert.AreEqual(19, myTarget.WriteCount);
Assert.AreEqual(2, myTarget.FlushCount);
targetWrapper.Close();
myTarget.Close();
}
public void FallbackGroupTargetSyncTest2()
{
// fail once
var myTarget1 = new MyTarget() { FailCounter = 1 };
var myTarget2 = new MyTarget();
var myTarget3 = new MyTarget();
var wrapper = new FallbackGroupTarget()
{
Targets = { myTarget1, myTarget2, myTarget3 },
};
myTarget1.Initialize(null);
myTarget2.Initialize(null);
myTarget3.Initialize(null);
wrapper.Initialize(null);
List<Exception> exceptions = new List<Exception>();
// no exceptions
for (int i = 0; i < 10; ++i)
{
wrapper.WriteAsyncLogEvent(LogEventInfo.CreateNullEvent().WithContinuation(exceptions.Add));
}
Assert.AreEqual(10, exceptions.Count);
foreach (var e in exceptions)
{
Assert.IsNull(e);
}
Assert.AreEqual(1, myTarget1.WriteCount);
Assert.AreEqual(10, myTarget2.WriteCount);
Assert.AreEqual(0, myTarget3.WriteCount);
Exception flushException = null;
var flushHit = new ManualResetEvent(false);
wrapper.Flush(ex => { flushException = ex; flushHit.Set(); });
flushHit.WaitOne();
if (flushException != null)
{
Assert.Fail(flushException.ToString());
}
}
public void RetryingTargetWrapperTest2()
{
var target = new MyTarget()
{
ThrowExceptions = 6,
};
var wrapper = new RetryingTargetWrapper()
{
WrappedTarget = target,
RetryCount = 4,
RetryDelayMilliseconds = 1,
};
wrapper.Initialize(null);
target.Initialize(null);
var exceptions = new List<Exception>();
var events = new []
{
new LogEventInfo(LogLevel.Debug, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "Logger2", "Hello").WithContinuation(exceptions.Add),
};
var internalLogOutput = RunAndCaptureInternalLog(() => wrapper.WriteAsyncLogEvents(events), LogLevel.Trace);
string expectedLogOutput = @"Warn Error while writing to 'MyTarget': System.InvalidOperationException: Some exception has ocurred.. Try 1/4
Warn Error while writing to 'MyTarget': System.InvalidOperationException: Some exception has ocurred.. Try 2/4
Warn Error while writing to 'MyTarget': System.InvalidOperationException: Some exception has ocurred.. Try 3/4
Warn Error while writing to 'MyTarget': System.InvalidOperationException: Some exception has ocurred.. Try 4/4
Warn Too many retries. Aborting.
Warn Error while writing to 'MyTarget': System.InvalidOperationException: Some exception has ocurred.. Try 1/4
Warn Error while writing to 'MyTarget': System.InvalidOperationException: Some exception has ocurred.. Try 2/4
";
Assert.AreEqual(expectedLogOutput, internalLogOutput);
// first event does not get to wrapped target because of too many attempts.
// second event gets there in 3rd retry
// and third event gets there immediately
Assert.AreEqual(2, target.Events.Count);
Assert.AreSame(events[1].LogEvent, target.Events[0]);
Assert.AreSame(events[2].LogEvent, target.Events[1]);
Assert.AreEqual(events.Length, exceptions.Count, "Some continuations were not invoked.");
Assert.IsNotNull(exceptions[0]);
Assert.AreEqual("Some exception has ocurred.", exceptions[0].Message);
Assert.IsNull(exceptions[1]);
Assert.IsNull(exceptions[2]);
}
private static void SplitGroupSyncTest1inner(bool allEventsAtOnce)
{
var myTarget1 = new MyTarget();
var myTarget2 = new MyTarget();
var myTarget3 = new MyTarget();
var wrapper = new SplitGroupTarget()
{
Targets = { myTarget1, myTarget2, myTarget3 },
};
myTarget1.Initialize(null);
myTarget2.Initialize(null);
myTarget3.Initialize(null);
wrapper.Initialize(null);
List<Exception> exceptions = new List<Exception>();
var inputEvents = new List<LogEventInfo>();
for (int i = 0; i < 10; ++i)
{
inputEvents.Add(LogEventInfo.CreateNullEvent());
}
int remaining = inputEvents.Count;
var allDone = new ManualResetEvent(false);
// no exceptions
AsyncContinuation asyncContinuation = ex =>
{
lock (exceptions)
{
exceptions.Add(ex);
if (Interlocked.Decrement(ref remaining) == 0)
{
allDone.Set();
}
}
;
};
if (allEventsAtOnce)
{
wrapper.WriteAsyncLogEvents(inputEvents.Select(ev => ev.WithContinuation(asyncContinuation)).ToArray());
}
else
{
for (int i = 0; i < inputEvents.Count; ++i)
{
wrapper.WriteAsyncLogEvent(inputEvents[i].WithContinuation(asyncContinuation));
}
}
allDone.WaitOne();
Assert.Equal(inputEvents.Count, exceptions.Count);
foreach (var e in exceptions)
{
Assert.Null(e);
}
Assert.Equal(inputEvents.Count, myTarget1.WriteCount);
Assert.Equal(inputEvents.Count, myTarget2.WriteCount);
Assert.Equal(inputEvents.Count, myTarget3.WriteCount);
for (int i = 0; i < inputEvents.Count; ++i)
{
Assert.Same(inputEvents[i], myTarget1.WrittenEvents[i]);
Assert.Same(inputEvents[i], myTarget2.WrittenEvents[i]);
Assert.Same(inputEvents[i], myTarget3.WrittenEvents[i]);
}
Exception flushException = null;
var flushHit = new ManualResetEvent(false);
wrapper.Flush(ex =>
{
flushException = ex;
flushHit.Set();
});
flushHit.WaitOne();
if (flushException != null)
{
Assert.True(false, flushException.ToString());
}
Assert.Equal(1, myTarget1.FlushCount);
Assert.Equal(1, myTarget2.FlushCount);
Assert.Equal(1, myTarget3.FlushCount);
}
public void AsyncTargetWrapperSyncTest_WhenTimeToSleepBetweenBatchesIsEqualToZero()
{
LogManager.ThrowConfigExceptions = true;
var myTarget = new MyTarget();
var targetWrapper = new AsyncTargetWrapper() {
WrappedTarget = myTarget,
TimeToSleepBetweenBatches = 0,
BatchSize = 4,
QueueLimit = 2, // Will make it "sleep" between every second write
OverflowAction = AsyncTargetWrapperOverflowAction.Block
};
targetWrapper.Initialize(null);
myTarget.Initialize(null);
try
{
int flushCounter = 0;
AsyncContinuation flushHandler = (ex) => { ++flushCounter; };
List<KeyValuePair<LogEventInfo, AsyncContinuation>> itemPrepareList = new List<KeyValuePair<LogEventInfo, AsyncContinuation>>(2500);
List<int> itemWrittenList = new List<int>(itemPrepareList.Capacity);
for (int i = 0; i< itemPrepareList.Capacity; ++i)
{
var logEvent = new LogEventInfo();
int sequenceID = logEvent.SequenceID;
itemPrepareList.Add(new KeyValuePair<LogEventInfo, AsyncContinuation>(logEvent, (ex) => itemWrittenList.Add(sequenceID)));
}
long startTicks = Environment.TickCount;
for (int i = 0; i < itemPrepareList.Count; ++i)
{
var logEvent = itemPrepareList[i].Key;
targetWrapper.WriteAsyncLogEvent(logEvent.WithContinuation(itemPrepareList[i].Value));
}
targetWrapper.Flush(flushHandler);
for (int i = 0; i < itemPrepareList.Count * 2 && itemWrittenList.Count != itemPrepareList.Count; ++i)
System.Threading.Thread.Sleep(1);
long elapsedMilliseconds = Environment.TickCount - startTicks;
Assert.Equal(itemPrepareList.Count, itemWrittenList.Count);
int prevSequenceID = 0;
for (int i = 0; i < itemWrittenList.Count; ++i)
{
Assert.True(prevSequenceID < itemWrittenList[i]);
prevSequenceID = itemWrittenList[i];
}
#if MONO || NET3_5
Assert.True(elapsedMilliseconds < 2500); // Skip timing test when running within OpenCover.Console.exe
#endif
targetWrapper.Flush(flushHandler);
for (int i = 0; i < 2000 && flushCounter != 2; ++i)
System.Threading.Thread.Sleep(1);
Assert.Equal(2, flushCounter);
}
finally
{
myTarget.Close();
targetWrapper.Close();
}
}
public void RepeatingTargetWrapperTest2()
{
var target = new MyTarget();
target.ThrowExceptions = true;
var wrapper = new RepeatingTargetWrapper()
{
WrappedTarget = target,
RepeatCount = 3,
};
wrapper.Initialize(null);
target.Initialize(null);
var exceptions = new List<Exception>();
var events = new []
{
new LogEventInfo(LogLevel.Debug, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "Logger2", "Hello").WithContinuation(exceptions.Add),
};
wrapper.WriteAsyncLogEvents(events);
// make sure all events went through but were registered only once
// since repeating target wrapper will not repeat in case of exception.
Assert.Equal(3, target.Events.Count);
Assert.Same(events[0].LogEvent, target.Events[0]);
Assert.Same(events[1].LogEvent, target.Events[1]);
Assert.Same(events[2].LogEvent, target.Events[2]);
Assert.Equal(events.Length, exceptions.Count);
foreach (var exception in exceptions)
{
Assert.NotNull(exception);
Assert.Equal("Some exception has occurred.", exception.Message);
}
}
public void BufferingTargetWrapperSyncTest1()
{
var myTarget = new MyTarget();
var targetWrapper = new BufferingTargetWrapper
{
WrappedTarget = myTarget,
BufferSize = 10,
};
myTarget.Initialize(null);
targetWrapper.Initialize(null);
int totalEvents = 100;
var continuationHit = new bool[totalEvents];
var lastException = new Exception[totalEvents];
var continuationThread = new Thread[totalEvents];
int hitCount = 0;
CreateContinuationFunc createAsyncContinuation =
eventNumber =>
ex =>
{
lastException[eventNumber] = ex;
continuationThread[eventNumber] = Thread.CurrentThread;
continuationHit[eventNumber] = true;
Interlocked.Increment(ref hitCount);
};
// write 9 events - they will all be buffered and no final continuation will be reached
int eventCounter = 0;
for (int i = 0; i < 9; ++i)
{
targetWrapper.WriteAsyncLogEvent(new LogEventInfo().WithContinuation(createAsyncContinuation(eventCounter++)));
}
Assert.AreEqual(0, hitCount);
Assert.AreEqual(0, myTarget.WriteCount);
// write one more event - everything will be flushed
targetWrapper.WriteAsyncLogEvent(new LogEventInfo().WithContinuation(createAsyncContinuation(eventCounter++)));
Assert.AreEqual(10, hitCount);
Assert.AreEqual(1, myTarget.BufferedWriteCount);
Assert.AreEqual(10, myTarget.BufferedTotalEvents);
Assert.AreEqual(10, myTarget.WriteCount);
for (int i = 0; i < hitCount; ++i)
{
Assert.AreSame(Thread.CurrentThread, continuationThread[i]);
Assert.IsNull(lastException[i]);
}
// write 9 more events - they will all be buffered and no final continuation will be reached
for (int i = 0; i < 9; ++i)
{
targetWrapper.WriteAsyncLogEvent(new LogEventInfo().WithContinuation(createAsyncContinuation(eventCounter++)));
}
// no change
Assert.AreEqual(10, hitCount);
Assert.AreEqual(1, myTarget.BufferedWriteCount);
Assert.AreEqual(10, myTarget.BufferedTotalEvents);
Assert.AreEqual(10, myTarget.WriteCount);
Exception flushException = null;
var flushHit = new ManualResetEvent(false);
targetWrapper.Flush(
ex =>
{
flushException = ex;
flushHit.Set();
});
Thread.Sleep(1000);
flushHit.WaitOne();
Assert.IsNull(flushException);
// make sure remaining events were written
Assert.AreEqual(19, hitCount);
Assert.AreEqual(2, myTarget.BufferedWriteCount);
Assert.AreEqual(19, myTarget.BufferedTotalEvents);
Assert.AreEqual(19, myTarget.WriteCount);
Assert.AreEqual(1, myTarget.FlushCount);
// flushes happen on the same thread
for (int i = 10; i < hitCount; ++i)
{
Assert.IsNotNull(continuationThread[i]);
Assert.AreSame(Thread.CurrentThread, continuationThread[i], "Invalid thread #" + i);
Assert.IsNull(lastException[i]);
}
// flush again - should just invoke Flush() on the wrapped target
flushHit.Reset();
targetWrapper.Flush(
ex =>
{
flushException = ex;
flushHit.Set();
});
flushHit.WaitOne();
Assert.AreEqual(19, hitCount);
Assert.AreEqual(2, myTarget.BufferedWriteCount);
Assert.AreEqual(19, myTarget.BufferedTotalEvents);
Assert.AreEqual(19, myTarget.WriteCount);
Assert.AreEqual(2, myTarget.FlushCount);
targetWrapper.Close();
myTarget.Close();
}
public void BufferingTargetWrapperSyncWithTimedFlushSlidingTest()
{
var myTarget = new MyTarget();
var targetWrapper = new BufferingTargetWrapper
{
WrappedTarget = myTarget,
BufferSize = 10,
FlushTimeout = 400,
};
myTarget.Initialize(null);
targetWrapper.Initialize(null);
int totalEvents = 100;
var continuationHit = new bool[totalEvents];
var lastException = new Exception[totalEvents];
var continuationThread = new Thread[totalEvents];
int hitCount = 0;
CreateContinuationFunc createAsyncContinuation =
eventNumber =>
ex =>
{
lastException[eventNumber] = ex;
continuationThread[eventNumber] = Thread.CurrentThread;
continuationHit[eventNumber] = true;
Interlocked.Increment(ref hitCount);
};
int eventCounter = 0;
targetWrapper.WriteAsyncLogEvent(new LogEventInfo().WithContinuation(createAsyncContinuation(eventCounter++)));
Thread.Sleep(300);
Assert.AreEqual(0, hitCount);
Assert.AreEqual(0, myTarget.WriteCount);
targetWrapper.WriteAsyncLogEvent(new LogEventInfo().WithContinuation(createAsyncContinuation(eventCounter++)));
Thread.Sleep(300);
Assert.AreEqual(0, hitCount);
Assert.AreEqual(0, myTarget.WriteCount);
Thread.Sleep(200);
Assert.AreEqual(2, hitCount);
Assert.AreEqual(2, myTarget.WriteCount);
}
public void PostFilteringTargetWrapperUsingDefaultNonFilterTest2()
{
// in this case both rules would match, but first one is picked
var target = new MyTarget();
var wrapper = new PostFilteringTargetWrapper()
{
WrappedTarget = target,
Rules =
{
// when there is an error, emit everything
new FilteringRule("level >= LogLevel.Error", "true"),
// if we had any warnings, log debug too
new FilteringRule("level >= LogLevel.Warn", "level >= LogLevel.Debug"),
},
// by default log info and above
DefaultFilter = "level >= LogLevel.Info",
};
wrapper.Initialize(null);
target.Initialize(null);
var exceptions = new List<Exception>();
var events = new []
{
new LogEventInfo(LogLevel.Debug, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "Logger2", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Debug, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Trace, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "Logger3", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Error, "Logger1", "Hello").WithContinuation(exceptions.Add),
};
var internalLogOutput = RunAndCaptureInternalLog(() => wrapper.WriteAsyncLogEvents(events), LogLevel.Trace);
string expectedLogOutput = @"Trace Running PostFilteringWrapper Target[(unnamed)](MyTarget) on 7 events
Trace Rule matched: (level >= Error)
Trace Filter to apply: True
Trace After filtering: 7 events.
Trace Sending to MyTarget
";
Assert.AreEqual(expectedLogOutput, internalLogOutput);
// make sure all events went through
Assert.AreEqual(7, target.Events.Count);
Assert.AreSame(events[0].LogEvent, target.Events[0]);
Assert.AreSame(events[1].LogEvent, target.Events[1]);
Assert.AreSame(events[2].LogEvent, target.Events[2]);
Assert.AreSame(events[3].LogEvent, target.Events[3]);
Assert.AreSame(events[4].LogEvent, target.Events[4]);
Assert.AreSame(events[5].LogEvent, target.Events[5]);
Assert.AreSame(events[6].LogEvent, target.Events[6]);
Assert.AreEqual(events.Length, exceptions.Count, "Some continuations were not invoked.");
}
public void InitializeFailedTest()
{
var target = new MyTarget();
target.ThrowOnInitialize = true;
try
{
target.Initialize(CommonCfg);
Assert.Fail("Expected exception.");
}
catch(NLogConfigurationException) //(InvalidOperationException)
{ // HACK: check out the new behavior to throw exceptions
}
// after exception in Initialize(), the target becomes non-functional and all Write() operations
var exceptions = new List<Exception>();
target.WriteAsyncLogEvent(LogEventInfo.CreateNullEvent().WithContinuation(exceptions.Add));
Assert.AreEqual(0, target.WriteCount);
Assert.AreEqual(1, exceptions.Count);
Assert.IsNotNull(exceptions[0]);
Assert.AreEqual("Target " + target + " failed to initialize.", exceptions[0].Message);
Assert.AreEqual("Init error.", exceptions[0].InnerException.Message);
}
public void PostFilteringTargetWrapperNoFiltersDefined()
{
var target = new MyTarget();
var wrapper = new PostFilteringTargetWrapper()
{
WrappedTarget = target,
};
wrapper.Initialize(null);
target.Initialize(null);
var exceptions = new List<Exception>();
var events = new[]
{
new LogEventInfo(LogLevel.Debug, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "Logger2", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Debug, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Trace, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "Logger3", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Error, "Logger1", "Hello").WithContinuation(exceptions.Add),
};
wrapper.WriteAsyncLogEvents(events);
// make sure all events went through
Assert.Equal(7, target.Events.Count);
Assert.Same(events[0].LogEvent, target.Events[0]);
Assert.Same(events[1].LogEvent, target.Events[1]);
Assert.Same(events[2].LogEvent, target.Events[2]);
Assert.Same(events[3].LogEvent, target.Events[3]);
Assert.Same(events[4].LogEvent, target.Events[4]);
Assert.Same(events[5].LogEvent, target.Events[5]);
Assert.Same(events[6].LogEvent, target.Events[6]);
Assert.Equal(events.Length, exceptions.Count);
}
public void FallbackGroupTargetSyncTest6()
{
// fail once
var myTarget1 = new MyTarget()
{
FailCounter = 10
};
var myTarget2 = new MyTarget()
{
FailCounter = 3
};
var myTarget3 = new MyTarget()
{
FailCounter = 3
};
var wrapper = new FallbackGroupTarget()
{
Targets = { myTarget1, myTarget2, myTarget3 },
ReturnToFirstOnSuccess = true,
};
myTarget1.Initialize(null);
myTarget2.Initialize(null);
myTarget3.Initialize(null);
wrapper.Initialize(null);
List <Exception> exceptions = new List <Exception>();
// no exceptions
for (int i = 0; i < 10; ++i)
{
wrapper.WriteAsyncLogEvent(LogEventInfo.CreateNullEvent().WithContinuation(exceptions.Add));
}
Assert.AreEqual(10, exceptions.Count);
for (int i = 0; i < 10; ++i)
{
if (i < 3)
{
// for the first 3 rounds, no target is available
Assert.IsNotNull(exceptions[i]);
Assert.IsInstanceOfType(typeof(InvalidOperationException), exceptions[i]);
Assert.AreEqual("Some failure.", exceptions[i].Message);
}
else
{
Assert.IsNull(exceptions[i], Convert.ToString(exceptions[i]));
}
}
Assert.AreEqual(10, myTarget1.WriteCount);
Assert.AreEqual(10, myTarget2.WriteCount);
Assert.AreEqual(3, myTarget3.WriteCount);
Exception flushException = null;
var flushHit = new ManualResetEvent(false);
wrapper.Flush(ex => { flushException = ex; flushHit.Set(); });
flushHit.WaitOne();
if (flushException != null)
{
Assert.Fail(flushException.ToString());
}
Assert.AreEqual(1, myTarget1.FlushCount);
Assert.AreEqual(1, myTarget2.FlushCount);
Assert.AreEqual(1, myTarget3.FlushCount);
}
public void AsyncTargetWrapperSyncTest_WhenTimeToSleepBetweenBatchesIsEqualToZero()
{
LogManager.ThrowConfigExceptions = true;
var myTarget = new MyTarget();
var targetWrapper = new AsyncTargetWrapper()
{
WrappedTarget = myTarget,
TimeToSleepBetweenBatches = 0,
BatchSize = 4,
QueueLimit = 2, // Will make it "sleep" between every second write
OverflowAction = AsyncTargetWrapperOverflowAction.Block
};
targetWrapper.Initialize(null);
myTarget.Initialize(null);
try
{
int flushCounter = 0;
AsyncContinuation flushHandler = (ex) => { ++flushCounter; };
List <KeyValuePair <LogEventInfo, AsyncContinuation> > itemPrepareList = new List <KeyValuePair <LogEventInfo, AsyncContinuation> >(500);
List <int> itemWrittenList = new List <int>(itemPrepareList.Capacity);
for (int i = 0; i < itemPrepareList.Capacity; ++i)
{
var logEvent = new LogEventInfo();
int sequenceID = logEvent.SequenceID;
itemPrepareList.Add(new KeyValuePair <LogEventInfo, AsyncContinuation>(logEvent, (ex) => itemWrittenList.Add(sequenceID)));
}
long startTicks = Environment.TickCount;
for (int i = 0; i < itemPrepareList.Count; ++i)
{
var logEvent = itemPrepareList[i].Key;
targetWrapper.WriteAsyncLogEvent(logEvent.WithContinuation(itemPrepareList[i].Value));
}
targetWrapper.Flush(flushHandler);
for (int i = 0; i < itemPrepareList.Count * 2 && itemWrittenList.Count != itemPrepareList.Count; ++i)
{
System.Threading.Thread.Sleep(1);
}
long elapsedMilliseconds = Environment.TickCount - startTicks;
Assert.Equal(itemPrepareList.Count, itemWrittenList.Count);
int prevSequenceID = 0;
for (int i = 0; i < itemWrittenList.Count; ++i)
{
Assert.True(prevSequenceID < itemWrittenList[i]);
prevSequenceID = itemWrittenList[i];
}
if (!IsAppVeyor())
{
Assert.True(elapsedMilliseconds < 750); // Skip timing test when running within OpenCover.Console.exe
}
targetWrapper.Flush(flushHandler);
for (int i = 0; i < 2000 && flushCounter != 2; ++i)
{
System.Threading.Thread.Sleep(1);
}
Assert.Equal(2, flushCounter);
}
finally
{
myTarget.Close();
targetWrapper.Close();
}
}
public void SplitGroupSyncTest1()
{
var myTarget1 = new MyTarget();
var myTarget2 = new MyTarget();
var myTarget3 = new MyTarget();
var wrapper = new SplitGroupTarget()
{
Targets = { myTarget1, myTarget2, myTarget3 },
};
myTarget1.Initialize(null);
myTarget2.Initialize(null);
myTarget3.Initialize(null);
wrapper.Initialize(null);
List <Exception> exceptions = new List <Exception>();
var inputEvents = new List <LogEventInfo>();
for (int i = 0; i < 10; ++i)
{
inputEvents.Add(LogEventInfo.CreateNullEvent());
}
int remaining = inputEvents.Count;
var allDone = new ManualResetEvent(false);
// no exceptions
for (int i = 0; i < inputEvents.Count; ++i)
{
wrapper.WriteAsyncLogEvent(inputEvents[i].WithContinuation(ex =>
{
lock (exceptions)
{
exceptions.Add(ex);
if (Interlocked.Decrement(ref remaining) == 0)
{
allDone.Set();
}
};
}));
}
allDone.WaitOne();
Assert.Equal(inputEvents.Count, exceptions.Count);
foreach (var e in exceptions)
{
Assert.Null(e);
}
Assert.Equal(inputEvents.Count, myTarget1.WriteCount);
Assert.Equal(inputEvents.Count, myTarget2.WriteCount);
Assert.Equal(inputEvents.Count, myTarget3.WriteCount);
for (int i = 0; i < inputEvents.Count; ++i)
{
Assert.Same(inputEvents[i], myTarget1.WrittenEvents[i]);
Assert.Same(inputEvents[i], myTarget2.WrittenEvents[i]);
Assert.Same(inputEvents[i], myTarget3.WrittenEvents[i]);
}
Exception flushException = null;
var flushHit = new ManualResetEvent(false);
wrapper.Flush(ex => { flushException = ex; flushHit.Set(); });
flushHit.WaitOne();
if (flushException != null)
{
Assert.True(false, flushException.ToString());
}
Assert.Equal(1, myTarget1.FlushCount);
Assert.Equal(1, myTarget2.FlushCount);
Assert.Equal(1, myTarget3.FlushCount);
}
public void WriteOnClosedTargetTest()
{
var target = new MyTarget();
target.Initialize(null);
target.Close();
var exceptions = new List<Exception>();
target.WriteAsyncLogEvent(LogEventInfo.CreateNullEvent().WithContinuation(exceptions.Add));
target.WriteAsyncLogEvents(
LogEventInfo.CreateNullEvent().WithContinuation(exceptions.Add),
LogEventInfo.CreateNullEvent().WithContinuation(exceptions.Add),
LogEventInfo.CreateNullEvent().WithContinuation(exceptions.Add));
Assert.AreEqual(1, target.InitializeCount);
Assert.AreEqual(1, target.CloseCount);
// write was not called
Assert.AreEqual(2, target.InitializeCount + target.FlushCount + target.CloseCount + target.WriteCount + target.WriteCount2 + target.WriteCount3);
// but all callbacks were invoked with null values
Assert.AreEqual(4, exceptions.Count);
exceptions.ForEach(Assert.IsNull);
}
public void LockingTest()
{
var target = new MyTarget();
target.Initialize(null);
var mre = new ManualResetEvent(false);
Exception backgroundThreadException = null;
Thread t = new Thread(() =>
{
try
{
target.BlockingOperation(1000);
}
catch (Exception ex)
{
backgroundThreadException = ex;
}
finally
{
mre.Set();
}
});
target.Initialize(null);
t.Start();
Thread.Sleep(50);
List<Exception> exceptions = new List<Exception>();
target.WriteAsyncLogEvent(LogEventInfo.CreateNullEvent().WithContinuation(exceptions.Add));
target.WriteAsyncLogEvents(new[]
{
LogEventInfo.CreateNullEvent().WithContinuation(exceptions.Add),
LogEventInfo.CreateNullEvent().WithContinuation(exceptions.Add),
});
target.Flush(exceptions.Add);
target.Close();
exceptions.ForEach(Assert.IsNull);
mre.WaitOne();
if (backgroundThreadException != null)
{
Assert.Fail(backgroundThreadException.ToString());
}
}
public void AutoFlushOnConditionTest()
{
var testTarget = new MyTarget();
var autoFlushWrapper = new AutoFlushTargetWrapper(testTarget);
autoFlushWrapper.Condition = "level > LogLevel.Info";
testTarget.Initialize(null);
autoFlushWrapper.Initialize(null);
AsyncContinuation continuation = ex => { };
autoFlushWrapper.WriteAsyncLogEvent(LogEventInfo.Create(LogLevel.Info, "*", "test").WithContinuation(continuation));
autoFlushWrapper.WriteAsyncLogEvent(LogEventInfo.Create(LogLevel.Trace, "*", "test").WithContinuation(continuation));
Assert.Equal(2, testTarget.WriteCount);
Assert.Equal(0, testTarget.FlushCount);
autoFlushWrapper.WriteAsyncLogEvent(LogEventInfo.Create(LogLevel.Warn, "*", "test").WithContinuation(continuation));
autoFlushWrapper.WriteAsyncLogEvent(LogEventInfo.Create(LogLevel.Error, "*", "test").WithContinuation(continuation));
Assert.Equal(4, testTarget.WriteCount);
Assert.Equal(2, testTarget.FlushCount);
}
public void BufferingTargetWrapperSyncWithTimedFlushTest()
{
var myTarget = new MyTarget();
var targetWrapper = new BufferingTargetWrapper
{
WrappedTarget = myTarget,
BufferSize = 10,
FlushTimeout = 1000,
};
myTarget.Initialize(null);
targetWrapper.Initialize(null);
int totalEvents = 100;
var continuationHit = new bool[totalEvents];
var lastException = new Exception[totalEvents];
var continuationThread = new Thread[totalEvents];
int hitCount = 0;
CreateContinuationFunc createAsyncContinuation =
eventNumber =>
ex =>
{
lastException[eventNumber] = ex;
continuationThread[eventNumber] = Thread.CurrentThread;
continuationHit[eventNumber] = true;
Interlocked.Increment(ref hitCount);
};
// write 9 events - they will all be buffered and no final continuation will be reached
int eventCounter = 0;
for (int i = 0; i < 9; ++i)
{
targetWrapper.WriteAsyncLogEvent(new LogEventInfo().WithContinuation(createAsyncContinuation(eventCounter++)));
}
Assert.AreEqual(0, hitCount);
Assert.AreEqual(0, myTarget.WriteCount);
// sleep 2 seconds, this will trigger the timer and flush all events
Thread.Sleep(4000);
Assert.AreEqual(9, hitCount);
Assert.AreEqual(1, myTarget.BufferedWriteCount);
Assert.AreEqual(9, myTarget.BufferedTotalEvents);
Assert.AreEqual(9, myTarget.WriteCount);
for (int i = 0; i < hitCount; ++i)
{
Assert.AreNotSame(Thread.CurrentThread, continuationThread[i]);
Assert.IsNull(lastException[i]);
}
// write 11 more events, 10 will be hit immediately because the buffer will fill up
// 1 will be pending
for (int i = 0; i < 11; ++i)
{
targetWrapper.WriteAsyncLogEvent(new LogEventInfo().WithContinuation(createAsyncContinuation(eventCounter++)));
}
Assert.AreEqual(19, hitCount);
Assert.AreEqual(2, myTarget.BufferedWriteCount);
Assert.AreEqual(19, myTarget.BufferedTotalEvents);
Assert.AreEqual(19, myTarget.WriteCount);
// sleep 2 seonds and the last remaining one will be flushed
Thread.Sleep(2000);
Assert.AreEqual(20, hitCount);
Assert.AreEqual(3, myTarget.BufferedWriteCount);
Assert.AreEqual(20, myTarget.BufferedTotalEvents);
Assert.AreEqual(20, myTarget.WriteCount);
}
public void PostFilteringTargetWrapperUsingDefaultNonFilterTest()
{
var target = new MyTarget();
var wrapper = new PostFilteringTargetWrapper()
{
WrappedTarget = target,
Rules =
{
// if we had any warnings, log debug too
new FilteringRule("level >= LogLevel.Warn", "level >= LogLevel.Debug"),
// when there is an error, emit everything
new FilteringRule("level >= LogLevel.Error", "true"),
},
// by default log info and above
DefaultFilter = "level >= LogLevel.Info",
};
wrapper.Initialize(null);
target.Initialize(null);
var exceptions = new List<Exception>();
var events = new[]
{
new LogEventInfo(LogLevel.Debug, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "Logger2", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Debug, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Trace, "Logger1", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "Logger3", "Hello").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Warn, "Logger1", "Hello").WithContinuation(exceptions.Add),
};
string result = RunAndCaptureInternalLog(() => wrapper.WriteAsyncLogEvents(events), LogLevel.Trace);
Assert.True(result.IndexOf("Trace Running PostFilteringWrapper Target[(unnamed)](MyTarget) on 7 events") != -1);
Assert.True(result.IndexOf("Trace Rule matched: (level >= Warn)") != -1);
Assert.True(result.IndexOf("Trace Filter to apply: (level >= Debug)") != -1);
Assert.True(result.IndexOf("Trace After filtering: 6 events.") != -1);
Assert.True(result.IndexOf("Trace Sending to MyTarget") != -1);
// make sure all Debug,Info,Warn events went through
Assert.Equal(6, target.Events.Count);
Assert.Same(events[0].LogEvent, target.Events[0]);
Assert.Same(events[1].LogEvent, target.Events[1]);
Assert.Same(events[2].LogEvent, target.Events[2]);
Assert.Same(events[3].LogEvent, target.Events[3]);
Assert.Same(events[5].LogEvent, target.Events[4]);
Assert.Same(events[6].LogEvent, target.Events[5]);
Assert.Equal(events.Length, exceptions.Count);
}
public void FallbackGroupTargetSyncTest6()
{
// fail once
var myTarget1 = new MyTarget() { FailCounter = 10 };
var myTarget2 = new MyTarget() { FailCounter = 3 };
var myTarget3 = new MyTarget() { FailCounter = 3 };
var wrapper = new FallbackGroupTarget()
{
Targets = { myTarget1, myTarget2, myTarget3 },
ReturnToFirstOnSuccess = true,
};
myTarget1.Initialize(null);
myTarget2.Initialize(null);
myTarget3.Initialize(null);
wrapper.Initialize(null);
List<Exception> exceptions = new List<Exception>();
// no exceptions
for (int i = 0; i < 10; ++i)
{
wrapper.WriteAsyncLogEvent(LogEventInfo.CreateNullEvent().WithContinuation(exceptions.Add));
}
Assert.AreEqual(10, exceptions.Count);
for (int i = 0; i < 10; ++i)
{
if (i < 3)
{
// for the first 3 rounds, no target is available
Assert.IsNotNull(exceptions[i]);
Assert.IsInstanceOfType(exceptions[i], typeof(InvalidOperationException));
Assert.AreEqual("Some failure.", exceptions[i].Message);
}
else
{
Assert.IsNull(exceptions[i], Convert.ToString(exceptions[i]));
}
}
Assert.AreEqual(10, myTarget1.WriteCount);
Assert.AreEqual(10, myTarget2.WriteCount);
Assert.AreEqual(3, myTarget3.WriteCount);
Exception flushException = null;
var flushHit = new ManualResetEvent(false);
wrapper.Flush(ex => { flushException = ex; flushHit.Set(); });
flushHit.WaitOne();
if (flushException != null)
{
Assert.Fail(flushException.ToString());
}
Assert.AreEqual(1, myTarget1.FlushCount);
Assert.AreEqual(1, myTarget2.FlushCount);
Assert.AreEqual(1, myTarget3.FlushCount);
}
/// <summary>
/// Test Fix for https://github.com/NLog/NLog/issues/1069
/// </summary>
private void AsyncTargetWrapperSyncTest_WhenTimeToSleepBetweenBatchesIsEqualToZero(bool forceLockingQueue)
{
LogManager.ThrowConfigExceptions = true;
var myTarget = new MyTarget();
var targetWrapper = new AsyncTargetWrapper()
{
WrappedTarget = myTarget,
TimeToSleepBetweenBatches = 0,
#if NET4_5
ForceLockingQueue = forceLockingQueue,
OptimizeBufferReuse = !forceLockingQueue,
#endif
BatchSize = 3,
QueueLimit = 5, // Will make it "sleep" between every second write
FullBatchSizeWriteLimit = 1,
OverflowAction = AsyncTargetWrapperOverflowAction.Block
};
targetWrapper.Initialize(null);
myTarget.Initialize(null);
try
{
int flushCounter = 0;
AsyncContinuation flushHandler = (ex) => { ++flushCounter; };
var itemPrepareList = new List <AsyncLogEventInfo>(500);
var itemWrittenList = new List <int>(itemPrepareList.Capacity);
for (int i = 0; i < itemPrepareList.Capacity; ++i)
{
var logEvent = new LogEventInfo();
int sequenceID = logEvent.SequenceID;
bool blockConsumer = (itemPrepareList.Capacity / 2) == i; // Force producers to get into blocking-mode
itemPrepareList.Add(logEvent.WithContinuation((ex) => { if (blockConsumer)
{
Thread.Sleep(125);
}
itemWrittenList.Add(sequenceID); }));
}
var eventProducer0 = new ManualResetEvent(false);
var eventProducer1 = new ManualResetEvent(false);
ParameterizedThreadStart producerMethod = (s) =>
{
var eventProducer = (ManualResetEvent)s;
if (eventProducer != null)
{
eventProducer.Set(); // Signal we are ready
}
int partitionNo = ReferenceEquals(eventProducer, eventProducer1) ? 1 : 0;
for (int i = 0; i < itemPrepareList.Count; ++i)
{
if (i % 2 == partitionNo)
{
targetWrapper.WriteAsyncLogEvent(itemPrepareList[i]);
}
}
};
Thread producer0 = new Thread(producerMethod);
producer0.IsBackground = true;
Thread producer1 = new Thread(producerMethod);
producer1.IsBackground = true;
producer1.Start(eventProducer0);
producer0.Start(eventProducer1);
Assert.True(eventProducer0.WaitOne(5000), "Producer0 Start Timeout");
Assert.True(eventProducer1.WaitOne(5000), "Producer1 Start Timeout");
long startTicks = Environment.TickCount;
Assert.True(producer0.Join(5000), "Producer0 Complete Timeout"); // Wait for producer0 to complete
Assert.True(producer1.Join(5000), "Producer1 Complete Timeout"); // Wait for producer1 to complete
long elapsedMilliseconds = Environment.TickCount - startTicks;
targetWrapper.Flush(flushHandler);
for (int i = 0; i < itemPrepareList.Count * 2 && itemWrittenList.Count != itemPrepareList.Count; ++i)
{
Thread.Sleep(1);
}
Assert.Equal(itemPrepareList.Count, itemWrittenList.Count);
int producer0sequenceID = 0;
int producer1sequenceID = 0;
for (int i = 1; i < itemWrittenList.Count; ++i)
{
if (itemWrittenList[i] % 2 == 0)
{
Assert.True(producer0sequenceID < itemWrittenList[i], "Producer0 invalid sequence");
producer0sequenceID = itemWrittenList[i];
}
else
{
Assert.True(producer1sequenceID < itemWrittenList[i], "Producer1 invalid sequence");
producer1sequenceID = itemWrittenList[i];
}
}
#if NET4_5
if (!IsAppVeyor()) // Skip timing test when running within OpenCover.Console.exe
#endif
Assert.InRange(elapsedMilliseconds, 0, 950);
targetWrapper.Flush(flushHandler);
for (int i = 0; i < 2000 && flushCounter != 2; ++i)
{
Thread.Sleep(1);
}
Assert.Equal(2, flushCounter);
}
finally
{
myTarget.Close();
targetWrapper.Close();
}
}
public void BufferingTargetWrapperSyncWithTimedFlushTest()
{
var myTarget = new MyTarget();
var targetWrapper = new BufferingTargetWrapper
{
WrappedTarget = myTarget,
BufferSize = 10,
FlushTimeout = 1000,
};
myTarget.Initialize(null);
targetWrapper.Initialize(null);
int totalEvents = 100;
var continuationHit = new bool[totalEvents];
var lastException = new Exception[totalEvents];
var continuationThread = new Thread[totalEvents];
int hitCount = 0;
CreateContinuationFunc createAsyncContinuation =
eventNumber =>
ex =>
{
lastException[eventNumber] = ex;
continuationThread[eventNumber] = Thread.CurrentThread;
continuationHit[eventNumber] = true;
Interlocked.Increment(ref hitCount);
};
// write 9 events - they will all be buffered and no final continuation will be reached
int eventCounter = 0;
for (int i = 0; i < 9; ++i)
{
targetWrapper.WriteAsyncLogEvent(new LogEventInfo().WithContinuation(createAsyncContinuation(eventCounter++)));
}
Assert.AreEqual(0, hitCount);
Assert.AreEqual(0, myTarget.WriteCount);
// sleep 2 seconds, this will trigger the timer and flush all events
Thread.Sleep(2000);
Assert.AreEqual(9, hitCount);
Assert.AreEqual(1, myTarget.BufferedWriteCount);
Assert.AreEqual(9, myTarget.BufferedTotalEvents);
Assert.AreEqual(9, myTarget.WriteCount);
for (int i = 0; i < hitCount; ++i)
{
Assert.AreNotSame(Thread.CurrentThread, continuationThread[i]);
Assert.IsNull(lastException[i]);
}
// write 11 more events, 10 will be hit immediately because the buffer will fill up
// 1 will be pending
for (int i = 0; i < 11; ++i)
{
targetWrapper.WriteAsyncLogEvent(new LogEventInfo().WithContinuation(createAsyncContinuation(eventCounter++)));
}
Assert.AreEqual(19, hitCount);
Assert.AreEqual(2, myTarget.BufferedWriteCount);
Assert.AreEqual(19, myTarget.BufferedTotalEvents);
Assert.AreEqual(19, myTarget.WriteCount);
// sleep 2 seonds and the last remaining one will be flushed
Thread.Sleep(2000);
Assert.AreEqual(20, hitCount);
Assert.AreEqual(3, myTarget.BufferedWriteCount);
Assert.AreEqual(20, myTarget.BufferedTotalEvents);
Assert.AreEqual(20, myTarget.WriteCount);
}
