public void NestedXmlConfigElementTest()
{
LoggingConfiguration c = XmlLoggingConfiguration.CreateFromXmlString(@"
<nlog>
<extensions>
<add type='" + typeof(StructuredDebugTarget).AssemblyQualifiedName + @"' />
</extensions>
<targets>
<target type='StructuredDebugTarget'>
<name>structuredTgt</name>
<layout>${message}</layout>
<config platform='any'>
<parameter name='param1' />
</config>
</target>
</targets>
</nlog>");
var t = c.FindTargetByName("structuredTgt") as StructuredDebugTarget;
Assert.NotNull(t);
Assert.Equal("any", t.Config.Platform);
Assert.Equal("param1", t.Config.Parameter.Name);
}
public static async Task ExecuteInNlogWrap(string loggerName, Func <Task> hostRunTaskFactory)
{
var curDir = Directory.GetCurrentDirectory();
var cfg = new XmlLoggingConfiguration(Path.Combine(curDir, "nlog.config"));
LogManager.Configuration = cfg;
var logger = LogManager.GetLogger(loggerName);
try
{
await hostRunTaskFactory();
}
catch (Exception exception)
{
//NLog: catch setup errors
logger.Error(exception, "Stopped program because of exception");
throw;
}
finally
{
// Ensure to flush and stop internal timers/threads before application-exit (Avoid segmentation fault on Linux)
LogManager.Shutdown();
}
}
public void AggregateExceptionSingleTest()
{
LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@"
<nlog>
<targets>
<target name='debug1' type='Debug' layout='${exception:format=message,shorttype:maxInnerExceptionLevel=5}' />
</targets>
<rules>
<logger minlevel='Info' writeTo='debug1' />
</rules>
</nlog>");
var task1 = System.Threading.Tasks.Task.Factory.StartNew(() => { throw new Exception("Test exception 1", new Exception("Test Inner 1")); },
System.Threading.CancellationToken.None, System.Threading.Tasks.TaskCreationOptions.None, System.Threading.Tasks.TaskScheduler.Default);
var aggregateExceptionMessage = "nothing thrown!";
try
{
System.Threading.Tasks.Task.WaitAll(new[] { task1 });
}
catch (AggregateException ex)
{
aggregateExceptionMessage = ex.ToString();
logger.Error(ex, "msg");
}
Assert.Contains(typeof(AggregateException).Name, aggregateExceptionMessage);
Assert.Contains("Test exception 1", aggregateExceptionMessage);
Assert.Contains("Test Inner 1", aggregateExceptionMessage);
var lastMessage = GetDebugLastMessage("debug1");
Assert.StartsWith("Test exception 1", lastMessage);
Assert.Contains("Test Inner 1", lastMessage);
}
public void AsyncTaskTarget_SkipAsyncTargetWrapper()
{
try
{
ConfigurationItemFactory.Default.RegisterType(typeof(AsyncTaskTestTarget), null);
LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@"
<nlog throwExceptions='true'>
<targets async='true'>
<target name='asyncDebug' type='AsyncTaskTest' />
<target name='debug' type='Debug' />
</targets>
<rules>
<logger name='*' minlevel='Debug' writeTo='debug' />
</rules>
</nlog>");
Assert.NotNull(LogManager.Configuration.FindTargetByName <AsyncTaskTestTarget>("asyncDebug"));
Assert.NotNull(LogManager.Configuration.FindTargetByName <NLog.Targets.Wrappers.AsyncTargetWrapper>("debug"));
}
finally
{
ConfigurationItemFactory.Default = null;
}
}
public void CustomInnerException_ObsoleteMethodTest()
{
LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@"
<nlog>
<targets>
<target name='debug1' type='Debug' layout='${exception:format=shorttype,message:maxInnerExceptionLevel=1:innerExceptionSeparator= ----INNER---- :innerFormat=type,message}' />
<target name='debug2' type='Debug' layout='${exception:format=shorttype,message:maxInnerExceptionLevel=1:innerExceptionSeparator= ----INNER---- :innerFormat=type,message,data}' />
</targets>
<rules>
<logger minlevel='Info' writeTo='debug1' />
<logger minlevel='Info' writeTo='debug2' />
</rules>
</nlog>");
var t = (DebugTarget)LogManager.Configuration.AllTargets[0];
var elr = ((SimpleLayout)t.Layout).Renderers[0] as ExceptionLayoutRenderer;
Assert.Equal("\r\n----INNER----\r\n", elr.InnerExceptionSeparator);
string exceptionMessage = "Test exception";
const string exceptionDataKey = "testkey";
const string exceptionDataValue = "testvalue";
Exception ex = GetNestedExceptionWithStackTrace(exceptionMessage);
ex.InnerException.Data.Add(exceptionDataKey, exceptionDataValue);
#pragma warning disable 0618
// Obsolete method requires testing until completely removed.
logger.ErrorException("msg", ex);
#pragma warning restore 0618
AssertDebugLastMessage("debug1", "ApplicationException Wrapper2" +
"\r\n----INNER----\r\n" +
"System.ArgumentException Wrapper1");
AssertDebugLastMessage("debug2", string.Format("ApplicationException Wrapper2" +
"\r\n----INNER----\r\n" +
"System.ArgumentException Wrapper1 " + ExceptionDataFormat, exceptionDataKey, exceptionDataValue));
}
public void NormalStringFormatTest()
{
LogEventInfo logEventInfo = new LogEventInfo(LogLevel.Info, "MyLogger", null, "{0:X} - Login request from {1} for {2} with userid {0}", new object[]
{
42,
"John",
"BestApplicationEver"
});
LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@"
<nlog throwExceptions='true'>
<targets>
<target name='debug' type='Debug' >
<layout type='JsonLayout' IncludeAllProperties='true'>
<attribute name='LogMessage' layout='${message:raw=true}' />
</layout>
</target>
</targets>
<rules>
<logger name='*' levels='Info' writeTo='debug' />
</rules>
</nlog>");
ILogger logger = LogManager.GetLogger("A");
logEventInfo.LoggerName = logger.Name;
logger.Log(logEventInfo);
AssertDebugLastMessage("debug", "{ \"LogMessage\": \"{0:X} - Login request from {1} for {2} with userid {0}\" }");
Assert.Equal("2A - Login request from John for BestApplicationEver with userid 42", logEventInfo.FormattedMessage);
Assert.Contains(new MessageTemplateParameter("0", 42, "X", CaptureType.Normal), logEventInfo.MessageTemplateParameters);
Assert.Contains(new MessageTemplateParameter("1", "John", null, CaptureType.Normal), logEventInfo.MessageTemplateParameters);
Assert.Contains(new MessageTemplateParameter("2", "BestApplicationEver", null, CaptureType.Normal), logEventInfo.MessageTemplateParameters);
Assert.Contains(new MessageTemplateParameter("0", 42, null, CaptureType.Normal), logEventInfo.MessageTemplateParameters);
}
public static void Init(bool forceInit = false)
{
if (!_init || forceInit)
{
#if NET_CORE
string nlogConfigPath = Path.Combine(SpiderConsts.BaseDirectory, "nlog.netcore.config");
#else
string nlogConfigPath = Path.Combine(SpiderConsts.BaseDirectory, "nlog.net45.config");
#endif
if (!File.Exists(nlogConfigPath))
{
File.AppendAllText(nlogConfigPath, Resource.nlog);
}
XmlLoggingConfiguration configuration = new XmlLoggingConfiguration(nlogConfigPath);
var connectString = Configuration.GetValue("logAndStatusConnectString");
var logAndStatusTargets = configuration.AllTargets.Where(t => t.Name == "dblog" || t.Name == "dbstatus").ToList();
if (!string.IsNullOrEmpty(connectString))
{
foreach (var logAndStatusTarget in logAndStatusTargets)
{
DatabaseTarget dbTarget = (DatabaseTarget)logAndStatusTarget;
dbTarget.ConnectionString = connectString;
}
}
var needDeleteRules = configuration.LoggingRules.Where(r => r.Targets.Any(t => t is DatabaseTarget && ((DatabaseTarget)t).ConnectionString == null)).ToList();
foreach (var rule in needDeleteRules)
{
configuration.LoggingRules.Remove(rule);
}
configuration.Install(new InstallationContext());
LogManager.Configuration = configuration;
_init = true;
}
}
public void IncludeAllJsonPropertiesMutableNestedXml()
{
// Arrange
LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@"
<nlog throwExceptions='true'>
<targets>
<target name='asyncDebug' type='BufferingWrapper'>
<target name='debug' type='Debug'>
<layout type='JsonLayout'>
<attribute name='properties' encode='false' >
<layout type='JsonLayout' IncludeAllProperties='true' ExcludeProperties='Excluded1,Excluded2' />
</attribute>
</layout>
</target>
</target>
</targets>
<rules>
<logger name='*' minlevel='Debug' writeTo='asyncDebug' />
</rules>
</nlog>");
ILogger logger = LogManager.GetLogger("A");
// Act
var logEventInfo = CreateLogEventWithExcluded();
var stringPropBuilder = new System.Text.StringBuilder(logEventInfo.Properties["StringProp"].ToString());
logEventInfo.Properties["StringProp"] = stringPropBuilder;
logger.Debug(logEventInfo);
stringPropBuilder.Clear();
LogManager.Flush();
// Assert
AssertDebugLastMessageContains("debug", ExpectedIncludeAllPropertiesWithExcludes);
}
public static void InitLogCenter()
{
#if !NET_CORE
string nlogConfigPath = Path.Combine(Env.BaseDirectory, "nlog.net45.config");
#else
string nlogConfigPath = Path.Combine(Env.BaseDirectory, "nlog.config");
#endif
if (!File.Exists(nlogConfigPath))
{
File.AppendAllText(nlogConfigPath, GetDefaultConfigString());
}
XmlLoggingConfiguration configuration = new XmlLoggingConfiguration(nlogConfigPath);
if (Env.SystemConnectionStringSettings == null)
{
var needDeleteRules = configuration.LoggingRules.Where(r => r.Targets.Any(t => t is DatabaseTarget && ((DatabaseTarget)t).ConnectionString == null)).ToList();
foreach (var rule in needDeleteRules)
{
configuration.LoggingRules.Remove(rule);
}
configuration.RemoveTarget("dblog");
}
else
{
var dblog = configuration.AllTargets.FirstOrDefault(t => t.Name == "dblog");
if (dblog != null)
{
DatabaseTarget dbTarget = (DatabaseTarget)dblog;
dbTarget.ConnectionString = Env.SystemConnectionStringSettings.ConnectionString;
}
}
configuration.Install(new InstallationContext());
LogManager.Configuration = configuration;
Logger = GetLogger();
}
public void LayoutCounterTest()
{
LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@"
<nlog>
<targets><target name='debug' type='Debug' layout='${message} ${counter:sequence=${event-context:item=context1}} ${counter}' /></targets>
<rules>
<logger name='*' minlevel='Info' writeTo='debug' />
</rules>
</nlog>");
ILogger logger = LogManager.GetLogger("A");
logger.Info().Message("a").Property("context1", "seq1").Write();
AssertDebugLastMessage("debug", "a 1 1");
logger.Info().Message("a").Property("context1", "seq1").Write();
AssertDebugLastMessage("debug", "a 2 2");
logger.Info().Message("a").Property("context1", "seq2").Write();
AssertDebugLastMessage("debug", "a 1 3");
logger.Info().Message("a").Property("context1", "seq1").Write();
AssertDebugLastMessage("debug", "a 3 4");
}
public void AssignArrayPropertyFromStringWillResultInNotSupportedExceptionSomeWhereDeep()
{
// Arrange
var config = @"
<nlog throwExceptions='true'>
<targets>
<target name='f' type='File' filename='test.log'>
<layout type='CSVLayout' column='a'>
</layout>
</target>
</targets>
<rules>
<logger name='*' minlevel='Debug' writeTo='f' />
</rules>
</nlog>";
// Act
var ex = Assert.Throws <NLogConfigurationException>(() => XmlLoggingConfiguration.CreateFromXmlString(config));
// Assert
Assert.IsType <NLogConfigurationException>(ex.InnerException);
Assert.IsType <NotSupportedException>(ex.InnerException.InnerException);
Assert.Contains("is an array, and cannot be assigned a scalar value", ex.InnerException.InnerException.Message);
}
public void UpperCaseTest()
{
LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@"
<nlog throwExceptions='true'>
<TARGETS><TARGET NAME='DEBUG' TYPE='DEBUG' LAYOUT='${MESSAGE}' /></TARGETS>
<RULES>
<LOGGER NAME='*' MINLEVEL='INFO' APPENDTO='DEBUG'>
<FILTERS DEFAULTACTION='LOG'>
<WHENCONTAINS LAYOUT='${MESSAGE}' SUBSTRING='msg' ACTION='IGNORE' />
</FILTERS>
</LOGGER>
</RULES>
</nlog>");
ILogger logger = LogManager.GetLogger("A");
logger.Debug("msg");
logger.Info("msg");
logger.Warn("msg");
logger.Error("msg");
logger.Fatal("msg");
logger.Debug("message");
AssertDebugCounter("debug", 0);
logger.Info("message");
AssertDebugCounter("debug", 1);
logger.Warn("message");
AssertDebugCounter("debug", 2);
logger.Error("message");
AssertDebugCounter("debug", 3);
logger.Fatal("message");
AssertDebugCounter("debug", 4);
}
public void ExceptionWithSeparatorForExistingRender()
{
LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@"
<nlog>
<targets>
<target name='debug1' type='Debug' layout='${exception:format=tostring,data:separator=\r\nXXX}' />
</targets>
<rules>
<logger minlevel='Info' writeTo='debug1' />
</rules>
</nlog>");
const string exceptionMessage = "message for exception";
const string exceptionDataKey1 = "testkey1";
const string exceptionDataValue1 = "testvalue1";
Exception ex = GetExceptionWithoutStackTrace(exceptionMessage);
ex.Data.Add(exceptionDataKey1, exceptionDataValue1);
logger.Error(ex);
AssertDebugLastMessage("debug1", string.Format(ExceptionDataFormat, ex.GetType().FullName, exceptionMessage) + "\r\nXXX" + string.Format(ExceptionDataFormat, exceptionDataKey1, exceptionDataValue1));
}
static LogCenter()
{
#if !NET_CORE
string nlogConfigPath = Path.Combine(Environment.BaseDirectory, "nlog.net45.config");
#else
string nlogConfigPath = Path.Combine(Environment.BaseDirectory, "nlog.config");
#endif
if (!File.Exists(nlogConfigPath))
{
File.AppendAllText(nlogConfigPath, GetDefaultConfigString());
}
XmlLoggingConfiguration configuration = new XmlLoggingConfiguration(nlogConfigPath);
var connectString = Config.GetValue("connectString");
var logAndStatusTargets = configuration.AllTargets.Where(t => t.Name == "dblog" || t.Name == "dbstatus").ToList();
if (!string.IsNullOrEmpty(connectString))
{
foreach (var logAndStatusTarget in logAndStatusTargets)
{
DatabaseTarget dbTarget = (DatabaseTarget)logAndStatusTarget;
dbTarget.ConnectionString = connectString;
}
}
else
{
var needDeleteRules = configuration.LoggingRules.Where(r => r.Targets.Any(t => t is DatabaseTarget && ((DatabaseTarget)t).ConnectionString == null)).ToList();
foreach (var rule in needDeleteRules)
{
configuration.LoggingRules.Remove(rule);
}
configuration.RemoveTarget("dblog");
configuration.RemoveTarget("dbstatus");
}
configuration.Install(new InstallationContext());
LogManager.Configuration = configuration;
}
public void XmlConfig_attributes_shouldNotLogWarningsToInternalLog(string @namespace)
{
// Arrange
var xml = $@"<?xml version=""1.0"" encoding=""utf-8""?>
<nlog xmlns=""http://www.nlog-project.org/schemas/NLog.xsd""
xmlns:{@namespace}=""http://www.w3.org/2001/XMLSchema-instance""
{@namespace}:schemaLocation=""somewhere""
{@namespace}:type=""asa""
internalLogToConsole=""true"" internalLogLevel=""Warn"">
</nlog>";
try
{
// ReSharper disable once UnusedVariable
var factory = ConfigurationItemFactory.Default; // retrieve factory for calling preload and so won't assert those warnings
TextWriter textWriter = new StringWriter();
InternalLogger.LogWriter = textWriter;
InternalLogger.IncludeTimestamp = false;
// Act
XmlLoggingConfiguration.CreateFromXmlString(xml);
// Assert
InternalLogger.LogWriter.Flush();
var warning = textWriter.ToString();
Assert.Equal("", warning);
}
finally
{
// cleanup
InternalLogger.LogWriter = null;
}
}
public void Can_configure_from_xml_file()
{
string configXml = $@"
<nlog throwConfigExceptions='true'>
<extensions>
<add type='{typeof(SentryTarget).AssemblyQualifiedName}' />
</extensions>
<targets>
<target type='Sentry' name='sentry' dsn='{ValidDsnWithoutSecret}'>
<options>
<environment>Development</environment>
</options>
</target>
</targets>
</nlog>";
var c = XmlLoggingConfiguration.CreateFromXmlString(configXml);
var t = c.FindTargetByName("sentry") as SentryTarget;
Assert.NotNull(t);
Assert.Equal(ValidDsnWithoutSecret, t.Options.Dsn.ToString());
Assert.Equal("Development", t.Options.Environment);
}
public void ExceptionNewLineSeparatorTest()
{
LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@"
<nlog>
<targets>
<target name='debug1' type='Debug' layout='${exception:format=message,shorttype:separator= }' />
</targets>
<rules>
<logger minlevel='Info' writeTo='debug1' />
</rules>
</nlog>");
string exceptionMessage = "Test exception";
Exception ex = GetExceptionWithStackTrace(exceptionMessage);
#pragma warning disable 0618
// Obsolete method requires testing until completely removed.
logger.ErrorException("msg", ex);
AssertDebugLastMessage("debug1", "Test exception\r\n" + typeof(CustomArgumentException).Name);
#pragma warning restore 0618
logger.Error(ex, "msg");
AssertDebugLastMessage("debug1", "Test exception\r\n" + typeof(CustomArgumentException).Name);
}
public void APITest()
{
// this is mostly to make Clover happy
LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@"
<nlog>
<targets><target name='debug' type='Debug' layout='${message}' /></targets>
<rules>
<logger name='*' minlevel='Debug' writeTo='debug'>
<filters>
<whenContains layout='${message}' substring='zzz' action='Ignore' />
</filters>
</logger>
</rules>
</nlog>");
Assert.True(LogManager.Configuration.LoggingRules[0].Filters[0] is WhenContainsFilter);
var wcf = (WhenContainsFilter)LogManager.Configuration.LoggingRules[0].Filters[0];
Assert.IsType <SimpleLayout>(wcf.Layout);
Assert.Equal("${message}", ((SimpleLayout)wcf.Layout).Text);
Assert.Equal("zzz", wcf.Substring);
Assert.Equal(FilterResult.Ignore, wcf.Action);
}
public static LogFactory ConfigureNLog(string application, string configFile = DefaultNLogConfigFile)
{
if (string.IsNullOrEmpty(configFile))
{
throw new ArgumentNullException(nameof(configFile));
}
var file = configFile;
if (!File.Exists(file))
{
file = ResolveSharedFileLocation(configFile);
if (string.IsNullOrEmpty(file))
{
throw new FileNotFoundException("File not exists.", file);
}
}
var configuration = new XmlLoggingConfiguration(file);
configuration.Variables["FeiniuBus-Application"] = application;
return(NLogBuilder.ConfigureNLog(configuration));
}
public void LoggingRule_LevelOff_NotSetAsActualLogLevel()
{
LoggingConfiguration c = XmlLoggingConfiguration.CreateFromXmlString(@"
<nlog>
<targets>
<target name='l1' type='Debug' layout='${message}' />
<target name='l2' type='Debug' layout='${message}' />
</targets>
<rules>
<logger name='a' level='Off' appendTo='l1' />
<logger name='a' minlevel='Debug' appendTo='l2' />
</rules>
</nlog>");
LogManager.Configuration = c;
LogManager.GetLogger("a");
Assert.Equal(2, c.LoggingRules.Count);
Assert.False(c.LoggingRules[0].IsLoggingEnabledForLevel(LogLevel.Off), "Log level Off should always return false.");
// The two functions below should not throw an exception.
c.LoggingRules[0].EnableLoggingForLevel(LogLevel.Debug);
c.LoggingRules[0].DisableLoggingForLevel(LogLevel.Debug);
}
public void LoggingRule_LevelsLayout_ParseLevel(string levelsVariable, LogLevel[] expectedLevels)
{
var config = XmlLoggingConfiguration.CreateFromXmlString(@"
<nlog>"
+ (!string.IsNullOrEmpty(levelsVariable) ? $"<variable name='var_levels' value='{levelsVariable}'/>" : "") +
@"<targets>
<target name='d1' type='Debug' layout='${message}' />
</targets>
<rules>
<logger name='*' levels='${var:var_levels}' writeTo='d1' />
</rules>
</nlog>");
LogManager.Configuration = config;
var logger = LogManager.GetLogger(nameof(LoggingRule_LevelsLayout_ParseLevel));
AssertLogLevelEnabled(logger, expectedLevels);
// Verify that runtime override also works
LogManager.Configuration.Variables["var_levels"] = LogLevel.Fatal.ToString();
LogManager.ReconfigExistingLoggers();
AssertLogLevelEnabled(logger, LogLevel.Fatal);
}
public void FiltersTest()
{
LoggingConfiguration c = XmlLoggingConfiguration.CreateFromXmlString(@"
<nlog>
<targets>
<target name='d1' type='Debug' />
<target name='d2' type='Debug' />
<target name='d3' type='Debug' />
<target name='d4' type='Debug' />
</targets>
<rules>
<logger name='*' level='Warn' writeTo='d1,d2,d3'>
<filters>
<when condition=""starts-with(message, 'x')"" action='Ignore' />
<when condition=""starts-with(message, 'z')"" action='Ignore' />
</filters>
</logger>
</rules>
</nlog>");
Assert.Equal(1, c.LoggingRules.Count);
var rule = c.LoggingRules[0];
Assert.Equal(2, rule.Filters.Count);
var conditionBasedFilter = rule.Filters[0] as ConditionBasedFilter;
Assert.NotNull(conditionBasedFilter);
Assert.Equal("starts-with(message, 'x')", conditionBasedFilter.Condition.ToString());
Assert.Equal(FilterResult.Ignore, conditionBasedFilter.Action);
conditionBasedFilter = rule.Filters[1] as ConditionBasedFilter;
Assert.NotNull(conditionBasedFilter);
Assert.Equal("starts-with(message, 'z')", conditionBasedFilter.Condition.ToString());
Assert.Equal(FilterResult.Ignore, conditionBasedFilter.Action);
}
public void MultipleTargetsTest()
{
LoggingConfiguration c = XmlLoggingConfiguration.CreateFromXmlString(@"
<nlog>
<targets>
<target name='d1' type='Debug' />
<target name='d2' type='Debug' />
<target name='d3' type='Debug' />
<target name='d4' type='Debug' />
</targets>
<rules>
<logger name='*' level='Warn' writeTo='d1,d2,d3' />
</rules>
</nlog>");
Assert.Equal(1, c.LoggingRules.Count);
var rule = c.LoggingRules[0];
Assert.Equal(3, rule.Targets.Count);
Assert.Same(c.FindTargetByName("d1"), rule.Targets[0]);
Assert.Same(c.FindTargetByName("d2"), rule.Targets[1]);
Assert.Same(c.FindTargetByName("d3"), rule.Targets[2]);
}
public void NoLevelsTest()
{
LoggingConfiguration c = XmlLoggingConfiguration.CreateFromXmlString(@"
<nlog>
<targets>
<target name='d1' type='Debug' />
</targets>
<rules>
<logger name='*' writeTo='d1' />
</rules>
</nlog>");
Assert.Equal(1, c.LoggingRules.Count);
var rule = c.LoggingRules[0];
Assert.Equal(6, rule.Levels.Count);
Assert.Contains(LogLevel.Trace, rule.Levels);
Assert.Contains(LogLevel.Debug, rule.Levels);
Assert.Contains(LogLevel.Info, rule.Levels);
Assert.Contains(LogLevel.Warn, rule.Levels);
Assert.Contains(LogLevel.Error, rule.Levels);
Assert.Contains(LogLevel.Fatal, rule.Levels);
}
public void LowerCaseTest()
{
LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@"
<nlog>
<targets><target name='debug' type='debug' layout='${message}' /></targets>
<rules>
<logger name='*' minlevel='info' appendto='debug'>
<filters defaultAction='log'>
<whencontains layout='${message}' substring='msg' action='ignore' />
</filters>
</logger>
</rules>
</nlog>");
ILogger logger = LogManager.GetLogger("A");
logger.Debug("msg");
logger.Info("msg");
logger.Warn("msg");
logger.Error("msg");
logger.Fatal("msg");
logger.Debug("message");
AssertDebugCounter("debug", 0);
logger.Info("message");
AssertDebugCounter("debug", 1);
logger.Warn("message");
AssertDebugCounter("debug", 2);
logger.Error("message");
AssertDebugCounter("debug", 3);
logger.Fatal("message");
AssertDebugCounter("debug", 4);
}
public void Log4JXmlTest()
{
LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@"
<nlog throwExceptions='true'>
<targets>
<target name='debug' type='Debug' layout='${log4jxmlevent:includeCallSite=true:includeSourceInfo=true:includeNdlc=true:includeMdc=true:IncludeNdc=true:includeMdlc=true:IncludeAllProperties=true:ndcItemSeparator=\:\::includenlogdata=true:loggerName=${logger}}' />
</targets>
<rules>
<logger name='*' minlevel='Debug' writeTo='debug' />
</rules>
</nlog>");
MappedDiagnosticsContext.Clear();
NestedDiagnosticsContext.Clear();
MappedDiagnosticsContext.Set("foo1", "bar1");
MappedDiagnosticsContext.Set("foo2", "bar2");
MappedDiagnosticsLogicalContext.Clear();
MappedDiagnosticsLogicalContext.Set("foo3", "bar3");
NestedDiagnosticsLogicalContext.Push("boo1");
NestedDiagnosticsLogicalContext.Push("boo2");
NestedDiagnosticsContext.Push("baz1");
NestedDiagnosticsContext.Push("baz2");
NestedDiagnosticsContext.Push("baz3");
ILogger logger = LogManager.GetLogger("A");
var logEventInfo = LogEventInfo.Create(LogLevel.Debug, "A", new Exception("Hello Exception", new Exception("Goodbye Exception")), null, "some message");
logEventInfo.Properties["nlogPropertyKey"] = "nlogPropertyValue";
logger.Log(logEventInfo);
string result = GetDebugLastMessage("debug");
string wrappedResult = "<log4j:dummyRoot xmlns:log4j='http://log4j' xmlns:nlog='http://nlog'>" + result + "</log4j:dummyRoot>";
Assert.NotEqual("", result);
// make sure the XML can be read back and verify some fields
StringReader stringReader = new StringReader(wrappedResult);
var foundsChilds = new Dictionary <string, int>();
var requiredChilds = new List <string>
{
"log4j.event",
"log4j.message",
"log4j.NDC",
"log4j.locationInfo",
"nlog.locationInfo",
"log4j.properties",
"nlog.properties",
"log4j.throwable",
"log4j.data",
"nlog.data",
};
using (XmlReader reader = XmlReader.Create(stringReader))
{
while (reader.Read())
{
var key = reader.LocalName;
var fullKey = reader.Prefix + "." + key;
if (!foundsChilds.ContainsKey(fullKey))
{
foundsChilds[fullKey] = 0;
}
foundsChilds[fullKey]++;
if (reader.NodeType == XmlNodeType.Element && reader.Prefix == "log4j")
{
switch (reader.LocalName)
{
case "dummyRoot":
break;
case "event":
Assert.Equal("DEBUG", reader.GetAttribute("level"));
Assert.Equal("A", reader.GetAttribute("logger"));
var epochStart = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
long timestamp = Convert.ToInt64(reader.GetAttribute("timestamp"));
var time = epochStart.AddMilliseconds(timestamp);
var now = DateTime.UtcNow;
Assert.True(now.Ticks - time.Ticks < TimeSpan.FromSeconds(3).Ticks);
Assert.Equal(Thread.CurrentThread.ManagedThreadId.ToString(), reader.GetAttribute("thread"));
break;
case "message":
reader.Read();
Assert.Equal("some message", reader.Value);
break;
case "NDC":
reader.Read();
Assert.Equal("baz1::baz2::baz3::boo1 boo2", reader.Value);
break;
case "locationInfo":
Assert.Equal(MethodBase.GetCurrentMethod().DeclaringType.FullName, reader.GetAttribute("class"));
Assert.Equal(MethodBase.GetCurrentMethod().ToString(), reader.GetAttribute("method"));
break;
case "properties":
break;
case "throwable":
reader.Read();
Assert.Contains("Hello Exception", reader.Value);
Assert.Contains("Goodbye Exception", reader.Value);
break;
case "data":
string name = reader.GetAttribute("name");
string value = reader.GetAttribute("value");
switch (name)
{
case "log4japp":
Assert.Equal(AppDomain.CurrentDomain.FriendlyName + "(" + Process.GetCurrentProcess().Id + ")", value);
break;
case "log4jmachinename":
Assert.Equal(Environment.MachineName, value);
break;
case "foo1":
Assert.Equal("bar1", value);
break;
case "foo2":
Assert.Equal("bar2", value);
break;
case "foo3":
Assert.Equal("bar3", value);
break;
case "nlogPropertyKey":
Assert.Equal("nlogPropertyValue", value);
break;
default:
Assert.True(false, "Unknown <log4j:data>: " + name);
break;
}
break;
default:
throw new NotSupportedException("Unknown element: " + key);
}
continue;
}
if (reader.NodeType == XmlNodeType.Element && reader.Prefix == "nlog")
{
switch (key)
{
case "eventSequenceNumber":
break;
case "locationInfo":
Assert.Equal(GetType().Assembly.FullName, reader.GetAttribute("assembly"));
break;
case "properties":
break;
case "data":
var name = reader.GetAttribute("name");
var value = reader.GetAttribute("value");
Assert.Equal("nlogPropertyKey", name);
Assert.Equal("nlogPropertyValue", value);
break;
default:
throw new NotSupportedException("Unknown element: " + key);
}
}
}
}
foreach (var required in requiredChilds)
{
Assert.True(foundsChilds.ContainsKey(required), $"{required} not found!");
}
}
public void NDLCTimingTest()
{
LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@"
<nlog>
<targets><target name='debug' type='Debug' layout='${ndlc}|${ndlctiming:CurrentScope=false:ScopeBeginTime=true:Format=yyyy-MM-dd HH\:mm\:ss}|${ndlctiming:CurrentScope=false:ScopeBeginTime=false:Format=fff}|${ndlctiming:CurrentScope=true:ScopeBeginTime=true:Format=HH\:mm\:ss.fff}|${ndlctiming:CurrentScope=true:ScopeBeginTime=false:Format=fffffff}|${message}' /></targets>
<rules>
<logger name='*' minlevel='Debug' writeTo='debug' />
</rules>
</nlog>");
NestedDiagnosticsLogicalContext.Clear();
LogManager.GetLogger("A").Debug("0");
AssertDebugLastMessage("debug", "|||||0");
using (NestedDiagnosticsLogicalContext.Push("ala"))
{
LogManager.GetLogger("A").Debug("a");
var measurements = GetDebugLastMessage("debug").Split(new[] { '|' }, System.StringSplitOptions.RemoveEmptyEntries);
Assert.Equal(6, measurements.Length);
Assert.Equal("ala", measurements[0]);
Assert.InRange(int.Parse(measurements[2]), 0, 999);
Assert.InRange(int.Parse(measurements[4]), 0, 9999999);
Assert.Equal("a", measurements[measurements.Length - 1]);
System.Threading.Thread.Sleep(10);
LogManager.GetLogger("A").Debug("b");
measurements = GetDebugLastMessage("debug").Split(new[] { '|' }, System.StringSplitOptions.RemoveEmptyEntries);
Assert.Equal("ala", measurements[0]);
Assert.InRange(int.Parse(measurements[2]), 10, 999);
Assert.InRange(int.Parse(measurements[4]), 100000, 9999999);
Assert.Equal("b", measurements[measurements.Length - 1]);
using (NestedDiagnosticsLogicalContext.Push("ma"))
{
LogManager.GetLogger("A").Debug("a");
measurements = GetDebugLastMessage("debug").Split(new[] { '|' }, System.StringSplitOptions.RemoveEmptyEntries);
Assert.Equal(6, measurements.Length);
Assert.Equal("ala ma", measurements[0]);
Assert.InRange(int.Parse(measurements[2]), 10, 999);
Assert.InRange(int.Parse(measurements[4]), 0, 9999999);
Assert.Equal("a", measurements[measurements.Length - 1]);
System.Threading.Thread.Sleep(10);
LogManager.GetLogger("A").Debug("b");
measurements = GetDebugLastMessage("debug").Split(new[] { '|' }, System.StringSplitOptions.RemoveEmptyEntries);
Assert.Equal(6, measurements.Length);
Assert.Equal("ala ma", measurements[0]);
Assert.InRange(int.Parse(measurements[2]), 20, 999);
Assert.InRange(int.Parse(measurements[4]), 100000, 9999999);
Assert.Equal("b", measurements[measurements.Length - 1]);
}
LogManager.GetLogger("A").Debug("c");
measurements = GetDebugLastMessage("debug").Split(new[] { '|' }, System.StringSplitOptions.RemoveEmptyEntries);
Assert.Equal("ala", measurements[0]);
Assert.InRange(int.Parse(measurements[2]), 20, 999);
Assert.InRange(int.Parse(measurements[4]), 200000, 9999999);
Assert.Equal("c", measurements[measurements.Length - 1]);
}
LogManager.GetLogger("A").Debug("0");
AssertDebugLastMessage("debug", "|||||0");
}
static Boolean InitLogsWithNLog(String folder)
{
String logConfigFileName = "NLogConfiguration.xml";
String logFileName = "MultiPlatformApplication"; // File name of the log file
String suffixWebRtc = "_WebRTC";
String suffixArchive = "_{###}";
String extension = ".log";
try
{
// Get content of the log file configuration
String logConfigContent = Helper.GetContentOfEmbeddedResource(logConfigFileName, Encoding.UTF8);
// Load XML in XMLDocument
XmlDocument doc = new XmlDocument();
doc.LoadXml(logConfigContent);
XmlElement targetElement = doc["nlog"]["targets"];
var targetsList = targetElement.ChildNodes;
foreach (var target in targetsList)
{
if (target is XmlElement xmlElement)
{
var name = xmlElement.GetAttribute("name");
if (name?.Contains("WEBRTC") == true)
{
var filename = Path.Combine(folder, logFileName + suffixWebRtc + extension);
var archiveFilename = Path.Combine(folder, logFileName + suffixWebRtc + suffixArchive + extension);
xmlElement.SetAttribute("fileName", filename);
xmlElement.SetAttribute("archiveFileName", archiveFilename);
}
else
{
var filename = Path.Combine(folder, logFileName + extension);
var archiveFilename = Path.Combine(folder, logFileName + suffixArchive + extension);
xmlElement.SetAttribute("fileName", filename);
xmlElement.SetAttribute("archiveFileName", archiveFilename);
}
}
}
// Create NLog configuration using XML file content
XmlLoggingConfiguration config = XmlLoggingConfiguration.CreateFromXmlString(doc.OuterXml);
if (config.InitializeSucceeded == true)
{
// Set NLog configuration
NLog.LogManager.Configuration = config;
// Create Logger factory
var factory = new NLog.Extensions.Logging.NLogLoggerFactory();
// Set Logger factory to Rainbow SDK
Rainbow.LogFactory.Set(factory);
return(true);
}
}
catch { }
return(false);
}
private void WebserviceTest_httppost_utf8(string bomAttr, bool includeBom)
{
var configuration = XmlLoggingConfiguration.CreateFromXmlString(@"
<nlog>
<targets>
<target type='WebService'
name='webservice'
url='http://*****:*****@"
encoding='UTF-8'
methodName='Foo'>
<parameter name='empty' type='System.String' layout=''/> <!-- work around so the guid is decoded properly -->
<parameter name='guid' type='System.String' layout='${guid}'/>
<parameter name='m' type='System.String' layout='${message}'/>
<parameter name='date' type='System.String' layout='${longdate}'/>
<parameter name='logger' type='System.String' layout='${logger}'/>
<parameter name='level' type='System.String' layout='${level}'/>
</target>
</targets>
</nlog>");
var target = configuration.FindTargetByName("webservice") as WebServiceTarget;
Assert.NotNull(target);
Assert.Equal(6, target.Parameters.Count);
Assert.Equal("utf-8", target.Encoding.WebName);
//async call with mockup stream
WebRequest webRequest = WebRequest.Create("http://www.test.com");
var httpWebRequest = (HttpWebRequest)webRequest;
var streamMock = new StreamMock();
//event for async testing
var counterEvent = new ManualResetEvent(false);
var parameterValues = new object[] { "", "336cec87129942eeabab3d8babceead7", "Debg", "2014-06-26 23:15:14.6348", "TestClient.Program", "Debug" };
target.DoInvoke(parameterValues, c => counterEvent.Set(), httpWebRequest,
(request, callback) =>
{
var t = new Task(() => { });
callback(t);
return(t);
},
(request, result) => streamMock);
counterEvent.WaitOne(10000);
var bytes = streamMock.bytes;
var url = streamMock.stringed;
const string expectedUrl = "empty=&guid=336cec87129942eeabab3d8babceead7&m=Debg&date=2014-06-26+23%3a15%3a14.6348&logger=TestClient.Program&level=Debug";
Assert.Equal(expectedUrl, url);
Assert.True(bytes.Length > 3);
//not bom
var possbleBomBytes = bytes.Take(3).ToArray();
if (includeBom)
{
Assert.Equal(possbleBomBytes, EncodingHelpers.Utf8BOM);
}
else
{
Assert.NotEqual(possbleBomBytes, EncodingHelpers.Utf8BOM);
}
Assert.Equal(bytes.Length, includeBom ? 126 : 123);
}
public void IdentityTest1Async()
{
var oldPrincipal = Thread.CurrentPrincipal;
try
{
ConfigurationItemFactory.Default.Targets
.RegisterDefinition("CSharpEventTarget", typeof(CSharpEventTarget));
LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@"<?xml version='1.0' encoding='utf-8' ?>
<nlog xmlns='http://www.nlog-project.org/schemas/NLog.xsd'
xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'
internalLogLevel='Debug'
throwExceptions='true' >
<targets async='true'>
<target name='target1' xsi:type='CSharpEventTarget' layout='${identity}' />
</targets>
<rules>
<logger name='*' writeTo='target1' />
</rules>
</nlog>
");
try
{
var continuationHit = new ManualResetEvent(false);
string rendered = null;
var threadId = Thread.CurrentThread.ManagedThreadId;
var asyncThreadId = threadId;
LogEventInfo lastLogEvent = null;
var asyncTarget = LogManager.Configuration.FindTargetByName <AsyncTargetWrapper>("target1");
Assert.NotNull(asyncTarget);
var target = asyncTarget.WrappedTarget as CSharpEventTarget;
Assert.NotNull(target);
target.BeforeWrite += (logevent, rendered1, asyncThreadId1) =>
{
//clear in current thread before write
Thread.CurrentPrincipal = new GenericPrincipal(new GenericIdentity("ANOTHER user", "type"), null);
};
target.EventWritten += (logevent, rendered1, asyncThreadId1) =>
{
rendered = rendered1;
asyncThreadId = asyncThreadId1;
lastLogEvent = logevent;
continuationHit.Set();
};
Thread.CurrentPrincipal = new GenericPrincipal(new GenericIdentity("SOMEDOMAIN\\SomeUser", "CustomAuth"), new[] { "Role1", "Role2" });
var logger = LogManager.GetCurrentClassLogger();
logger.Debug("test write");
Assert.True(continuationHit.WaitOne());
Assert.NotNull(lastLogEvent);
//should be written in another thread.
Assert.NotEqual(threadId, asyncThreadId);
Assert.Equal("auth:CustomAuth:SOMEDOMAIN\\SomeUser", rendered);
}
finally
{
LogManager.Configuration.Close();
}
}
finally
{
InternalLogger.Reset();
Thread.CurrentPrincipal = oldPrincipal;
}
}
/// <summary>
/// Initialize the logging environment for Azure; including
/// automatically rewriting log file paths for compatibility with
/// local storage and setting up private variables.
/// </summary>
public void InitializeForCloud()
{
// Attach the diagnostic monitor trace listener to the list of master
// System.Diagnostics trace listeners
Trace.Listeners.Clear();
if (RoleEnvironment.IsAvailable)
Trace.Listeners.Add(new DiagnosticMonitorTraceListener());
else
Trace.Listeners.Add(new DefaultTraceListener());
Trace.WriteLine("Initializing NLog configuration for Azure");
// Replace log file and role name settings in the configuration
var currentCfg = LogManager.Configuration;
if (currentCfg == null)
{
// Depending on the deployment environment (i.e. Azure emulator) the NLog library
// may not properly auto-load the NLog.config file.
var binDirectory = new Uri(
System.IO.Path.GetDirectoryName(
System.Reflection.Assembly.GetExecutingAssembly().GetName().CodeBase)).LocalPath;
var configFile = Path.Combine(binDirectory, "NLog.config");
// Check for NLog.config in the local directory.
if (File.Exists(configFile))
{
var newConfig = new XmlLoggingConfiguration(configFile);
LogManager.Configuration = newConfig;
currentCfg = LogManager.Configuration;
}
else
{
// Set basic configuration and log the error
var localPath = System.IO.Path.GetTempPath();
var logDirPath = Path.Combine(localPath, "logs");
global::NLog.Config.SimpleConfigurator.ConfigureForFileLogging(
Path.Combine(logDirPath, "ApplicationLog.log"));
System.Diagnostics.Trace.TraceWarning("Warning: no NLog configuration section found in web.config or NLog.config; falling back to basic configuration");
return;
}
}
Trace.WriteLine("Resetting NLog configuration");
UpdateConfigForCloud(currentCfg);
LogManager.Configuration = currentCfg;
}
