public void SimpleLogTest() { var logioTarget = new LogIOTarget(); logioTarget.Node = "${machinename}"; logioTarget.Stream = "${logger}"; logioTarget.Layout = "Logger: ${logger} TID: ${threadid} Message: ${message}"; var rule = new LoggingRule("*", logioTarget); rule.EnableLoggingForLevels(LogLevel.Trace, LogLevel.Fatal); var config = new LoggingConfiguration(); config.LoggingRules.Add(rule); LogManager.Configuration = config; var logger = LogManager.GetLogger("Example"); logger.Trace("Hello log.io with trace!"); logger.Debug("Hello log.io with debug!"); logger.Info("Hello log.io with info!"); logger.Warn("Hello log.io with warn!"); logger.Error("Hello log.io with error!"); logger.Fatal("Hello log.io with fatal!"); LogManager.Flush(); }
public void LogRuleDisableLoggingLevels() { var rule = new LoggingRule(); rule.EnableLoggingForLevels(LogLevel.MinLevel, LogLevel.MaxLevel); rule.DisableLoggingForLevels(LogLevel.Warn, LogLevel.Fatal); Assert.Equal(rule.Levels, new[] { LogLevel.Trace, LogLevel.Debug, LogLevel.Info }); }
public void LogRuleSetLoggingLevels_off() { var rule = new LoggingRule(); rule.EnableLoggingForLevels(LogLevel.MinLevel, LogLevel.MaxLevel); rule.SetLoggingLevels(LogLevel.Off, LogLevel.Off); Assert.Equal(rule.Levels, new LogLevel[0]); }
public void LogRuleSetLoggingLevels_disables() { var rule = new LoggingRule(); rule.EnableLoggingForLevels(LogLevel.MinLevel, LogLevel.MaxLevel); rule.SetLoggingLevels(LogLevel.Warn, LogLevel.Fatal); Assert.Equal(rule.Levels, new[] { LogLevel.Warn, LogLevel.Error, LogLevel.Fatal }); }
private void EnableLoggingTarget(out MemoryTarget target, out LoggingRule loggingRule) { target = new MemoryTarget { Layout = "${longdate} ${level:uppercase=true:padding=-7} ${message} ${exception:format=tostring}" }; loggingRule = new LoggingRule(); loggingRule.Targets.Add(target); loggingRule.EnableLoggingForLevels(LogLevel.Trace, LogLevel.Fatal); LogManager.Configuration.LoggingRules.Add(loggingRule); LogManager.ReconfigExistingLoggers(); }
public void SetLogLevels(string MinLevel, string MaxLevel = "") { if (!Initialized) { throw new InvalidOperationException("Not initialized."); } try { var min = LogLevel.FromString(MinLevel); var max = LogLevel.FromString(MaxLevel != String.Empty ? MaxLevel : MinLevel); rule.DisableLoggingForLevels(LogLevel.Trace, LogLevel.Fatal); rule.EnableLoggingForLevels(min, max); LogManager.ReconfigExistingLoggers(); } catch (Exception ex) { ilogger.Error(ex, "Internal error"); throw new InvalidOperationException(ex.Message); } }
public FileLoggingConfigurator(string targetName, string[] namePatterns, string defaultFilePath) { _target = new FileTarget { Name = targetName, }; _target.FileName = defaultFilePath; _rules = new LoggingRule[namePatterns.Length]; for (var i = 0; i < namePatterns.Length; i++) { var rule = new LoggingRule { LoggerNamePattern = namePatterns[i], Final = true, }; rule.Targets.Add(_target); rule.Targets.Add(TorchUtils.GetWpfTarget()); rule.EnableLoggingForLevels(LogLevel.Info, LogLevel.Off); _rules[i] = rule; } }
public void SanizeNewLines() { var logioTarget = new LogIOTarget(); logioTarget.Node = "${machinename}"; logioTarget.Stream = "${logger}"; logioTarget.Layout = "Logger: ${logger} TID: ${threadid} Message: ${message}"; var rule = new LoggingRule("*", logioTarget); rule.EnableLoggingForLevels(LogLevel.Trace, LogLevel.Fatal); var config = new LoggingConfiguration(); config.LoggingRules.Add(rule); LogManager.Configuration = config; var logger = LogManager.GetLogger("Example"); logger.Info("Hello\r\nlog.io\r\nwith\r\nnewline!"); LogManager.Flush(); }
public void ConfigureLogging() { // Intialize Config Object LoggingConfiguration config = new LoggingConfiguration(); // Initialize Console Target var consoleTarget = new ColoredConsoleTarget("Console Target") { Layout = @"${time} ${longdate} ${uppercase: ${level}} ${logger} ${message} ${exception: format=ToString}" }; // Initialize the AsyncWrapper for the ConsoleTarget AsyncTargetWrapper consoleWrapper = new AsyncTargetWrapper(); consoleWrapper.WrappedTarget = consoleTarget; consoleWrapper.OverflowAction = AsyncTargetWrapperOverflowAction.Block; consoleWrapper.QueueLimit = 5000; // Initialize the AsyncFlushTargetWrapper for the ConsoleWrapper AutoFlushTargetWrapper consoleFlushWrapper = new AutoFlushTargetWrapper(); consoleFlushWrapper.WrappedTarget = consoleWrapper; // This condition controls when the log is flushed. Set the LogLevel to be equivalent to the maximum level specified in the targetRule consoleFlushWrapper.Condition = "level >= LogLevel.Trace"; // Adding the target to the config config.AddTarget("console", consoleFlushWrapper); // Initialize File Target var fileTarget = new FileTarget("File Target") { FileName = "Logs\\${cached:cached=true:Inner=${date:format=dd.MM.yyyy HH-mm}:CacheKey=${shortdate}}.log", KeepFileOpen = false, Layout = @"[${date:format=dd.MM.yyyy HH-mm-ss}] ${message} ${exception: format=ToString}" }; // Initialize the AsyncWrapper for the fileTarget AsyncTargetWrapper fileWrapper = new AsyncTargetWrapper(); fileWrapper.WrappedTarget = fileTarget; fileWrapper.QueueLimit = 5000; fileWrapper.OverflowAction = AsyncTargetWrapperOverflowAction.Block; // Initialize the AsyncFlushTargetWrapper for the FileWrapper AutoFlushTargetWrapper fileFlushWrapper = new AutoFlushTargetWrapper(); fileFlushWrapper.WrappedTarget = fileWrapper; // This condition controls when the log is flushed. Set the LogLevel to be equivalent to the maximum level specified in the targetRule fileFlushWrapper.Condition = "level >= LogLevel.Trace"; // Adding the target to the config config.AddTarget("file", fileFlushWrapper); // Creating the Log Level rules for each target and adding them to the config // Edit these to change what methods are logged var fileRule = new LoggingRule("*", fileTarget); fileRule.EnableLoggingForLevels(LogLevel.Trace, LogLevel.Info); fileRule.EnableLoggingForLevel(LogLevel.Error); config.LoggingRules.Add(fileRule); var consoleRule = new LoggingRule("*", consoleTarget); consoleRule.EnableLoggingForLevels(LogLevel.Trace, LogLevel.Info); consoleRule.EnableLoggingForLevel(LogLevel.Error); config.LoggingRules.Add(consoleRule); // Assigning the configuration to the logger LogManager.Configuration = config; }
//class TestLogManager //{ // // A Logger dispenser for the current configuration (Remember to call Flush on application exit) // public static LogFactory Instance { get { return instance.Value; } } // private static Lazy<LogFactory> instance = new Lazy<LogFactory>(BuildLogFactory); // private static LogFactory BuildLogFactory() // { // // Initialize LogFactory object // LogFactory logFactory = new LogFactory(); // // Initialize LogFactory Configuration // LoggingConfiguration config = new LoggingConfiguration(); // // Register the custom layout to show stack trace in logs // LayoutRenderer.Register("IndentationLayout", typeof(IndentationLayoutRenderer)); //no space // // Initialize File Target // var fileTarget = new FileTarget("File Target") // { // FileName = "${basedir}/logs/logTest.xml", // DeleteOldFileOnStartup = true, // Deletes old log file every time log is called. Set to true simply for testing purposes // KeepFileOpen = true, // Keeps file open regardless of logger status. (Increases performance) // OpenFileCacheTimeout = 30, // Max number of seconds file is kept open. (Increases performance, but the value will scale with the scope of logger implementation) // Layout = "${IndentationLayout} ${longdate} | ${level:uppercase=true} | ${logger} | ${message} | ${callsite:className=true:fileName=false:includeSourcePath=false:methodName=true}" //use IndentationLayout // }; // // Initialize the AsyncWrapper for the fileTarget // AsyncTargetWrapper fileWrapper = new AsyncTargetWrapper(); // fileWrapper.WrappedTarget = fileTarget; // fileWrapper.QueueLimit = 5000; // Limits number of requests in the request queue (Improves performance) // fileWrapper.OverflowAction = AsyncTargetWrapperOverflowAction.Block; // Blocks incoming requests until request queue if has space // // Initialize the AsyncFlushTargetWrapper for the FileWrapper // AutoFlushTargetWrapper fileFlushWrapper = new AutoFlushTargetWrapper(); // fileFlushWrapper.WrappedTarget = fileWrapper; // // This condition controls when the log is flushed. Set the LogLevel to be equivalent to the maximum level specified in the targetRule // fileFlushWrapper.Condition = "level >= LogLevel.Info"; // // Adding the target to the config // config.AddTarget("file", fileFlushWrapper); // // Creating the Log Level rules for each target and adding them to the config // var fileRule = new LoggingRule("*", fileTarget); // fileRule.EnableLoggingForLevel(exceptionLevel); // fileRule.EnableLoggingForLevels(minLevel, maxLevel); // config.LoggingRules.Add(fileRule); // // Assigning the configuration to the logger // logFactory.Configuration = config; // return logFactory; // } //} private void SetupLoggingConfiguration() { // Intialize Config Object LoggingConfiguration config = new LoggingConfiguration(); LayoutRenderer.Register("IndentationLayout", typeof(IndentationLayoutRenderer)); //no space /* * // Initialize Console Target * var consoleTarget = new ColoredConsoleTarget("Console Target") * { * Layout = @"${time} ${longdate} ${uppercase: ${level}} ${logger} ${message} ${exception: format=ToString}" * }; * * // Initialize the AsyncWrapper for the ConsoleTarget * AsyncTargetWrapper consoleWrapper = new AsyncTargetWrapper(); * consoleWrapper.WrappedTarget = consoleTarget; * consoleWrapper.OverflowAction = AsyncTargetWrapperOverflowAction.Block; * consoleWrapper.QueueLimit = 5000; * * // Initialize the AsyncFlushTargetWrapper for the ConsoleWrapper * AutoFlushTargetWrapper consoleFlushWrapper = new AutoFlushTargetWrapper(); * consoleFlushWrapper.WrappedTarget = consoleWrapper; * * // This condition controls when the log is flushed. Set the LogLevel to be equivalent to the maximum level specified in the targetRule * consoleFlushWrapper.Condition = "level >= LogLevel.Info"; * * // Adding the target to the config * config.AddTarget("console", consoleFlushWrapper); */ // Initialize File Target var fileTarget = new FileTarget("File Target") { FileName = @"${basedir}\logs\Robotics Automation Log.xml", DeleteOldFileOnStartup = true, // Deletes old log file every time log is called. Set to true simply for testing purposes KeepFileOpen = true, // Keeps file open regardless of logger status. (Increases performance) OpenFileCacheTimeout = 30, // Max number of seconds file is kept open. (Increases performance, but the value will scale with the scope of logger implementation) Layout = @"${IndentationLayout} ${date:format=yyyy-MM-dd HH\:mm\:ss} | ${level:uppercase=true} | ${message}" //use IndentationLayout }; //// XmlLayout Configuration //var XmlLayout = new XmlLayout(); //XmlLayout.IndentXml = true; //XmlLayout.ElementName = "Automated Test"; //XmlLayout.ElementValue = "Current Test"; // Unit Test name can be entered into here so each log entry will include Unit Test //XmlLayout.MaxRecursionLimit = 10; //XmlLayout.Attributes.Add(new XmlAttribute("Time", "${longdate}")); //XmlLayout.Attributes.Add(new XmlAttribute("Level", "${level:upperCase=true")); //XmlLayout.Elements.Add(new XmlElement("Output", "${message}")); //XmlLayout.Elements.Add(new XmlElement("Location", "${callsite:methodName=true}")); //fileTarget.Layout = XmlLayout; // Initialize the AsyncWrapper for the fileTarget AsyncTargetWrapper fileWrapper = new AsyncTargetWrapper(); fileWrapper.WrappedTarget = fileTarget; fileWrapper.QueueLimit = 5000; // Limits number of requests in the request queue (Improves performance) fileWrapper.OverflowAction = AsyncTargetWrapperOverflowAction.Block; // Blocks incoming requests until request queue if has space // Initialize the AsyncFlushTargetWrapper for the FileWrapper AutoFlushTargetWrapper fileFlushWrapper = new AutoFlushTargetWrapper(); fileFlushWrapper.WrappedTarget = fileWrapper; /* * // Initiliaze Database Target * var dbTarget = new DatabaseTarget * { * ConnectionString = WhatINeed, * DBProvider = "MongoServer", * Name = "Mongo", * CommandText = * @"insert into dbo.Log ( * Logged, Level, Message, Username, Url, Logger, Callsite, Exception, Stacktrace, remoteAddress * ) values( * @Logged, @Level, @Message, @Username, @Url, @Logger, @Callsite, @Exception, @Stacktrace, @remoteAddress * );" * }; * * // Adding all database parameters to pass through Mongo * dbTarget.Parameters.Add(new DatabaseParameterInfo("@Logged", "${date}")); * dbTarget.Parameters.Add(new DatabaseParameterInfo("@Level", "${level}")); * dbTarget.Parameters.Add(new DatabaseParameterInfo("@Message", "${message}")); * dbTarget.Parameters.Add(new DatabaseParameterInfo("@Username", "${identity}")); * dbTarget.Parameters.Add(new DatabaseParameterInfo("@Url", "${I need this}")); * dbTarget.Parameters.Add(new DatabaseParameterInfo("@Logger", "${logger}")); * dbTarget.Parameters.Add(new DatabaseParameterInfo("@Callsite", "${callsite}")); * dbTarget.Parameters.Add(new DatabaseParameterInfo("@Exception", "${exception:format=toString}")); * dbTarget.Parameters.Add(new DatabaseParameterInfo("@StackTrace", "${stacktrace}")); * * // Add the target to the config * config.AddTarget("database", dbTarget); * * var databaseRule = new LoggingRule("DatabaseRule", LogLevel.Trace, dbTarget); * config.LoggingRules.Add(databaseRule); */ // This condition controls when the log is flushed. Set the LogLevel to be equivalent to the maximum level specified in the targetRule fileFlushWrapper.Condition = "level >= LogLevel.Info"; // Adding the target to the config config.AddTarget("file", fileFlushWrapper); // Creating the Log Level rules for each target and adding them to the config var fileRule = new LoggingRule("*", fileTarget); fileRule.EnableLoggingForLevel(exceptionLevel); fileRule.EnableLoggingForLevels(minLevel, maxLevel); config.LoggingRules.Add(fileRule); /* * var consoleRule = new LoggingRule("*", consoleTarget); * consoleRule.EnableLoggingForLevels(LogLevel.Trace, LogLevel.Info); * consoleRule.EnableLoggingForLevel(LogLevel.Error); * config.LoggingRules.Add(consoleRule); */ // Assigning the configuration to the logger LogManager.Configuration = config; }
private static int Main(string[] args) { LoggingConfiguration config = LogManager.Configuration; if (config == null) { Console.WriteLine("\n~~~~~~~~~~~ Failed to get log configuration ~~~~~~~~~~~\n"); return(-99); } LoggingRule fileRule = config.FindRuleByName("file rule"); LoggingRule consoleRule = config.FindRuleByName("console rule"); fileRule.DisableLoggingForLevels(LogLevel.Info, LogLevel.Fatal); LogManager.Configuration = config; string script; Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); string version = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString(); var p = new FluentCommandLineParser <AppArguments>(); p.Setup(arg => arg.ShowBuildVersion) .As('v', "version") .Callback(arg => { showBuildVersion = arg; }) .SetDefault(false) .WithDescription("Show build version"); p.Setup(arg => arg.ScriptFile) .As('s', "script") //.Required() .WithDescription("Script file."); p.Setup(arg => arg.UserName) .As('u', "user") .WithDescription("Run script against AD Account name."); p.Setup(arg => arg.ShowAlert) .As('a', "alert") .Callback(arg => showUserAlert = arg) .SetDefault(false) .WithDescription("Notify the user if error. Default: FALSE (Don't notify)"); p.Setup(arg => arg.HideConsole) .As('h', "hide") .Callback(arg => hideConsole = arg) .SetDefault(false) .WithDescription("Hide console window during execution. Default: FALSE (Don't hide console)"); p.Setup(arg => arg.GetFirstAvailableLetter) .As('f', "first") .Callback(arg => getFirstAvailableLetter = arg) .SetDefault(false) .WithDescription("Resolve drive letter conflict to first available. Default: FALSE (Resolve to next available drive letter)"); p.SetupHelp("?", "help") .Callback(text => Console.WriteLine(text)); var result = p.Parse(args); if (showBuildVersion) { log.Info(version); return(0); } log.Info(""); log.Info($"Hikari V{version} - created by Stefan Bazelkov"); if (result.HelpCalled) { stopwatch.Stop(); ShowUsage(); return(0); } if (result.EmptyArgs) { p.HelpOption.ShowHelp(p.Options); ShowUsage(); stopwatch.Stop(); return(0); } if (result.HasErrors) { log.Error(result.ErrorText); stopwatch.Stop(); log.Info($"Time elapsed: {stopwatch.Elapsed.TotalSeconds:00.00}s"); ShowUserAlert("Command line arguments parsing failed!"); return(-1); } if (hideConsole) { // do not show log if console is hidden consoleRule.DisableLoggingForLevels(LogLevel.Trace, LogLevel.Fatal); ShowWindow(GetConsoleWindow(), ERROR_SW_HIDE); log.Info("Start with console window hidden."); } AppArguments appArg = p.Object; if (!File.Exists(appArg.ScriptFile)) { log.Error($"\"{appArg.ScriptFile}\" doesn't exist!"); stopwatch.Stop(); log.Info($"Time elapsed: {stopwatch.Elapsed.TotalSeconds:00.00}s"); ShowUserAlert($"Missing or wrong script file '{appArg.ScriptFile}'!"); return(-2); } if (!string.IsNullOrEmpty(appArg.UserName)) { user = ActiveDirectoryHelper.FindPrincipal(appArg.UserName); if (user == null) { stopwatch.Stop(); log.Info($"Time elapsed: {stopwatch.Elapsed.TotalSeconds:00.00}s"); log.Error($"Error in resolving provided username: \"{appArg.UserName}\""); return(-6); } } if (user != null) { // Do not map network drives if username argument is present // Only check the network shares to be connected for that AD user doMapping = false; log.Warn($"Checking mappings for \"{user.SamAccountName}\"."); log.Warn("No network drives will be connected."); } else { // logging will be performed only in the console fileRule.EnableLoggingForLevels(LogLevel.Info, LogLevel.Fatal); LogManager.Configuration = config; doMapping = true; user = UserPrincipal.Current; DisconnectAllLocalNetworkDrives(); log.Info($"Connecting network drives for \"{user.SamAccountName}\"."); } groups = ActiveDirectoryHelper.GetMembership(user).ToList(); Console.WriteLine(); log.Info($"Processing \"{appArg.ScriptFile}\" script ..."); using (StreamReader file = new StreamReader(appArg.ScriptFile)) { script = file.ReadToEnd(); file.Close(); } var parser = new HikariScriptParser(groups); try { parser.UserName = user.SamAccountName; parser.Parse(script); log.Info(parser.Model); } catch (HikariParserException x) { Console.WriteLine(); log.Error(x.Message); Console.WriteLine(); log.Warn("No drives will be connected!"); Console.WriteLine(); return(-7); } // Resolve and map the network drives ResolveMappings(parser.Model); if (doMapping) { DisconnectAllLocalNetworkDrives(); ConnectNetworkDrives(parser.Model); ConnectNetworkPrinters(parser.Model); } stopwatch.Stop(); Console.WriteLine(); log.Info($"Total time elapsed: {stopwatch.Elapsed.TotalSeconds:00.00}s"); Console.WriteLine(); return(0); }