public void MustBeRethrown_ShouldLog_exception_and_only_once(string text, Type exceptionType, bool logFirst, string levelText)
{
using (new InternalLoggerScope())
{
var level = LogLevel.FromString(levelText);
InternalLogger.LogLevel = LogLevel.Trace;
InternalLogger.LogToConsole = true;
InternalLogger.IncludeTimestamp = false;
var ex1 = CreateException(exceptionType);
//exception should be once
const string prefix = " Exception: ";
string expected =
levelText + " " + text + prefix + ex1 + Environment.NewLine;
StringWriter consoleOutWriter = new StringWriter()
{
NewLine = Environment.NewLine
};
// Redirect the console output to a StringWriter.
Console.SetOut(consoleOutWriter);
// Named (based on LogLevel) public methods.
if (logFirst)
{
InternalLogger.Log(ex1, level, text);
}
ex1.MustBeRethrown();
consoleOutWriter.Flush();
var actual = consoleOutWriter.ToString();
Assert.Equal(expected, actual);
}
}
public void AsyncTaskTarget_TestRetryException()
{
ILogger logger = LogManager.GetCurrentClassLogger();
var asyncTarget = new AsyncTaskTestTarget
{
Layout = "${level}",
RetryDelayMilliseconds = 10,
RetryCount = 3
};
SimpleConfigurator.ConfigureForTargetLogging(asyncTarget, LogLevel.Trace);
foreach (var logLevel in LogLevel.AllLoggingLevels)
{
logger.Log(logLevel, logLevel == LogLevel.Debug ? "EXCEPTION" : logLevel.Name.ToUpperInvariant());
}
Thread.Sleep(75);
Assert.True(asyncTarget.Logs.Count != 0);
LogManager.Flush();
Assert.Equal(LogLevel.MaxLevel.Ordinal, asyncTarget.Logs.Count);
Assert.Equal(LogLevel.MaxLevel.Ordinal + 4, asyncTarget.WriteTasks);
int ordinal = 0;
while (asyncTarget.Logs.Count > 0)
{
string logEventMessage = asyncTarget.Logs.Dequeue();
var logLevel = LogLevel.FromString(logEventMessage);
Assert.NotEqual(LogLevel.Debug, logLevel);
Assert.Equal(ordinal++, logLevel.Ordinal);
if (ordinal == LogLevel.Debug.Ordinal)
{
++ordinal;
}
}
LogManager.Configuration = null;
}
private static LogLevel GetSetting(string configName, string envName, LogLevel defaultValue)
{
string value = GetSettingString(configName, envName);
if (value == null)
{
return(defaultValue);
}
try
{
return(LogLevel.FromString(value));
}
catch (Exception exception)
{
if (exception.MustBeRethrown())
{
throw;
}
return(defaultValue);
}
}
public override async Task <Message> HandleMessage(Message msg)
{
MessageContext context = new MessageContext(msg, this);
string dsFrom = await From.SelectStringAsync(context);
string dsLevel = await Level.SelectStringAsync(context);
LogLevel _level = LogLevel.FromString(dsLevel);
string dsLogger = null;
if (Logger != null)
{
dsLogger = await Logger.SelectStringAsync(context);
}
NLog.Logger _logger = dsLogger != null
? LogManager.GetLogger(dsLogger)
: LogManager.GetCurrentClassLogger();
_logger.Log(_level, dsFrom);
return(msg);
}
static void Main(string[] args)
{
Settings Settings = Settings.Read();
//Log config
var config = new LoggingConfiguration();
LogLevel logLevel = LogLevel.FromString(Settings.Log.Lvl);
config.AddTarget(Settings.Log.Rule.GetRule(logLevel).Targets.First());
config.LoggingRules.Add(Settings.Log.Rule.GetRule(logLevel));
LogManager.Configuration = config;
ServerHost host = new ServerHost();
host.Start(Settings);
Console.WriteLine("Сервис запущен; Нажмите любую кнопку чтобы завершить...");
Console.ReadLine();
host.Stop();
Console.WriteLine("Сервис остановлен");
}
private static void InitLog(bool console)
{
var config = new LoggingConfiguration();
var debuggerTarget = new DebuggerTarget();
config.AddTarget("debugger", debuggerTarget);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, debuggerTarget));
if (console)
{
var consoleTarget = new ColoredConsoleTarget();
consoleTarget.Layout = "${message}";
config.AddTarget("console", consoleTarget);
#if DEBUG
var level = LogLevel.Trace;
#else
var level = LogLevel.Info;
#endif
config.LoggingRules.Add(new LoggingRule("*", level, consoleTarget));
}
if (instance.Log.Enabled)
{
var fileTarget = new FileTarget();
config.AddTarget("file", fileTarget);
fileTarget.FileName = Path.Combine(Util.Normalize(instance.Log.Path), "${shortdate}.log");
// fileTarget.Layout = "${message}";
config.LoggingRules.Add(new LoggingRule("*", LogLevel.FromString(instance.Log.Level), fileTarget));
}
LogManager.Configuration = config;
logger.Info("DotOPDS v{0}", build);
logger.Info("Loaded configuration from {0}", FileName);
}
public void ShowTest()
{
using (ShimsContext.Create())
{
ShimLog.AllInstances.ConfiguredLogLevelGet = (a) => { return(LogLevel.FromString("Debug")); };
ShimFeedListView.AllInstances.GetFeedListIListOfRssFeed = (a, b) =>
{
var f = new List <RssFeed>();
return(Result.Ok <IList <RssFeed> >(f));
};
ShimBaseView.AllInstances.ShowHeaderString = (a, b) => { };
ShimBaseView.AllInstances.ShowFooterString = (a, b) => { };
ShimFeedListView.AllInstances.GetPicklist = (a) =>
{
var r = new Picklist <RssFeed>();
return(Result.Ok(r));
};
ConfigObject layout = new ConfigObject();
var controls = new List <GuiElement>();
layout.Add(new KeyValuePair <string, object>("Width", 100));
layout.Add(new KeyValuePair <string, object>("Height", 101));
layout.Add(new KeyValuePair <string, object>("Controls", controls));
var view = new FeedListView(layout);
var feeds = new List <RssFeed>();
view.Show(false, feeds);
Assert.AreEqual(view._mainView.Width, 100);
Assert.AreEqual(view._mainView.Height, 101);
}
}
/// <summary>
/// The method triggered when the command line arguments are parsed
/// with success.
/// </summary>
/// <param name="options">
/// An instance of <see cref="Options" /> containing the parsed command
/// line arguments.
/// </param>
private static void CommandLineArgumentsParsed(Options options)
{
// Create our StructureMap registry and...
Registry registry = new Registry();
Container container = new Container(registry);
string logLevelStr = options.Verbosity.ToString();
LogLevel logLevel = LogLevel.FromString(logLevelStr);
// Get the default NLog configuration - i.e. the one declared
// in Nlog.config.
LoggingConfiguration loggingConfiguration =
LogManager.Configuration;
// Add a rule for each target, based on the input Verbosity level.
LoggingRule loggingRule = null;
foreach (Target target in loggingConfiguration.AllTargets)
{
loggingRule = new LoggingRule("*", logLevel, target);
loggingConfiguration.LoggingRules.Add(loggingRule);
}
// Get an instance.
IOutputFileGenerator outputFileGenerator =
container.GetInstance <IOutputFileGenerator>();
executionSuccess = outputFileGenerator.CreateOutputFile(
new Tuple <string, string>(
options.AccessKeyId,
options.SecretAccessKey),
options.AwsRegion,
options.PasswordEncryptionKeyFile,
options.RoleArn,
options.OutputFile);
}
private static void InitializeLogger()
{
NLogUtils.CreateConfigFileIfNotExists();
SimpleLayout simpleLayout;
var layout = LogManager.Configuration.Variables.TryGetValue("TextBoxLayout", out simpleLayout)
? simpleLayout.Text
: "${date:format=HH\\:MM\\:ss.ffff} [${level:upperCase=true}]\t[${logger:shortName=true}] ${message}";
var minLogLevel = LogManager.Configuration.Variables.TryGetValue("MinLogLevel", out simpleLayout)
? LogLevel.FromString(simpleLayout.Text)
: LogLevel.Info;
var reconfigLoggers = false;
var fileTarget = LogManager.Configuration.FindTargetByName <FileTarget>("file");
if (fileTarget != null && LogManager.Configuration.Variables.TryGetValue("VerboseLayout", out simpleLayout))
{
simpleLayout.Text = simpleLayout.Text.Replace("${callsite", "${callsite:skipFrames=3");
fileTarget.Layout = simpleLayout;
reconfigLoggers = true;
}
var target = new ColoredConsoleTarget {
Layout = layout, Name = "console"
};
LogManager.Configuration.LoggingRules.Add(new LoggingRule("*", minLogLevel, target));
LogManager.Configuration.Reload(); //important, refreshes the config
if (reconfigLoggers)
{
LogManager.ReconfigExistingLoggers();
}
}
public void Reconfigure()
{
var minimumLogLevel = LogLevel.FromString(_configFileProvider.LogLevel);
LogLevel minimumConsoleLogLevel;
if (_configFileProvider.ConsoleLogLevel.IsNotNullOrWhiteSpace())
{
minimumConsoleLogLevel = LogLevel.FromString(_configFileProvider.ConsoleLogLevel);
}
else if (minimumLogLevel > LogLevel.Info)
{
minimumConsoleLogLevel = minimumLogLevel;
}
else
{
minimumConsoleLogLevel = LogLevel.Info;
}
var rules = LogManager.Configuration.LoggingRules;
//Console
SetMinimumLogLevel(rules, "consoleLogger", minimumConsoleLogLevel);
//Log Files
SetMinimumLogLevel(rules, "appFileInfo", minimumLogLevel <= LogLevel.Info ? LogLevel.Info : LogLevel.Off);
SetMinimumLogLevel(rules, "appFileDebug", minimumLogLevel <= LogLevel.Debug ? LogLevel.Debug : LogLevel.Off);
SetMinimumLogLevel(rules, "appFileTrace", minimumLogLevel <= LogLevel.Trace ? LogLevel.Trace : LogLevel.Off);
SetLogRotation();
//Log Sql
SqlBuilderExtensions.LogSql = _configFileProvider.LogSql;
//Sentry
ReconfigureSentry();
LogManager.ReconfigExistingLoggers();
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.String)
{
var ret = LogLevel.FromString((string)reader.Value);
return(ret);
}
else if (reader.TokenType == JsonToken.StartObject)
{
reader.Read();
if (reader.TokenType == JsonToken.PropertyName && String.Equals((string)reader.Value, "name", StringComparison.OrdinalIgnoreCase))
{
reader.Read();
if (reader.TokenType == JsonToken.String)
{
string val = (string)reader.Value;
reader.Read();
Debug.Assert(reader.TokenType == JsonToken.EndObject);
return(LogLevel.FromString(val));
}
}
}
return(null);
}
//!!! no test coverage in this file
static Diagnostics()
{
try
{
logger = LogManager.GetCurrentClassLogger();
if (LogManager.Configuration?.LoggingRules?.Any() == true)
{
// config file has been read, use that
}
else
{
// no config file, use default config
string nlogConfigXml = ReadDefaultConfiguration();
SetDefaultConfiguration(nlogConfigXml);
}
string minLogLevel = Environment.GetEnvironmentVariable(MinLogLevelEnvironmentVariableName);
if (!string.IsNullOrWhiteSpace(minLogLevel))
{
// this will throw if invalid value
LogLevel minLogLevelParsed = LogLevel.FromString(minLogLevel);
LogManager.Configuration.LoggingRules.Single().SetLoggingLevels(minLogLevelParsed, LogLevel.Fatal);
LogManager.ReconfigExistingLoggers();
}
}
catch (Exception)
{
// telemetry can never crash the application, swallow the exception
// this probably means no logging
}
}
public static string WriteLogEntry(List <object> curObjects, string logMessage, LogLevelType curLevel, Exception curException, string destinationMachineName)
{
LogLevel nLogLevel = LogLevel.FromString(curLevel.ToString());
LogObject curLogObject = new LogObject {
Message = logMessage, CurrentDataObjects = curObjects
};
Guid logGUID = Guid.NewGuid();
string uniqueID = logGUID.ToString();
string xmlMessage;
using (StringWriter sw = new StringWriter())
{
_curSerializer.Serialize(sw, curLogObject);
xmlMessage = sw.ToString();
}
LogEventInfo logRecord;
if (curException != null)
{
logRecord = new LogEventInfo(nLogLevel, null, null, xmlMessage, null, curException);
}
else
{
logRecord = new LogEventInfo(nLogLevel, null, xmlMessage);
}
logRecord.Properties["DestinationMachineName"] = destinationMachineName;
logRecord.Properties["UniqueID"] = uniqueID;
_curLogger.Log(logRecord);
return(uniqueID);
}
public void FromStringTest()
{
Assert.Same(LogLevel.FromString("trace"), LogLevel.Trace);
Assert.Same(LogLevel.FromString("debug"), LogLevel.Debug);
Assert.Same(LogLevel.FromString("info"), LogLevel.Info);
Assert.Same(LogLevel.FromString("warn"), LogLevel.Warn);
Assert.Same(LogLevel.FromString("error"), LogLevel.Error);
Assert.Same(LogLevel.FromString("fatal"), LogLevel.Fatal);
Assert.Same(LogLevel.FromString("off"), LogLevel.Off);
Assert.Same(LogLevel.FromString("Trace"), LogLevel.Trace);
Assert.Same(LogLevel.FromString("Debug"), LogLevel.Debug);
Assert.Same(LogLevel.FromString("Info"), LogLevel.Info);
Assert.Same(LogLevel.FromString("Warn"), LogLevel.Warn);
Assert.Same(LogLevel.FromString("Error"), LogLevel.Error);
Assert.Same(LogLevel.FromString("Fatal"), LogLevel.Fatal);
Assert.Same(LogLevel.FromString("Off"), LogLevel.Off);
Assert.Same(LogLevel.FromString("TracE"), LogLevel.Trace);
Assert.Same(LogLevel.FromString("DebuG"), LogLevel.Debug);
Assert.Same(LogLevel.FromString("InfO"), LogLevel.Info);
Assert.Same(LogLevel.FromString("WarN"), LogLevel.Warn);
Assert.Same(LogLevel.FromString("ErroR"), LogLevel.Error);
Assert.Same(LogLevel.FromString("FataL"), LogLevel.Fatal);
Assert.Same(LogLevel.FromString("TRACE"), LogLevel.Trace);
Assert.Same(LogLevel.FromString("DEBUG"), LogLevel.Debug);
Assert.Same(LogLevel.FromString("INFO"), LogLevel.Info);
Assert.Same(LogLevel.FromString("WARN"), LogLevel.Warn);
Assert.Same(LogLevel.FromString("ERROR"), LogLevel.Error);
Assert.Same(LogLevel.FromString("FATAL"), LogLevel.Fatal);
Assert.Same(LogLevel.FromString("NoNe"), LogLevel.Off);
Assert.Same(LogLevel.FromString("iNformaTION"), LogLevel.Info);
Assert.Same(LogLevel.FromString("WarNING"), LogLevel.Warn);
}
static void InitializeLogging(string logLevel)
{
var loggingConfiguration = new LoggingConfiguration();
// Create our default targets
var coloredConsoleTarget = new ColoredConsoleTarget();
var logFileDir = ".";
Target fileTarget = CreateDefaultFileTarget(logFileDir);
loggingConfiguration.AddTarget("Console", coloredConsoleTarget);
loggingConfiguration.AddTarget("DailyFile", fileTarget);
// The LogLevel.Trace means has to be at least Trace to show up on console
loggingConfiguration.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, coloredConsoleTarget));
// LogLevel.Debug means has to be at least Debug to show up in logfile
loggingConfiguration.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, fileTarget));
LogManager.Configuration = loggingConfiguration;
LogManager.EnableLogging();
LogManager.GlobalThreshold = LogLevel.FromString(logLevel);
}
public void AsyncTaskTarget_TestAsyncException()
{
ILogger logger = LogManager.GetCurrentClassLogger();
var asyncTarget = new AsyncTaskTestTarget
{
Layout = "${level}",
RetryDelayMilliseconds = 50
};
SimpleConfigurator.ConfigureForTargetLogging(asyncTarget, LogLevel.Trace);
foreach (var logLevel in LogLevel.AllLoggingLevels)
{
logger.Log(logLevel, logLevel == LogLevel.Debug ? "ASYNCEXCEPTION" : logLevel.Name.ToUpperInvariant());
}
Assert.True(asyncTarget.WaitForWriteEvent());
Assert.NotEmpty(asyncTarget.Logs);
LogManager.Flush();
Assert.Equal(LogLevel.MaxLevel.Ordinal, asyncTarget.Logs.Count);
int ordinal = 0;
while (asyncTarget.Logs.TryDequeue(out var logEventMessage))
{
var logLevel = LogLevel.FromString(logEventMessage);
Assert.NotEqual(LogLevel.Debug, logLevel);
Assert.Equal(ordinal++, logLevel.Ordinal);
if (ordinal == LogLevel.Debug.Ordinal)
{
++ordinal;
}
}
LogManager.Configuration = null;
}
private static void ConfigureLogging(IConfiguration configuration)
{
const string defaultMessageLayout = "${longdate} [${pad:padding=5:inner=${level:uppercase=true}}] ${processid}:${threadid} ${logger} - ${message} ${exception:format=tostring}";
var layout = configuration["Logging:Layout"] ?? defaultMessageLayout;
var level = LogLevel.FromString(configuration["Logging:DefaultLevel"] ?? "Info");
var logfile = configuration["Logging:LogFile"];
var logConfig = new LoggingConfiguration();
if (!String.IsNullOrEmpty(logfile))
{
var fileTarget = new FileTarget
{
FileName = logfile ?? "gambot.log",
Layout = layout
};
logConfig.AddTarget("file", fileTarget);
var fileRule = new LoggingRule("*", level, fileTarget);
logConfig.LoggingRules.Add(fileRule);
}
var consoleTarget = new ColoredConsoleTarget
{
Layout = layout
};
logConfig.AddTarget("console", consoleTarget);
var consoleRule = new LoggingRule("*", level, consoleTarget);
logConfig.LoggingRules.Add(consoleRule);
LogManager.GlobalThreshold = level;
LogManager.Configuration = logConfig;
}
private void HandleDiscordLogs(LogSeverity severity, string source, string message, Exception exception = null)
{
var logLevel = LogLevel.FromString(Enum.Parse(typeof(LogSeverity), severity.ToString()).ToString());
Logger.Log(logLevel, message);
}
public void FromStringFailingTest()
{
Assert.Throws <ArgumentException>(() => LogLevel.FromString("zzz"));
Assert.Throws <ArgumentNullException>(() => LogLevel.FromString(null));
}
/// <summary>
/// Parse {Logger} xml element
/// </summary>
/// <param name="loggerElement"></param>
/// <param name="rulesCollection">Rules are added to this parameter.</param>
private void ParseLoggerElement(NLogXmlElement loggerElement, IList <LoggingRule> rulesCollection)
{
loggerElement.AssertName("logger");
var namePattern = loggerElement.GetOptionalAttribute("name", "*");
var enabled = loggerElement.GetOptionalBooleanAttribute("enabled", true);
if (!enabled)
{
InternalLogger.Debug("The logger named '{0}' are disabled");
return;
}
var rule = new LoggingRule();
string appendTo = loggerElement.GetOptionalAttribute("appendTo", null);
if (appendTo == null)
{
appendTo = loggerElement.GetOptionalAttribute("writeTo", null);
}
rule.LoggerNamePattern = namePattern;
if (appendTo != null)
{
foreach (string t in appendTo.Split(','))
{
string targetName = t.Trim();
Target target = FindTargetByName(targetName);
if (target != null)
{
rule.Targets.Add(target);
}
else
{
throw new NLogConfigurationException("Target " + targetName + " not found.");
}
}
}
rule.Final = loggerElement.GetOptionalBooleanAttribute("final", false);
string levelString;
if (loggerElement.AttributeValues.TryGetValue("level", out levelString))
{
LogLevel level = LogLevel.FromString(levelString);
rule.EnableLoggingForLevel(level);
}
else if (loggerElement.AttributeValues.TryGetValue("levels", out levelString))
{
levelString = CleanSpaces(levelString);
string[] tokens = levelString.Split(',');
foreach (string token in tokens)
{
if (!string.IsNullOrEmpty(token))
{
LogLevel level = LogLevel.FromString(token);
rule.EnableLoggingForLevel(level);
}
}
}
else
{
int minLevel = 0;
int maxLevel = LogLevel.MaxLevel.Ordinal;
string minLevelString;
string maxLevelString;
if (loggerElement.AttributeValues.TryGetValue("minLevel", out minLevelString))
{
minLevel = LogLevel.FromString(minLevelString).Ordinal;
}
if (loggerElement.AttributeValues.TryGetValue("maxLevel", out maxLevelString))
{
maxLevel = LogLevel.FromString(maxLevelString).Ordinal;
}
for (int i = minLevel; i <= maxLevel; ++i)
{
rule.EnableLoggingForLevel(LogLevel.FromOrdinal(i));
}
}
var children = loggerElement.Children.ToList();
foreach (var child in children)
{
switch (child.LocalName.ToUpper(CultureInfo.InvariantCulture))
{
case "FILTERS":
this.ParseFilters(rule, child);
break;
case "LOGGER":
this.ParseLoggerElement(child, rule.ChildRules);
break;
}
}
rulesCollection.Add(rule);
}
/// <summary>
/// Parse {NLog} xml element.
/// </summary>
/// <param name="nlogElement"></param>
/// <param name="filePath">path to config file.</param>
/// <param name="autoReloadDefault">The default value for the autoReload option.</param>
private void ParseNLogElement(NLogXmlElement nlogElement, string filePath, bool autoReloadDefault)
{
InternalLogger.Trace("ParseNLogElement");
nlogElement.AssertName("nlog");
if (nlogElement.GetOptionalBooleanAttribute("useInvariantCulture", false))
{
this.DefaultCultureInfo = CultureInfo.InvariantCulture;
}
//check loglevel as first, as other properties could write (indirect) to the internal log.
InternalLogger.LogLevel = LogLevel.FromString(nlogElement.GetOptionalAttribute("internalLogLevel", InternalLogger.LogLevel.Name));
#pragma warning disable 618
this.ExceptionLoggingOldStyle = nlogElement.GetOptionalBooleanAttribute("exceptionLoggingOldStyle", false);
#pragma warning restore 618
bool autoReload = nlogElement.GetOptionalBooleanAttribute("autoReload", autoReloadDefault);
if (filePath != null)
{
this.fileMustAutoReloadLookup[GetFileLookupKey(filePath)] = autoReload;
}
logFactory.ThrowExceptions = nlogElement.GetOptionalBooleanAttribute("throwExceptions", logFactory.ThrowExceptions);
logFactory.ThrowConfigExceptions = nlogElement.GetOptionalBooleanAttribute("throwConfigExceptions", logFactory.ThrowConfigExceptions);
InternalLogger.LogToConsole = nlogElement.GetOptionalBooleanAttribute("internalLogToConsole", InternalLogger.LogToConsole);
InternalLogger.LogToConsoleError = nlogElement.GetOptionalBooleanAttribute("internalLogToConsoleError", InternalLogger.LogToConsoleError);
InternalLogger.LogFile = nlogElement.GetOptionalAttribute("internalLogFile", InternalLogger.LogFile);
#if !SILVERLIGHT && !__IOS__ && !__ANDROID__
InternalLogger.LogToTrace = nlogElement.GetOptionalBooleanAttribute("internalLogToTrace", InternalLogger.LogToTrace);
#endif
InternalLogger.IncludeTimestamp = nlogElement.GetOptionalBooleanAttribute("internalLogIncludeTimestamp", InternalLogger.IncludeTimestamp);
logFactory.GlobalThreshold = LogLevel.FromString(nlogElement.GetOptionalAttribute("globalThreshold", logFactory.GlobalThreshold.Name));
var children = nlogElement.Children.ToList();
//first load the extensions, as the can be used in other elements (targets etc)
var extensionsChilds = children.Where(child => child.LocalName.Equals("EXTENSIONS", StringComparison.InvariantCultureIgnoreCase)).ToList();
foreach (var extensionsChild in extensionsChilds)
{
this.ParseExtensionsElement(extensionsChild, Path.GetDirectoryName(filePath));
}
//parse all other direct elements
foreach (var child in children)
{
switch (child.LocalName.ToUpper(CultureInfo.InvariantCulture))
{
case "EXTENSIONS":
//already parsed
break;
case "INCLUDE":
this.ParseIncludeElement(child, Path.GetDirectoryName(filePath), autoReloadDefault: autoReload);
break;
case "APPENDERS":
case "TARGETS":
this.ParseTargetsElement(child);
break;
case "VARIABLE":
this.ParseVariableElement(child);
break;
case "RULES":
this.ParseRulesElement(child, this.LoggingRules);
break;
case "TIME":
this.ParseTimeElement(child);
break;
case "POOLING":
this.ParsePoolingElement(child);
break;
default:
InternalLogger.Warn("Skipping unknown node: {0}", child.LocalName);
break;
}
}
}
/// <summary>
/// Log initialization.
/// </summary>
internal static void InitializeLog(string logFileName = null, string logLevel = null)
{
// default parameters initialization from config file
if (String.IsNullOrEmpty(logFileName))
{
logFileName = System.Configuration.ConfigurationManager.AppSettings["logFilename"];
}
if (String.IsNullOrEmpty(logFileName))
{
logFileName = ("${basedir}/log/" + typeof(ConsoleUtils).Namespace.Replace(".SimpleHelpers", "") + ".log");
}
if (String.IsNullOrEmpty(logLevel))
{
logLevel = System.Configuration.ConfigurationManager.AppSettings["logLevel"] ?? "Info";
}
// check if log was initialized with same options
if (_logFileName == logFileName && _logLevel == logLevel)
{
return;
}
// save current log configuration
_logFileName = logFileName;
_logLevel = logLevel;
// try to parse loglevel
LogLevel currentLogLevel;
try { currentLogLevel = LogLevel.FromString(logLevel); }
catch { currentLogLevel = LogLevel.Info; }
// prepare log configuration
var config = new NLog.Config.LoggingConfiguration();
// console output
if (!Console.IsOutputRedirected)
{
var consoleTarget = new NLog.Targets.ColoredConsoleTarget();
consoleTarget.Layout = "${longdate}\t${callsite}\t${level}\t${message}\t${onexception: \\:[Exception] ${exception:format=tostring}}";
config.AddTarget("console", consoleTarget);
var rule1 = new NLog.Config.LoggingRule("*", LogLevel.Trace, consoleTarget);
config.LoggingRules.Add(rule1);
}
// file output
var fileTarget = new NLog.Targets.FileTarget();
fileTarget.FileName = logFileName;
fileTarget.Layout = "${longdate}\t${callsite}\t${level}\t\"${message}${onexception: \t [Exception] ${exception:format=tostring}}\"";
fileTarget.ConcurrentWrites = true;
fileTarget.AutoFlush = true;
fileTarget.KeepFileOpen = true;
fileTarget.DeleteOldFileOnStartup = false;
fileTarget.ArchiveAboveSize = 2 * 1024 * 1024; // 2 Mb
fileTarget.MaxArchiveFiles = 10;
fileTarget.ArchiveNumbering = NLog.Targets.ArchiveNumberingMode.Date;
fileTarget.ArchiveDateFormat = "yyyyMMdd_HHmmss";
// set file output to be async (commented out since doesn't work on mono)
// var wrapper = new NLog.Targets.Wrappers.AsyncTargetWrapper (fileTarget);
config.AddTarget("file", fileTarget);
// configure log from configuration file
var rule2 = new NLog.Config.LoggingRule("*", currentLogLevel, fileTarget);
config.LoggingRules.Add(rule2);
// set configuration options
LogManager.Configuration = config;
}
private void ConfigureRulesFromElement(LoggingConfiguration config, LoggingRuleCollection rules, XmlElement element)
{
if (element == null)
{
return;
}
foreach (XmlElement el in PropertyHelper.GetChildElements(element, "logger"))
{
XmlElement ruleElement = el;
LoggingRule rule = new LoggingRule();
string namePattern = GetCaseInsensitiveAttribute(ruleElement, "name");
if (namePattern == null)
{
namePattern = "*";
}
string appendTo = GetCaseInsensitiveAttribute(ruleElement, "appendTo");
if (appendTo == null)
{
appendTo = GetCaseInsensitiveAttribute(ruleElement, "writeTo");
}
rule.LoggerNamePattern = namePattern;
if (appendTo != null)
{
foreach (string t in appendTo.Split(','))
{
string targetName = t.Trim();
Target target = config.FindTargetByName(targetName);
if (target != null)
{
rule.Targets.Add(target);
}
else
{
throw new NLogConfigurationException("Target " + targetName + " not found.");
}
}
}
rule.Final = false;
if (HasCaseInsensitiveAttribute(ruleElement, "final"))
{
rule.Final = true;
}
if (HasCaseInsensitiveAttribute(ruleElement, "level"))
{
LogLevel level = LogLevel.FromString(GetCaseInsensitiveAttribute(ruleElement, "level"));
rule.EnableLoggingForLevel(level);
}
else if (HasCaseInsensitiveAttribute(ruleElement, "levels"))
{
string levelsString = GetCaseInsensitiveAttribute(ruleElement, "levels");
levelsString = CleanWhitespace(levelsString);
string[] tokens = levelsString.Split(',');
foreach (string s in tokens)
{
if (s != "")
{
LogLevel level = LogLevel.FromString(s);
rule.EnableLoggingForLevel(level);
}
}
}
else
{
int minLevel = 0;
int maxLevel = LogLevel.MaxLevel.Ordinal;
if (HasCaseInsensitiveAttribute(ruleElement, "minlevel"))
{
minLevel = LogLevel.FromString(GetCaseInsensitiveAttribute(ruleElement, "minlevel")).Ordinal;
}
if (HasCaseInsensitiveAttribute(ruleElement, "maxlevel"))
{
maxLevel = LogLevel.FromString(GetCaseInsensitiveAttribute(ruleElement, "maxlevel")).Ordinal;
}
for (int i = minLevel; i <= maxLevel; ++i)
{
rule.EnableLoggingForLevel(LogLevel.FromOrdinal(i));
}
}
foreach (XmlElement el2 in PropertyHelper.GetChildElements(ruleElement, "filters"))
{
ConfigureRuleFiltersFromXmlElement(rule, el2);
}
ConfigureRulesFromElement(config, rule.ChildRules, ruleElement);
rules.Add(rule);
}
}
private void ConfigureFromXmlElement(XmlElement configElement, string baseDirectory)
{
switch (GetCaseInsensitiveAttribute(configElement, "autoReload"))
{
case "true":
AutoReload = true;
break;
case "false":
AutoReload = false;
break;
}
switch (GetCaseInsensitiveAttribute(configElement, "throwExceptions"))
{
case "true":
LogManager.ThrowExceptions = true;
break;
case "false":
LogManager.ThrowExceptions = false;
break;
}
switch (GetCaseInsensitiveAttribute(configElement, "internalLogToConsole"))
{
case "true":
InternalLogger.LogToConsole = true;
break;
case "false":
InternalLogger.LogToConsole = false;
break;
}
#if !NETCF
switch (GetCaseInsensitiveAttribute(configElement, "internalLogToConsoleError"))
{
case "true":
InternalLogger.LogToConsoleError = true;
break;
case "false":
InternalLogger.LogToConsoleError = false;
break;
}
#endif
string s = GetCaseInsensitiveAttribute(configElement, "internalLogFile");
if (s != null)
{
InternalLogger.LogFile = s;
}
s = GetCaseInsensitiveAttribute(configElement, "internalLogLevel");
if (s != null)
{
InternalLogger.LogLevel = LogLevel.FromString(s);
}
s = GetCaseInsensitiveAttribute(configElement, "globalThreshold");
if (s != null)
{
LogManager.GlobalThreshold = LogLevel.FromString(s);
}
foreach (XmlElement el in PropertyHelper.GetChildElements(configElement))
{
switch (el.LocalName.ToLower())
{
case "extensions":
AddExtensionsFromElement(el, baseDirectory);
break;
case "include":
IncludeFileFromElement(el, baseDirectory);
break;
case "appenders":
case "targets":
ConfigureTargetsFromElement(el);
break;
case "variable":
SetVariable(el);
break;
case "rules":
ConfigureRulesFromElement(this, LoggingRules, el);
break;
}
}
}
/// <summary>
/// Setup application inspector logging; 1 file per process
/// </summary>
/// <param name="opts"></param>
/// <returns></returns>
public static Logger SetupLogging(CommandOptions opts, bool onErrorConsole = false)
{
//prevent being called again if already set unless closed first
if (Logger != null)
{
return(Logger);
}
var config = new NLog.Config.LoggingConfiguration();
if (String.IsNullOrEmpty(opts.LogFilePath))
{
opts.LogFilePath = Utils.GetPath(Utils.AppPath.defaultLog);
}
//clean up previous for convenience in reading
if (File.Exists(opts.LogFilePath))
{
// Read the file and display it line by line.
System.IO.StreamReader file = new System.IO.StreamReader(opts.LogFilePath);
String line = file.ReadLine();
file.Close();
if (!String.IsNullOrEmpty(line))
{
if (line.Contains("AppInsLog"))//prevent file other than our logs from deletion
{
File.Delete(opts.LogFilePath);
}
else
{
if (Utils.CLIExecutionContext && onErrorConsole)
{
WriteOnce.Error(MsgHelp.FormatString(MsgHelp.ID.CMD_INVALID_LOG_PATH, opts.LogFilePath), true, WriteOnce.ConsoleVerbosity.Low, false);
}
throw new OpException(MsgHelp.FormatString(MsgHelp.ID.CMD_INVALID_LOG_PATH, opts.LogFilePath));
}
}
}
else
{
try
{
File.WriteAllText(opts.LogFilePath, "");//verify log file path is writable
}
catch (Exception e)
{
WriteOnce.SafeLog(e.Message + "\n" + e.StackTrace, NLog.LogLevel.Error);
if (Utils.CLIExecutionContext && onErrorConsole)
{
WriteOnce.Error(MsgHelp.FormatString(MsgHelp.ID.CMD_INVALID_FILE_OR_DIR, opts.LogFilePath), true, WriteOnce.ConsoleVerbosity.Low, false);
}
throw new OpException((MsgHelp.FormatString(MsgHelp.ID.CMD_INVALID_FILE_OR_DIR, opts.LogFilePath)));
}
}
LogLevel log_level = LogLevel.Error;//default
if (String.IsNullOrEmpty(opts.LogFileLevel))
{
opts.LogFileLevel = "Error";
}
try
{
log_level = LogLevel.FromString(opts.LogFileLevel);
}
catch (Exception)
{
if (Utils.CLIExecutionContext && onErrorConsole)
{
WriteOnce.Error(MsgHelp.FormatString(MsgHelp.ID.CMD_INVALID_ARG_VALUE, "-v"), true, WriteOnce.ConsoleVerbosity.Low, false);
}
throw new OpException((MsgHelp.FormatString(MsgHelp.ID.CMD_INVALID_ARG_VALUE, "-v")));
}
using (var fileTarget = new FileTarget()
{
Name = "LogFile",
FileName = opts.LogFilePath,
Layout = @"${date:format=yyyy-MM-dd HH\:mm\:ss} ${threadid} ${level:uppercase=true} - AppInsLog - ${message}",
ForceMutexConcurrentWrites = true
})
{
config.AddTarget(fileTarget);
config.LoggingRules.Add(new LoggingRule("CST.ApplicationInspector", log_level, fileTarget));
}
LogFilePath = opts.LogFilePath;//preserve for console path msg
LogManager.Configuration = config;
Logger = LogManager.GetLogger("CST.ApplicationInspector");
return(Logger);
}
/// <summary>
/// Try stringed keyword to <see cref="ConditionExpression"/>
/// </summary>
/// <param name="keyword"></param>
/// <param name="expression"></param>
/// <returns>success?</returns>
private bool TryPlainKeywordToExpression(string keyword, out ConditionExpression expression)
{
if (0 == string.Compare(keyword, "level", StringComparison.OrdinalIgnoreCase))
{
{
expression = new ConditionLevelExpression();
return(true);
}
}
if (0 == string.Compare(keyword, "logger", StringComparison.OrdinalIgnoreCase))
{
{
expression = new ConditionLoggerNameExpression();
return(true);
}
}
if (0 == string.Compare(keyword, "message", StringComparison.OrdinalIgnoreCase))
{
{
expression = new ConditionMessageExpression();
return(true);
}
}
if (0 == string.Compare(keyword, "loglevel", StringComparison.OrdinalIgnoreCase))
{
_tokenizer.Expect(ConditionTokenType.Dot);
{
expression = new ConditionLiteralExpression(LogLevel.FromString(_tokenizer.EatKeyword()));
return(true);
}
}
if (0 == string.Compare(keyword, "true", StringComparison.OrdinalIgnoreCase))
{
{
expression = new ConditionLiteralExpression(ConditionExpression.BoxedTrue);
return(true);
}
}
if (0 == string.Compare(keyword, "false", StringComparison.OrdinalIgnoreCase))
{
{
expression = new ConditionLiteralExpression(ConditionExpression.BoxedFalse);
return(true);
}
}
if (0 == string.Compare(keyword, "null", StringComparison.OrdinalIgnoreCase))
{
{
expression = new ConditionLiteralExpression(null);
return(true);
}
}
expression = null;
return(false);
}
private static LogLevel GetLogLevelFromConfigurationManager()
{
var settingValue = CloudConfigurationManager.GetSetting("LogLevel");
return(LogLevel.FromString(settingValue));
}
public static LoggingConfiguration ConfigureLogging(this IConfiguration configuration)
{
var loggingConfiguration = new LoggingConfiguration();
IConfiguration userLoggingConfiguration = configuration.GetSection("diagnostics:logging");
if (!userLoggingConfiguration.GetValue <bool>("enabled"))
{
return(loggingConfiguration);
}
var userLoggingTargets = userLoggingConfiguration.GetSection("targets");
ConfigureConsoleLoggingTarget();
ConfigureFilesLoggingTarget();
void ConfigureConsoleLoggingTarget()
{
var consoleTarget = userLoggingTargets.GetSection("console");
if (!consoleTarget.GetValue <bool>("enabled"))
{
return;
}
var nLogColoredConsoleTarget = new ColoredConsoleTarget("console")
{
Encoding = Encoding.UTF8,
DetectConsoleAvailable = true,
DetectOutputRedirected = true
};
loggingConfiguration.AddRule(
LogLevel.FromString(consoleTarget["levels:minimum"]),
LogLevel.FromString(consoleTarget["levels:maximum"]),
nLogColoredConsoleTarget
);
}
void ConfigureFilesLoggingTarget()
{
var filesTarget = userLoggingTargets.GetSection("files");
if (!filesTarget.GetValue <bool>("enabled"))
{
return;
}
var nLogFileTarget = new FileTarget
{
FileName = Path.Combine(filesTarget["path"], "${shortdate}.log"),
CreateDirs = true,
KeepFileOpen = true,
Encoding = Encoding.UTF8,
WriteBom = false,
LineEnding = LineEndingMode.CRLF,
ArchiveEvery = FileArchivePeriod.Day,
ArchiveNumbering = ArchiveNumberingMode.DateAndSequence
};
loggingConfiguration.AddRule(
LogLevel.FromString(filesTarget["levels:minimum"]),
LogLevel.FromString(filesTarget["levels:maximum"]),
nLogFileTarget
);
}
return(loggingConfiguration);
}
private static void ConfigureLogging()
{
var config = clusterConfig.Logging;
var loggingConfig = new LoggingConfiguration();
if (config != null)
{
// parse level
var level = !string.IsNullOrEmpty(config.Level)
? LogLevel.FromString(config.Level)
: LogLevel.Info;
var layout = "[${longdate}] [${level:format=FirstCharacter:uppercase=true}] [${logger:shortName=true}] ${message} ${exception:format=ToString,StackTrace}";
if (config.EnableConsoleLog)
{
if (config.EnableConsoleColors)
{
var target = new ColoredConsoleTarget("console")
{
Layout = layout
};
target.RowHighlightingRules.Add(new ConsoleRowHighlightingRule(
ConditionParser.ParseExpression("level == LogLevel.Trace"),
ConsoleOutputColor.DarkMagenta, ConsoleOutputColor.NoChange));
target.RowHighlightingRules.Add(new ConsoleRowHighlightingRule(
ConditionParser.ParseExpression("level == LogLevel.Debug"),
ConsoleOutputColor.Gray, ConsoleOutputColor.NoChange));
target.RowHighlightingRules.Add(new ConsoleRowHighlightingRule(
ConditionParser.ParseExpression("level == LogLevel.Info"),
ConsoleOutputColor.White, ConsoleOutputColor.NoChange));
target.RowHighlightingRules.Add(new ConsoleRowHighlightingRule(
ConditionParser.ParseExpression("level == LogLevel.Warn"),
ConsoleOutputColor.Yellow, ConsoleOutputColor.NoChange));
target.RowHighlightingRules.Add(new ConsoleRowHighlightingRule(
ConditionParser.ParseExpression("level == LogLevel.Error"),
ConsoleOutputColor.Red, ConsoleOutputColor.NoChange));
target.RowHighlightingRules.Add(new ConsoleRowHighlightingRule(
ConditionParser.ParseExpression("level == LogLevel.Fatal"),
ConsoleOutputColor.DarkRed, ConsoleOutputColor.White));
loggingConfig.AddTarget(target);
loggingConfig.AddRule(level, LogLevel.Fatal, target);
}
else
{
var target = new ConsoleTarget("console")
{
Layout = layout
};
loggingConfig.AddTarget(target);
loggingConfig.AddRule(level, LogLevel.Fatal, target);
}
}
if (!string.IsNullOrEmpty(config.LogFile))
{
var target = new FileTarget("file")
{
FileName = GetLogPath(config, config.LogFile),
FileNameKind = FilePathKind.Unknown,
Layout = layout
};
loggingConfig.AddTarget(target);
loggingConfig.AddRule(level, LogLevel.Fatal, target);
}
if (config.PerPoolLogFile)
{
foreach (var poolConfig in clusterConfig.Pools)
{
var target = new FileTarget(poolConfig.Id)
{
FileName = GetLogPath(config, poolConfig.Id + ".log"),
FileNameKind = FilePathKind.Unknown,
Layout = layout
};
loggingConfig.AddTarget(target);
loggingConfig.AddRule(level, LogLevel.Fatal, target, poolConfig.Id);
}
}
}
LogManager.Configuration = loggingConfig;
logger = LogManager.GetCurrentClassLogger();
}
public Manager(string jsonConfigFile, string logLevel, string logfileDir, bool liveMonitor, CancellationToken cancelToken, bool processConfiguration = true)
{
LogsFileDatabase.Manager = this;
StartedOn = DateTime.UtcNow;
LiveMonitor = liveMonitor;
var vfi = new FileInfo(jsonConfigFile);
JsonConfig = vfi.FullName;
LogfileDir = logfileDir;
numMessages = 0;
numConnections = 0;
Outputs = new List <OutputSender>();
Listeners = new List <InputListener>();
var loggingConfiguration = new LoggingConfiguration();
// Create our default targets
var coloredConsoleTarget = new ColoredConsoleTarget();
Target fileTarget = CreateDefaultFileTarget(logfileDir);
loggingConfiguration.AddTarget("Console", coloredConsoleTarget);
loggingConfiguration.AddTarget("DailyFile", fileTarget);
// The LogLevel.Trace means has to be at least Trace to show up on console
loggingConfiguration.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, coloredConsoleTarget));
// LogLevel.Debug means has to be at least Debug to show up in logfile
loggingConfiguration.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, fileTarget));
LogManager.Configuration = loggingConfiguration;
LogManager.EnableLogging();
LogManager.GlobalThreshold = LogLevel.FromString(logLevel);
//LogManager.GetCurrentClassLogger()
// .Info("TimberWinR Version {0}", GetAssemblyByName("TimberWinR.ServiceHost").GetName().Version.ToString());
LogManager.GetCurrentClassLogger()
.Info("TimberWinR Version {0}", Assembly.GetEntryAssembly().GetName().Version.ToString());
LogManager.GetCurrentClassLogger()
.Info("Database Filename: {0}", LogsFileDatabase.Instance.DatabaseFileName);
try
{
var fi = new FileInfo(jsonConfigFile);
if (fi.Exists)
{
LogManager.GetCurrentClassLogger().Info("Initialized, Reading Configurations From File: {0}", fi.FullName);
if (!fi.Exists)
{
throw new FileNotFoundException("Missing config file", jsonConfigFile);
}
LogManager.GetCurrentClassLogger().Info("Initialized, Reading Config: {0}", fi.FullName);
Config = Configuration.FromFile(jsonConfigFile);
}
else if (Directory.Exists(jsonConfigFile))
{
DirectoryInfo di = new DirectoryInfo(jsonConfigFile);
LogManager.GetCurrentClassLogger().Info("Initialized, Reading Configurations From {0}", di.FullName);
Config = Configuration.FromDirectory(jsonConfigFile, cancelToken, this);
}
}
catch (JsonSerializationException jse)
{
LogManager.GetCurrentClassLogger().Error(jse);
}
catch (Exception ex)
{
LogManager.GetCurrentClassLogger().Error(ex);
}
LogManager.GetCurrentClassLogger().Info("Log Directory {0}", logfileDir);
LogManager.GetCurrentClassLogger().Info("Logging Level: {0}", LogManager.GlobalThreshold);
if (processConfiguration)
{
ProcessConfiguration(cancelToken, Config);
}
}
