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 StudentConnection()
{
EventLogTarget target = new EventLogTarget();
target.Source = "My Source";
target.Log = "Application";
target.MachineName = ".";
target.Layout = "${logger}: ${message}";
NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(target, LogLevel.Debug);
var config = new LoggingConfiguration();
config.AddTarget("EventLog", target);
LogManager.Configuration = config;
}
public void Test1()
{
#if TODO
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");
#endif
}
private static void ConfigureEventTarget(LoggingConfiguration config)
{
if(Environment.UserInteractive)
{
return;
}
var eventTarget = new EventLogTarget
{
Layout = LogLayout
};
config.AddTarget("eventlog", eventTarget);
var eventTargetRule = new LoggingRule("*", LogLevel.Error, eventTarget);
config.LoggingRules.Add(eventTargetRule);
}
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;
}
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.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();
}
private static EventLogTarget CreateEventLogTarget(Layout entryType, string sourceName, EventLogTargetOverflowAction overflowAction, int maxMessageLength)
{
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;
target.MaxMessageLength = maxMessageLength;
return target;
}
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);
}
public void MaxMessageLengthShouldSetToDefault_WhenSetNegativeOrZero(int maxMessageLength)
{
const int expectedMaxMessageLength = 16384;
var target = new EventLogTarget();
target.MaxMessageLength = maxMessageLength;
Assert.Equal(expectedMaxMessageLength, target.MaxMessageLength);
}
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));
}
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);
}
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;
}
/// <summary>
/// Configures the log targets that this service will use. The default log targets is a colored console target that logs verbose and a event log
/// target that logs "info" or higher.
/// </summary>
private void EnableDefaultLogTargets()
{
// Start configuring the logger.
var loggingConfiguration = new LoggingConfiguration();
// Configure the console logger.
var consoleTarget = new ColoredConsoleTarget();
consoleTarget.Layout = "${message}";
loggingConfiguration.AddTarget("Console", consoleTarget);
loggingConfiguration.LoggingRules.Add(new LoggingRule("*", Arguments.VerboseLogging ? LogLevel.Trace : LogLevel.Info, consoleTarget));
// Configure the event logger for exceptions.
var eventLogTarget = new EventLogTarget();
eventLogTarget.Source = Arguments.ServiceName;
eventLogTarget.Layout = "${message}";
loggingConfiguration.AddTarget("EventLog", eventLogTarget);
loggingConfiguration.LoggingRules.Add(new LoggingRule("*", LogLevel.Info, eventLogTarget));
// Enable the logger and print the current version.
LogManager.Configuration = loggingConfiguration;
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public void ConfigureWindowsEventLogOutput(string logName, string sourceName)
{
var eventLogTarget = new EventLogTarget();
eventLogTarget.MachineName = ".";
eventLogTarget.Log = logName;
eventLogTarget.Source = sourceName;
if ( !eventLogTarget.IsInstalled(null).GetValueOrDefault() )
{
eventLogTarget.Install(new InstallationContext());
}
}
