static void Main(string[] args)
{
FileTarget wrappedTarget = new FileTarget();
wrappedTarget.FileName = "${basedir}/file.txt";
PostFilteringTargetWrapper postFilteringTarget = new PostFilteringTargetWrapper();
postFilteringTarget.WrappedTarget = wrappedTarget;
// set up default filter
postFilteringTarget.DefaultFilter = "level >= LogLevel.Info";
FilteringRule rule;
// if there are any warnings in the buffer
// dump the messages whose level is Debug or higher
rule = new FilteringRule();
rule.Exists = "level >= LogLevel.Warn";
rule.Filter = "level >= LogLevel.Debug";
postFilteringTarget.Rules.Add(rule);
BufferingTargetWrapper target = new BufferingTargetWrapper();
target.BufferSize = 100;
target.WrappedTarget = postFilteringTarget;
NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(target, LogLevel.Debug);
Logger logger = LogManager.GetLogger("Example");
logger.Debug("log message");
}
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);
}
protected void Application_Start(object sender, EventArgs e)
{
FileTarget fileTarget = new FileTarget();
fileTarget.FileName = "${basedir}/logfile.txt";
PostFilteringTargetWrapper postfilteringTarget = new PostFilteringTargetWrapper();
ASPNetBufferingTargetWrapper aspnetBufferingTarget = new ASPNetBufferingTargetWrapper();
aspnetBufferingTarget.WrappedTarget = postfilteringTarget;
postfilteringTarget.WrappedTarget = fileTarget;
postfilteringTarget.DefaultFilter = "level >= LogLevel.Info";
FilteringRule rule = new FilteringRule();
rule.Exists = "level >= LogLevel.Warn";
rule.Filter = "level >= LogLevel.Debug";
postfilteringTarget.Rules.Add(rule);
SimpleConfigurator.ConfigureForTargetLogging(aspnetBufferingTarget, LogLevel.Debug);
}
public void PostFilteringTargetWrapperNoFiltersDefined()
{
var target = new MyTarget();
var wrapper = new PostFilteringTargetWrapper()
{
WrappedTarget = target,
};
((ISupportsInitialize)wrapper).Initialize();
((ISupportsInitialize)target).Initialize();
var events = new LogEventInfo[]
{
new LogEventInfo(LogLevel.Debug, "Logger1", "Hello"),
new LogEventInfo(LogLevel.Info, "Logger1", "Hello"),
new LogEventInfo(LogLevel.Info, "Logger2", "Hello"),
new LogEventInfo(LogLevel.Debug, "Logger1", "Hello"),
new LogEventInfo(LogLevel.Trace, "Logger1", "Hello"),
new LogEventInfo(LogLevel.Info, "Logger3", "Hello"),
new LogEventInfo(LogLevel.Error, "Logger1", "Hello"),
};
var exceptions = new List<Exception>();
var continuations = new AsyncContinuation[events.Length];
for (int i = 0; i < continuations.Length; ++i)
{
continuations[i] = exceptions.Add;
}
wrapper.WriteLogEvents(events, continuations);
// make sure all events went through
Assert.AreEqual(7, target.Events.Count);
Assert.AreSame(events[0], target.Events[0]);
Assert.AreSame(events[1], target.Events[1]);
Assert.AreSame(events[2], target.Events[2]);
Assert.AreSame(events[3], target.Events[3]);
Assert.AreSame(events[4], target.Events[4]);
Assert.AreSame(events[5], target.Events[5]);
Assert.AreSame(events[6], target.Events[6]);
Assert.AreEqual(continuations.Length, exceptions.Count, "Some continuations were not invoked.");
}
public void PostFilteringTargetWrapperNoFiltersDefined()
{
var target = new MyTarget();
var wrapper = new PostFilteringTargetWrapper()
{
WrappedTarget = target,
};
wrapper.Initialize(CommonCfg);
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.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 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(CommonCfg);
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.GetLines(), internalLogOutput.GetLines());
// 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 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 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",
};
((ISupportsInitialize)wrapper).Initialize();
((ISupportsInitialize)target).Initialize();
var events = new LogEventInfo[]
{
new LogEventInfo(LogLevel.Debug, "Logger1", "Hello"),
new LogEventInfo(LogLevel.Info, "Logger1", "Hello"),
new LogEventInfo(LogLevel.Info, "Logger2", "Hello"),
new LogEventInfo(LogLevel.Debug, "Logger1", "Hello"),
new LogEventInfo(LogLevel.Trace, "Logger1", "Hello"),
new LogEventInfo(LogLevel.Info, "Logger3", "Hello"),
};
var exceptions = new List<Exception>();
var continuations = new AsyncContinuation[events.Length];
for (int i = 0; i < continuations.Length; ++i)
{
continuations[i] = exceptions.Add;
}
wrapper.WriteLogEvents(events, continuations);
// make sure all Info events went through
Assert.AreEqual(3, target.Events.Count);
Assert.AreSame(events[1], target.Events[0]);
Assert.AreSame(events[2], target.Events[1]);
Assert.AreSame(events[5], target.Events[2]);
Assert.AreEqual(continuations.Length, exceptions.Count, "Some continuations were not invoked.");
}
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",
};
((ISupportsInitialize)wrapper).Initialize();
((ISupportsInitialize)target).Initialize();
var events = new LogEventInfo[]
{
new LogEventInfo(LogLevel.Debug, "Logger1", "Hello"),
new LogEventInfo(LogLevel.Info, "Logger1", "Hello"),
new LogEventInfo(LogLevel.Info, "Logger2", "Hello"),
new LogEventInfo(LogLevel.Debug, "Logger1", "Hello"),
new LogEventInfo(LogLevel.Trace, "Logger1", "Hello"),
new LogEventInfo(LogLevel.Info, "Logger3", "Hello"),
new LogEventInfo(LogLevel.Error, "Logger1", "Hello"),
};
var exceptions = new List<Exception>();
var continuations = new AsyncContinuation[events.Length];
for (int i = 0; i < continuations.Length; ++i)
{
continuations[i] = exceptions.Add;
}
var internalLogOutput = RunAndCaptureInternalLog(() => wrapper.WriteLogEvents(events, continuations), LogLevel.Trace);
string expectedLogOutput = @"Trace Input: 7 events
Trace Rule matched: (level >= Error)
Trace Filter to apply: True
Trace After filtering: 7 events
";
Assert.AreEqual(expectedLogOutput, internalLogOutput);
// make sure all events went through
Assert.AreEqual(7, target.Events.Count);
Assert.AreSame(events[0], target.Events[0]);
Assert.AreSame(events[1], target.Events[1]);
Assert.AreSame(events[2], target.Events[2]);
Assert.AreSame(events[3], target.Events[3]);
Assert.AreSame(events[4], target.Events[4]);
Assert.AreSame(events[5], target.Events[5]);
Assert.AreSame(events[6], target.Events[6]);
Assert.AreEqual(continuations.Length, exceptions.Count, "Some continuations were not invoked.");
}
