public void WriteEventLogEntry()
{
var target = new EventLogTarget();
//The Log to write to is intentionally lower case!!
target.Log = "application";
SimpleConfigurator.ConfigureForTargetLogging(target, LogLevel.Debug);
var logger = LogManager.GetLogger("WriteEventLogEntry");
var el = new EventLog(target.Log);
var latestEntryTime = el.Entries.Cast <EventLogEntry>().Max(n => n.TimeWritten);
var testValue = Guid.NewGuid();
logger.Debug(testValue.ToString());
var entryExists = (from entry in el.Entries.Cast <EventLogEntry>()
where entry.TimeWritten >= latestEntryTime &&
entry.Message.Contains(testValue.ToString())
select entry).Any();
Assert.True(entryExists);
}
static void setUpNLog(bool EnableConsoleLog, bool EnableServiceLog)
{
var config = new LoggingConfiguration();
if (EnableConsoleLog)
{
var consoleTarget = new ColoredConsoleTarget();
config.AddTarget("console", consoleTarget);
consoleTarget.Layout = @"${date:format=HH\:mm\:ss} ${logger} ${message}";
var rule = new LoggingRule("*", LoggerAdapter.ToNLogLevel(verbosity), consoleTarget);
config.LoggingRules.Add(rule);
}
if (EnableServiceLog)
{
var eventTarget = new EventLogTarget();
config.AddTarget("eventlog", eventTarget);
eventTarget.Layout = @"${date:format=HH\:mm\:ss} ${logger} ${message}";
var rule = new LoggingRule("*", LoggerAdapter.ToNLogLevel(verbosity), eventTarget);
config.LoggingRules.Add(rule);
}
N.LogManager.Configuration = config;
}
public void WriteEventLogEntry_WithoutSource_WillBeDiscarded()
{
// Arrange
var eventLogMock = new EventLogMock(
deleteEventSourceFunction: (source, machineName) => { },
sourceExistsFunction: (source, machineName) => true,
logNameFromSourceNameFunction: (source, machineName) => string.Empty,
createEventSourceFunction: (sourceData) => { });
var target = new EventLogTarget(eventLogMock, null);
target.Source = "${event-properties:item=DynamicSource}";
var logFactory = new LogFactory();
var logConfig = new LoggingConfiguration(logFactory);
logConfig.AddRuleForAllLevels(target);
logFactory.Configuration = logConfig;
// Act
var logger = logFactory.GetLogger("EventLogCorrectLog");
logger.Info("Hello");
// Assert
Assert.Empty(eventLogMock.WrittenEntries);
}
private static void SetupEventLogService()
{
if (LogManager.Configuration == null)
{
return;
}
//Create targets and adding rules
var serviceEventLogTarget = new EventLogTarget("eventLogTarget")
{
Layout = "Service: " + _serviceName + "\n" + @"${date:format=HH\:mm\:ss} ${level:uppercase=true} ${message} ${exception}",
OptimizeBufferReuse = true,
Source = EventLogManager.EventSource,
Name = EventLogManager.EventLogName
};
LogManager.Configuration.AddTarget(serviceEventLogTarget);
#if DEBUG
LogManager.Configuration.AddRule(LogLevel.Info, LogLevel.Fatal, serviceEventLogTarget); // only infos and higher
#else
LogManager.Configuration.AddRule(LogLevel.Debug, LogLevel.Fatal, serviceEventLogTarget); // only infos and higher
#endif
LogManager.ReconfigExistingLoggers();
}
[InlineData(null, EventLogMock.EventLogDefaultMaxKilobytes, EventLogMock.EventLogDefaultMaxKilobytes)] // Should not change MaxKilobytes when the value is null
public void ShouldSetMaxKilobytes_WhenNeeded(long?newValue, long initialValue, long expectedValue)
{
string targetLog = "application"; // The Log to write to is intentionally lower case!!
var eventLogMock = new EventLogMock(
deleteEventSourceFunction: (source, machineName) => { },
sourceExistsFunction: (source, machineName) => false,
logNameFromSourceNameFunction: (source, machineName) => targetLog,
createEventSourceFunction: (sourceData) => { })
{
MaximumKilobytes = initialValue
};
var target = new EventLogTarget(eventLogMock, null)
{
Log = targetLog,
Source = "NLog.UnitTests" + Guid.NewGuid().ToString("N"), // set the source explicitly to prevent random AppDomain name being used as the source name
Layout = new SimpleLayout("${message}"), // Be able to check message length and content, the Layout is intentionally only ${message}.
OnOverflow = EventLogTargetOverflowAction.Truncate,
MaxMessageLength = MaxMessageLength,
MaxKilobytes = newValue,
};
eventLogMock.AssociateNewEventLog(target.Log, target.MachineName, target.GetFixedSource());
target.Install(new InstallationContext());
Assert.Equal(expectedValue, eventLogMock.MaximumKilobytes);
}
public void WriteEventLogEntry_WillComplain_WhenWrongLogName()
{
// Arrange
string sourceName = "NLog.UnitTests" + Guid.NewGuid().ToString("N");
string deletedSourceName = string.Empty;
string createdLogName = string.Empty;
var eventLogMock = new EventLogMock(
deleteEventSourceFunction: (source, machineName) => deletedSourceName = source,
sourceExistsFunction: (source, machineName) => true,
logNameFromSourceNameFunction: (source, machineName) => "FaultyLog",
createEventSourceFunction: (sourceData) => createdLogName = sourceData.LogName);
var target = new EventLogTarget(eventLogMock, null);
target.Log = "CorrectLog";
target.Source = "${event-properties:item=DynamicSource}";
target.Layout = "${message}";
var logFactory = new LogFactory();
var logConfig = new LoggingConfiguration(logFactory);
logConfig.AddRuleForAllLevels(target);
logFactory.Configuration = logConfig;
// Act
var logger = logFactory.GetLogger("EventLogCorrectLog");
logger.Info("Hello {DynamicSource:l}", sourceName);
// Assert
Assert.Equal(string.Empty, deletedSourceName);
Assert.Equal(string.Empty, createdLogName);
Assert.Equal(target.Log, eventLogMock.WrittenEntries[0].Log);
Assert.Equal(sourceName, eventLogMock.WrittenEntries[0].Source);
Assert.Equal($"Hello {sourceName}", eventLogMock.WrittenEntries[0].Message);
}
public void TestNLogToEventLogSucceeds()
{
var target = new EventLogTarget()
{
Name = "e",
Source = "TestLogger",
Layout = "${longdate} ${level:uppercase=true} ${logger} ${message}",
Log = "TestLogger",
};
var config = new LoggingConfiguration();
NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(target, LogLevel.Trace);
config.AddTarget(target);
var rule = new LoggingRule("*", LogLevel.Trace, target);
config.LoggingRules.Add(rule);
LogManager.Configuration = config;
var logger = LogManager.GetCurrentClassLogger();
logger.Log(LogLevel.Info, "Hello there");
logger.Log(LogLevel.Error, new Exception("Hi, I'm an exception"));
}
private static void WriteEventLogEntry2(LogLevel logLevel, EventLogEntryType eventLogEntryType, Layout entryType = null)
{
var target = new EventLogTarget();
//The Log to write to is intentionally lower case!!
target.Log = "application";
// set the source explicitly to prevent random AppDomain name being used as the source name
target.Source = "NLog.UnitTests";
if (entryType != null)
{
//set only when not default
target.EntryType = entryType;
}
SimpleConfigurator.ConfigureForTargetLogging(target, LogLevel.Trace);
var logger = LogManager.GetLogger("WriteEventLogEntry");
var el = new EventLog(target.Log);
var loggedNotBefore = DateTime.Now.AddMinutes(-1);
var testValue = Guid.NewGuid().ToString();
logger.Log(logLevel, testValue);
var entries = GetEventRecords(el.Log).TakeWhile(e => e.TimeCreated > loggedNotBefore).ToList();
//debug-> error
EntryExists(entries, testValue, target.Source, eventLogEntryType);
}
protected override void Load(ContainerBuilder builder)
{
// Create config
var config = new LoggingConfiguration();
// EventLog
string productName = Assembly.GetCallingAssembly().GetName().Name;
var eventLogTarget = new EventLogTarget(productName)
{
EntryType = "EventLog"
, Layout = "${longdate} ${level} ${message} ${exception}"
, Category = "Layout"
, EventId = "Layout"
, MachineName = Environment.MachineName
};
// File Log
var fileTarget = new FileTarget("fileTarget")
{
FileName = "${basedir}/file.txt",
Layout = "${longdate} ${level} ${message} ${exception}"
};
config.AddTarget(fileTarget);
// Define rules
config.AddRuleForOneLevel(LogLevel.Warn, fileTarget);
config.AddRule(LogLevel.Info, LogLevel.Fatal, eventLogTarget);
// Activate the configuration
LogManager.Configuration = config;
}
/// <summary>
/// 動態取得 EventLog 的 NLog Configuration.
/// </summary>
/// <param name="logLevel"></param>
/// <returns></returns>
public static Logger GetEventLogConfig(LogLevel logLevel)
{
LoggingConfiguration config = new LoggingConfiguration();
//Create targets and add them to the configuration
var eventLogTarget = new EventLogTarget();
eventLogTarget.Name = "eventLog1";
//Set target properties
eventLogTarget.Layout = @"${longdate} | ${level:uppercase=true} | ${logger} | ${message} ${onexception:${newline}${exception:format=tostring}}";
eventLogTarget.Source = "[[應用程式名稱]]";
eventLogTarget.Log = "Application";
config.AddTarget("eventLog1", eventLogTarget);
LoggingRule rule = new LoggingRule("*", logLevel, eventLogTarget);
config.LoggingRules.Add(rule);
LogManager.Configuration = config;
Logger logger = LogManager.GetLogger("NLogHelper");
return(logger);
}
private void InitServer()
{
var logConfig = new LoggingConfiguration();
// var logFile = new FileTarget("logFile") {
// FileName = "KeyServer.log",
// ArchiveAboveSize = 2000000,
// EnableArchiveFileCompression = true,
// Encoding = Encoding.UTF8,
// KeepFileOpen = true,
// WriteBom = false,
// Layout =
// @"${longdate}|${level:uppercase=true}|${logger}|${callsite:methodName=false:className=false:fileName=true:includeSourcePath=false}|${message}"
// };
var logConsole = new ColoredConsoleTarget("logConsole")
{
EnableAnsiOutput = false,
ErrorStream = true,
DetectConsoleAvailable = true,
DetectOutputRedirected = false,
AutoFlush = true,
Layout =
@"${time} ${level:uppercase=true} ${callsite:methodName=false:className=false:fileName=true:includeSourcePath=false} ${message}"
};
var logSystem = new EventLogTarget("logSystem")
{
Layout =
@"${longdate}|${level:uppercase=true}|${logger}|${callsite:methodName=false:className=false:fileName=true:includeSourcePath=false}|${message}"
};
logConfig.AddRule(LogLevel.Trace, LogLevel.Fatal, logConsole);
// logConfig.AddRule(LogLevel.Debug, LogLevel.Fatal, logFile);
logConfig.AddRule(LogLevel.Debug, LogLevel.Fatal, logSystem);
LogManager.Configuration = logConfig;
_logger = LogManager.GetCurrentClassLogger();
Parser.Default.ParseArguments <Options>(_args)
.WithParsed(async o => {
_logger.Info("Starting...");
_logger.Debug("Arguments parsed: {arguments}", o);
string accessToken;
if (string.IsNullOrWhiteSpace(o.AccessToken))
{
var random = new Random();
accessToken = new string(Enumerable
.Repeat(Chars, 16)
.Select(s => s[random.Next(s.Length)]).ToArray()
);
_logger.Info("Access token is not specified; generated: {token}", accessToken);
}
else
{
accessToken = o.AccessToken;
}
await StartServer(accessToken, o.Url, o.Port);
});
}
public void ShouldThrowException_WhenMaxMessageLengthSetNegativeOrZero(int maxMessageLength)
{
ArgumentException ex = Assert.Throws <ArgumentException>(() =>
{
var target = new EventLogTarget();
target.MaxMessageLength = maxMessageLength;
});
Assert.Equal("MaxMessageLength cannot be zero or negative.", ex.Message);
}
[InlineData(16384)] // Acceptable value
public void MaxKilobytes_ShouldBeAsSpecified_WhenValueIsValid(long?maxKilobytes)
{
var expectedMaxKilobytes = maxKilobytes;
var target = new EventLogTarget();
target.MaxKilobytes = maxKilobytes;
Assert.Equal(expectedMaxKilobytes, target.MaxKilobytes);
}
[InlineData(4194304)] // Is multiple of 64, but bigger than the max value of 4194240
public void MaxKilobytes_ShouldThrowException_WhenMaxKilobytesIsInvalid(long?maxKilobytes)
{
ArgumentException ex = Assert.Throws <ArgumentException>(() =>
{
var target = new EventLogTarget();
target.MaxKilobytes = maxKilobytes;
});
Assert.Equal("MaxKilobytes must be a multiple of 64, and between 64 and 4194240", ex.Message);
}
public static void Configure(LogConfiguration configuration)
{
var logFolder = configuration.LogFolder;
var archiveAboveSize = configuration.MaxSizeOfFile;
var maxArchiveFiles = configuration.MaxNumberOfLogFiles;
var eventLogName = configuration.EventLog;
var eventLogSourceName = string.IsNullOrEmpty(configuration.Environment)
? configuration.EventSource
: string.Format("{0}_{1}", configuration.Environment, configuration.EventSource);
var config = new LoggingConfiguration();
var consoleTarget = new ColoredConsoleTarget();
config.AddTarget("console", consoleTarget);
var fileTarget = new FileTarget();
config.AddTarget("file", fileTarget);
var eventLogTarget = new EventLogTarget();
config.AddTarget("event", eventLogTarget);
var consoleLogLevel = ConvertToNLogLogLevel(configuration.LogLevel);
var fileLogLevel = ConvertToNLogLogLevel(configuration.LogLevel);
var eventLogLevel = LogLevel.Warn;//ConvertToNLogLogLevel(configuration.LogLevel);
consoleTarget.Layout = "${logger} ${message} ${onexception:${newline}${exception:format=tostring}}";
fileTarget.FileName = String.Format("{0}/{1}_{2}", logFolder, configuration.LogFileName, "${shortdate}.log");
fileTarget.ArchiveFileName = String.Format("{0}/{1}_{2}", logFolder, configuration.LogFileName, "${shortdate}_{#}.log");
fileTarget.Layout = "${longdate} ${level} ${logger} ${message}${onexception:${newline}${exception:format=tostring}}";
fileTarget.ArchiveAboveSize = Convert.ToInt64(archiveAboveSize);
fileTarget.ArchiveNumbering = ArchiveNumberingMode.Sequence;
fileTarget.MaxArchiveFiles = Convert.ToInt32(maxArchiveFiles);
fileTarget.ConcurrentWrites = false;
eventLogTarget.Layout = "${logger} ${message} ${onexception:${newline}${exception:format=tostring}}";
eventLogTarget.Log = eventLogName;
eventLogTarget.Source = eventLogSourceName;
eventLogTarget.EventId = string.Format("${{when:inner={0}:when='${{level}}'=='Info'}}${{when:inner={1}:when='${{level}}'=='Error'}}${{when:inner={2}:when='${{level}}'=='Warn'}}",
EventCode.UndefinedInfo.GetHashCode(), EventCode.UndefinedError.GetHashCode(), EventCode.UndefinedWarning.GetHashCode());
var consoleRule = new LoggingRule("*", consoleLogLevel, consoleTarget);
config.LoggingRules.Add(consoleRule);
var fileRule = new LoggingRule("*", fileLogLevel, fileTarget);
config.LoggingRules.Add(fileRule);
var eventLogRule = new LoggingRule("*", eventLogLevel, eventLogTarget);
config.LoggingRules.Add(eventLogRule);
LogManager.Configuration = config;
}
private EventLogTarget BuildEventLog(string name, string layout)
{
var eventLogTarget = new EventLogTarget();
eventLogTarget.Name = name;
eventLogTarget.Log = _logName;
eventLogTarget.Source = _logSourceName;
eventLogTarget.MachineName = ".";
eventLogTarget.Layout = layout;
return(eventLogTarget);
}
private void CreateEventLogTarget()
{
EventLogTarget target = new EventLogTarget {
Source = "NHooked",
Log = "Application",
MachineName = ".",
Layout = DefaultLayout
};
Configuration.AddTarget("eventLog", target);
Configuration.LoggingRules.Add(new LoggingRule("*", NLog.LogLevel.Warn, target));
}
public static void AddEventLog(this LoggingConfiguration config, LogLevel min, LogLevel max)
{
var t = new EventLogTarget
{
Log = "Application",
MachineName = ".",
//Source = "ApplicationName",
Layout = NEWLINE_LAYOUT
};
config.AddTarget("eventlog", t);
config.LoggingRules.Add(new LoggingRule("*", min, max, t));
}
static void Main(string[] args)
{
EventLogTarget target = new EventLogTarget();
target.Source = "My Source";
target.Log = "Application";
target.MachineName = ".";
target.Layout = "${logger}: ${message}";
NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(target, LogLevel.Debug);
Logger logger = LogManager.GetLogger("Example");
logger.Debug("log message");
}
public void Test1()
{
EventLogTarget elt = new EventLogTarget();
elt.Log = "NLog.UnitTests";
elt.Source = "NLog.UnitTests";
elt.EventID = "10";
elt.Category = "123";
SimpleConfigurator.ConfigureForTargetLogging(elt);
LogManager.Configuration = null;
Logger l = LogManager.GetCurrentClassLogger();
l.Info("aaa");
}
internal static void InitLoggers()
{
if (LogManager.Configuration != null)
{
// User provided custom NLog config, or we have it set already, so don't override it
InitConsoleLoggers();
LogManager.ConfigurationChanged += OnConfigurationChanged;
return;
}
LoggingConfiguration config = new LoggingConfiguration();
ColoredConsoleTarget coloredConsoleTarget = new ColoredConsoleTarget("ColoredConsole")
{
DetectConsoleAvailable = false,
Layout = GeneralLayout
};
config.AddTarget(coloredConsoleTarget);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, coloredConsoleTarget));
if (Program.IsRunningAsService)
{
EventLogTarget eventLogTarget = new EventLogTarget("EventLog")
{
Layout = EventLogLayout,
Log = SharedInfo.EventLog,
Source = SharedInfo.EventLogSource
};
config.AddTarget(eventLogTarget);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, eventLogTarget));
}
else if (Program.Mode != Program.EMode.Client)
{
FileTarget fileTarget = new FileTarget("File")
{
DeleteOldFileOnStartup = true,
FileName = SharedInfo.LogFile,
Layout = GeneralLayout
};
config.AddTarget(fileTarget);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, fileTarget));
}
LogManager.Configuration = config;
InitConsoleLoggers();
}
internal static void InitLoggers()
{
if (LogManager.Configuration != null)
{
IsUsingCustomConfiguration = true;
InitConsoleLoggers();
LogManager.ConfigurationChanged += OnConfigurationChanged;
return;
}
LoggingConfiguration config = new LoggingConfiguration();
ColoredConsoleTarget coloredConsoleTarget = new ColoredConsoleTarget("ColoredConsole")
{
DetectConsoleAvailable = false,
Layout = GeneralLayout
};
config.AddTarget(coloredConsoleTarget);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, coloredConsoleTarget));
if (Program.IsRunningAsService)
{
EventLogTarget eventLogTarget = new EventLogTarget("EventLog")
{
Layout = EventLogLayout,
Log = SharedInfo.EventLog,
Source = SharedInfo.EventLogSource
};
config.AddTarget(eventLogTarget);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, eventLogTarget));
}
else if (!Program.Mode.HasFlag(Program.EMode.Client) || Program.Mode.HasFlag(Program.EMode.Server))
{
FileTarget fileTarget = new FileTarget("File")
{
DeleteOldFileOnStartup = true,
FileName = SharedInfo.LogFile,
Layout = GeneralLayout
};
config.AddTarget(fileTarget);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, fileTarget));
}
LogManager.Configuration = config;
InitConsoleLoggers();
}
static void Main(string[] args)
{
EventLogTarget target = new EventLogTarget();
target.Source = "My Source";
target.Log = "Application";
target.MachineName = ".";
target.Layout = "${logger}: ${message}";
NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(target, LogLevel.Debug);
Logger logger = LogManager.GetLogger("Example");
logger.Debug("log message");
}
private static EventLogTarget CreateEventLogTarget(Layout entryType = null, string sourceName = "NLog.UnitTests")
{
var target = new EventLogTarget();
//The Log to write to is intentionally lower case!!
target.Log = "application";
// set the source explicitly to prevent random AppDomain name being used as the source name
target.Source = sourceName;
if (entryType != null)
{
//set only when not default
target.EntryType = entryType;
}
return(target);
}
private static EventLogTarget InitializeEventLogTarget(EventLogTarget target, string sourceName, EventLogTargetOverflowAction overflowAction, int maxMessageLength, Layout entryType)
{
target.Name = "eventlog";
target.Log = "application"; // The Log to write to is intentionally lower case!!
target.Source = sourceName; // set the source explicitly to prevent random AppDomain name being used as the source name
target.Layout = new SimpleLayout("${message}"); //Be able to check message length and content, the Layout is intentionally only ${message}.
target.OnOverflow = overflowAction;
target.MaxMessageLength = maxMessageLength;
if (entryType != null)
{
target.EntryType = entryType;
}
return(target);
}
public static void ConfigureEventLogTarget(string sourceName)
{
var configuration = EnsureConfiguration();
var eventLogTarget = new EventLogTarget()
{
Layout = DefaultLayout,
MachineName = ".",
Source = sourceName,
Log = EventLogDefaultTarget,
Name = EventLogTargetName
};
configuration.AddTarget(EventLogTargetName, eventLogTarget);
configuration.AddRule(LogLevel.Info, LogLevel.Fatal, EventLogTargetName);
LogManager.ReconfigExistingLoggers();
}
public void Test1()
{
EventLogTarget elt = new EventLogTarget();
elt.Log = "NLog.UnitTests";
elt.Source = "NLog.UnitTests";
elt.EventID = "10";
elt.Category = "123";
SimpleConfigurator.ConfigureForTargetLogging(elt);
LogManager.Configuration = null;
Logger l = LogManager.GetCurrentClassLogger();
l.Info("aaa");
}
// TODO: not sure if this is the way we want to configure the logger, however, this
// honors the principle of being a code based configuration vs XML/file based.
public NLogFactory(LogFileSettings settings)
{
string fileName = settings.NamePrefix;
string archiveFileName = settings.NamePrefix + ".{###}";
if (!string.IsNullOrEmpty(settings.ArchiveName))
{
archiveFileName = settings.ArchiveName;
}
FileTarget target
= new FileTarget
{
Layout = "${longdate} [${threadid}] ${level} ${logger} - ${message}",
FileName = CreatePathFromSettings(settings.DirectoryPath, fileName, settings.Ext),
ArchiveFileName = CreatePathFromSettings(settings.DirectoryPath, archiveFileName, settings.Ext),
ArchiveEvery = ConvertRollingPeriod(settings.RolloverFrequency),
ArchiveNumbering = ArchiveNumberingMode.Rolling,
MaxArchiveFiles = 100,
DeleteOldFileOnStartup = false,
};
LoggingConfiguration config = new LoggingConfiguration();
LogLevel level = ConvertLogLevel(settings.Level);
config.LoggingRules.Add(new LoggingRule("*", level, target));
// if the event log level is specified, then we will log the the Application EventLog.
// Default is to only log Fatal messages.
if (settings.EventLogLevel != LoggingLevel.Off)
{
EventLogTarget eventLogTarget
= new EventLogTarget
{
Layout = "${logger}: ${message}${newline}${exception:format=ToString}",
Source = settings.EventLogSource,
Log = "Application",
};
LogLevel eventLogLevel = ConvertLogLevel(settings.EventLogLevel);
config.LoggingRules.Add(new LoggingRule("*", eventLogLevel, eventLogTarget));
}
LogManager.Configuration = config;
LogManager.ReconfigExistingLoggers();
}
// TODO: not sure if this is the way we want to configure the logger, however, this
// honors the principle of being a code based configuration vs XML/file based.
public NLogFactory(LogFileSettings settings)
{
string fileName = settings.NamePrefix;
string archiveFileName = settings.NamePrefix + ".{###}";
if (!string.IsNullOrEmpty(settings.ArchiveName))
{
archiveFileName = settings.ArchiveName;
}
FileTarget target
= new FileTarget
{
Layout = "${longdate} [${threadid}] ${level} ${logger} - ${message}",
FileName = CreatePathFromSettings(settings.DirectoryPath, fileName, settings.Ext),
ArchiveFileName = CreatePathFromSettings(settings.DirectoryPath, archiveFileName, settings.Ext),
ArchiveEvery = ConvertRollingPeriod(settings.RolloverFrequency),
ArchiveNumbering = ArchiveNumberingMode.Rolling,
MaxArchiveFiles = 100,
DeleteOldFileOnStartup = false,
};
LoggingConfiguration config = new LoggingConfiguration();
LogLevel level = ConvertLogLevel(settings.Level);
config.LoggingRules.Add(new LoggingRule("*", level, target));
// if the event log level is specified, then we will log the the Application EventLog.
// Default is to only log Fatal messages.
if (settings.EventLogLevel != LoggingLevel.Off)
{
EventLogTarget eventLogTarget
= new EventLogTarget
{
Layout = "${logger}: ${message}${newline}${exception:format=ToString}",
Source = settings.EventLogSource,
Log = "Application",
};
LogLevel eventLogLevel = ConvertLogLevel(settings.EventLogLevel);
config.LoggingRules.Add(new LoggingRule("*", eventLogLevel, eventLogTarget));
}
LogManager.Configuration = config;
LogManager.ReconfigExistingLoggers();
}
private static void ConfigureLogger()
{
LoggingConfiguration config = new LoggingConfiguration();
EventLogTarget eventLogTarget = new EventLogTarget
{
Name = "eventLog",
Layout = @"${longdate} [${level:uppercase=true}] ${message}",
Source = "LazyCopySvc",
Log = "Application"
};
FileTarget traceFileTarget = new FileTarget
{
Name = "traceFileLog",
Layout = @"${longdate} [${level:uppercase=true}] ${logger}: ${message}",
FileName = Path.Combine(Environment.ExpandEnvironmentVariables(Settings.Default.LogPath), "service.trace"),
ArchiveFileName = Path.Combine(Environment.ExpandEnvironmentVariables(Settings.Default.LogPath), "service.{#####}.trace"),
ArchiveAboveSize = 5 * 1024 * 1024,
ArchiveNumbering = ArchiveNumberingMode.Rolling,
MaxArchiveFiles = 5
};
FileTarget errorFileTarget = new FileTarget
{
Name = "errorFileLog",
Layout = @"${longdate} [${level:uppercase=true}] ${logger}: ${message}",
FileName = Path.Combine(Environment.ExpandEnvironmentVariables(Settings.Default.LogPath), "service.err"),
ArchiveFileName = Path.Combine(Environment.ExpandEnvironmentVariables(Settings.Default.LogPath), "service.{#####}.err"),
ArchiveAboveSize = 1 * 1024 * 1024,
ArchiveNumbering = ArchiveNumberingMode.Rolling,
MaxArchiveFiles = 5
};
config.AddTarget(eventLogTarget.Name, eventLogTarget);
config.AddTarget(traceFileTarget.Name, traceFileTarget);
config.AddTarget(errorFileTarget.Name, errorFileTarget);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Info, eventLogTarget));
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, traceFileTarget));
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Error, errorFileTarget));
LogManager.Configuration = config;
}
private static IEnumerable <EventLogMock.EventRecord> WriteWithMock(LogLevel logLevel, EventLogEntryType expectedEventLogEntryType,
string logMessage, Layout entryType = null, EventLogTargetOverflowAction overflowAction = EventLogTargetOverflowAction.Truncate, int maxMessageLength = MaxMessageLength)
{
var sourceName = "NLog.UnitTests" + Guid.NewGuid().ToString("N");
var eventLogMock = new EventLogMock(
deleteEventSourceFunction: (source, machineName) => { },
sourceExistsFunction: (source, machineName) => false,
logNameFromSourceNameFunction: (source, machineName) => string.Empty,
createEventSourceFunction: (sourceData) => { });
var target = new EventLogTarget(eventLogMock, null);
InitializeEventLogTarget(target, sourceName, overflowAction, maxMessageLength, entryType);
SimpleConfigurator.ConfigureForTargetLogging(target, LogLevel.Trace);
var logger = LogManager.GetLogger("WriteEventLogEntry");
logger.Log(logLevel, logMessage);
var entries = eventLogMock.WrittenEntries;
var expectedSource = target.GetFixedSource();
var filteredEntries = entries.Where(entry =>
entry.Source == expectedSource &&
entry.EntryType == expectedEventLogEntryType
);
if (overflowAction == EventLogTargetOverflowAction.Discard && logMessage.Length > maxMessageLength)
{
Assert.False(filteredEntries.Any(),
$"No message is expected. But {filteredEntries.Count()} message(s) found entry of type '{expectedEventLogEntryType}' from source '{expectedSource}'.");
}
else
{
Assert.True(filteredEntries.Any(),
$"Failed to find entry of type '{expectedEventLogEntryType}' from source '{expectedSource}'");
}
return(filteredEntries);
}
public LoggingConfiguration Initialize()
{
var config = new LoggingConfiguration();
var target = new EventLogTarget();
target.Source = "FinancialCharting";
target.Log = "Application";
target.MachineName = ".";
target.Name = "EventLogTarget";
target.Layout = "${message}";
config.AddTarget("EventLogTarget", target);
var rule = new LoggingRule("*", LogLevel.Debug, target);
config.LoggingRules.Add(rule);
return(config);
}
private static EventLogTarget CreateEventLogTarget(Layout entryType, string sourceName, EventLogTargetOverflowAction overflowAction)
{
var target = new EventLogTarget();
//The Log to write to is intentionally lower case!!
target.Log = "application";
// set the source explicitly to prevent random AppDomain name being used as the source name
target.Source = sourceName;
//Be able to check message length and content, the Layout is intentionally only ${message}.
target.Layout = new SimpleLayout("${message}");
if (entryType != null)
{
//set only when not default
target.EntryType = entryType;
}
target.OnOverflow = overflowAction;
return(target);
}
