protected override void Initialize(LogSettings logSettings)
{
base.Initialize(logSettings);
DisplayDebug = ((MyLogSettings)logSettings).DisplayDebugs;
DisplayDiagnostics = ((MyLogSettings)logSettings).DisplayDiagnostics;
}
/// <summary>
/// Initialize
/// </summary>
/// <remarks>
/// The current implementation just set to True DisplayConsole and DisplayDebug
/// </remarks>
protected override void Initialize(LogSettings logSettings)
{
base.Initialize(LogSettings);
DisplayConsole = true;
DisplayDebug = true;
}
/// <summary>
/// Initialize
/// </summary>
/// <remarks>
/// The current implementation just set to True DisplayDebug and DisplayDiagnostics
/// </remarks>
protected override void Initialize(LogSettings logSettings)
{
base.Initialize(logSettings);
DisplayDiagnostics = true;
DisplayDebug = true;
}
/// <summary>
/// Constructor with a setting parameter
/// </summary>
/// <param name="logSettings">Custom settings or null</param>
public ConsoleLogAdapter(LogSettings logSettings)
: base(logSettings)
{
}
/// <summary>
/// Constructor with a setting parameter
/// </summary>
/// <param name="logSettings">Custom settings or null</param>
public DefaultLogAdapter(LogSettings logSettings)
{
LogSettings = logSettings;
Initialize(logSettings);
}
/// <summary>
/// Initialize
/// </summary>
/// <remarks>
/// The current implementation just set to True DisplayDebug
/// </remarks>
protected virtual void Initialize(LogSettings logSettings)
{
DisplayDebug = true;
}
/// <summary>
/// Extends the logging rules in the "NLog.config" with node log settings rules.
/// </summary>
/// <param name="settings">Node log settings to extend the rules from the configuration file, or null if no extension is required.</param>
/// <param name="dataFolder">Data folder to determine path to log files.</param>
private static void AddFilters(LogSettings settings = null, DataFolder dataFolder = null)
{
if (settings == null)
{
return;
}
logSettings = settings;
folder = dataFolder;
// If we use "debug*" targets, which are defined in "NLog.config", make sure they log into the correct log folder in data directory.
List <Target> debugTargets = LogManager.Configuration.AllTargets.Where(t => (t.Name != null) && t.Name.StartsWith("debug")).ToList();
foreach (Target debugTarget in debugTargets)
{
FileTarget debugFileTarget = debugTarget is AsyncTargetWrapper ? (FileTarget)((debugTarget as AsyncTargetWrapper).WrappedTarget) : (FileTarget)debugTarget;
string currentFile = debugFileTarget.FileName.Render(new LogEventInfo {
TimeStamp = DateTime.UtcNow
});
debugFileTarget.FileName = Path.Combine(folder.LogPath, Path.GetFileName(currentFile));
if (debugFileTarget.ArchiveFileName != null)
{
string currentArchive = debugFileTarget.ArchiveFileName.Render(new LogEventInfo {
TimeStamp = DateTime.UtcNow
});
debugFileTarget.ArchiveFileName = Path.Combine(folder.LogPath, currentArchive);
}
}
// Remove rule that forbids logging before the logging is initialized.
LoggingRule nullPreInitRule = null;
foreach (LoggingRule rule in LogManager.Configuration.LoggingRules)
{
if (rule.Final && rule.NameMatches("*") && (rule.Targets.Count > 0) && (rule.Targets[0].Name == "null"))
{
nullPreInitRule = rule;
break;
}
}
LogManager.Configuration.LoggingRules.Remove(nullPreInitRule);
// Configure main file target, configured using command line or node configuration file settings.
var mainTarget = new FileTarget
{
Name = "main",
FileName = Path.Combine(folder.LogPath, "node.txt"),
ArchiveFileName = Path.Combine(folder.LogPath, "node-${date:universalTime=true:format=yyyy-MM-dd}.txt"),
ArchiveNumbering = ArchiveNumberingMode.Sequence,
ArchiveEvery = FileArchivePeriod.Day,
MaxArchiveFiles = 7,
Layout = "[${longdate:universalTime=true} ${threadid}${mdlc:item=id}] ${level:uppercase=true}: ${callsite} ${message}",
Encoding = Encoding.UTF8
};
LogManager.Configuration.AddTarget(mainTarget);
// Default logging level is Info for all components.
var defaultRule = new LoggingRule($"{nameof(Stratis)}.*", settings.LogLevel, mainTarget);
if (settings.DebugArgs.Any() && settings.DebugArgs[0] != "1")
{
lock (KeyCategories)
{
var usedCategories = new HashSet <string>(StringComparer.Ordinal);
// Increase selected categories to Debug.
foreach (string key in settings.DebugArgs)
{
if (!KeyCategories.TryGetValue(key.Trim(), out string category))
{
// Allow direct specification - e.g. "-debug=Stratis.Bitcoin.Miner".
category = key.Trim();
}
if (!usedCategories.Contains(category))
{
usedCategories.Add(category);
var rule = new LoggingRule(category, settings.LogLevel, mainTarget);
LogManager.Configuration.LoggingRules.Add(rule);
}
}
}
}
LogManager.Configuration.LoggingRules.Add(defaultRule);
// Apply new rules.
LogManager.ReconfigExistingLoggers();
}
private void Log(LogSettings settings)
{
// Only log if the log level is appropriate
var level = LogPluginConstants.LevelFor(LogLevel);
// Validate: log.debug but level is Warn
if (level < settings.LogLevelValue)
return;
// Good to log.
string message = LogHelper.BuildMessage(ParamList);
if (settings.OutputMode == LogPluginConstants.Console)
Console.WriteLine(LogLevel + " : " + message);
else if (settings.OutputMode == LogPluginConstants.Callback)
settings.Callback(level, message, null);
else if (settings.OutputMode == LogPluginConstants.File && settings.Logger != null)
settings.Logger.WriteLine(LogLevel + " : " + message);
}
/// <summary>
/// Creates new instance of the type.
/// </summary>
/// <returns></returns>
public override object DoEvaluate(IAstVisitor visitor)
{
var settings = Ctx.Plugins.GetSettings<LogSettings>("comlib.log");
if (settings == null)
{
settings = new LogSettings();
Ctx.Plugins.SetSettings("comlib.log", settings);
}
// 1. Resolve the parameters.
ParamHelper.ResolveNonNamedParameters(ParamListExpressions, ParamList, visitor);
if (Mode == "log")
{
Log(settings);
return LObjects.EmptyString;
}
else if (Mode == "level")
{
return new LString(settings.LogLevelName);
}
else if (Mode == "level_check")
{
var level = this.LogLevel;
if (level == "debug") return settings.LogLevelValue == LogPluginConstants.Debug;
if (level == "info") return settings.LogLevelValue == LogPluginConstants.Info;
if (level == "warn") return settings.LogLevelValue == LogPluginConstants.Warn;
if (level == "error") return settings.LogLevelValue == LogPluginConstants.Error;
if (level == "fatal") return settings.LogLevelValue == LogPluginConstants.Fatal;
return false;
}
else if (Mode == "configure")
{
Configure(settings);
return LObjects.EmptyString;
}
return LObjects.EmptyString;
}
public LogRepository(LogSettings settings)
{
_context = new LogContext(settings);
}
private static void Compare(LogSettings exp, LogSettings act)
{
Assert.AreEqual(exp.Enabled, act.Enabled);
Assert.AreEqual(exp.Category, act.Category);
Compare(exp.RetentionPolicy, act.RetentionPolicy);
}
public WindowsEnumeratorTests(ITestOutputHelper testOutputHelper)
{
LogSettings.RegisterDefaultLogger <XUnitLogger>(LogLevels.Verbose, testOutputHelper);
}
/// <summary>
/// Configure the console logger and set it to filter logs not related to the fullnode.
/// </summary>
/// <param name="loggerFactory">Not used.</param>
/// <param name="consoleLoggerSettings">Console settings to filter.</param>
/// <param name="settings">Settings that hold potential debug arguments, if null no debug arguments will be loaded."/></param>
public static void ConfigureConsoleFilters(this ILoggerFactory loggerFactory, ConsoleLoggerSettings consoleLoggerSettings, LogSettings settings)
{
if (settings != null)
{
if (settings.DebugArgs.Any())
{
if (settings.DebugArgs[0] == "1")
{
// Increase all logging to Debug.
consoleLoggerSettings.Switches.Add($"{nameof(Stratis)}.{nameof(Bitcoin)}", Microsoft.Extensions.Logging.LogLevel.Debug);
}
else
{
lock (KeyCategories)
{
var usedCategories = new HashSet <string>(StringComparer.Ordinal);
// Increase selected categories to Debug.
foreach (string key in settings.DebugArgs)
{
if (!KeyCategories.TryGetValue(key.Trim(), out string category))
{
// Allow direct specification - e.g. "-debug=Stratis.Bitcoin.Miner".
category = key.Trim();
}
if (!usedCategories.Contains(category))
{
usedCategories.Add(category);
consoleLoggerSettings.Switches.Add(category.TrimEnd('*').TrimEnd('.'), Microsoft.Extensions.Logging.LogLevel.Debug);
}
}
}
}
}
}
consoleLoggerSettings.Reload();
}
/// <summary>
/// Extends the logging rules in the "NLog.config" with node log settings rules.
/// </summary>
/// <param name="loggerFactory">Not used.</param>
/// <param name="settings">Node log settings to extend the rules from the configuration file, or null if no extension is required.</param>
/// <param name="dataFolder">Data folder to determine path to log files.</param>
public static void AddFilters(this ILoggerFactory loggerFactory, LogSettings settings, DataFolder dataFolder)
{
AddFilters(settings, dataFolder);
}
/// <summary>
/// Constructor with a setting parameter
/// </summary>
/// <param name="logSettings">Custom settings or null</param>
public TraceLogAdapter(LogSettings logSettings)
: base(logSettings)
{
}
public MyLogAdapter(LogSettings logSettings)
: base(logSettings)
{
}
public DeviceTests(ITestOutputHelper testOutputHelper)
{
LogSettings.RegisterDefaultLogger <XUnitLogger>(LogLevels.Verbose, testOutputHelper);
}
private void Configure(LogSettings settings)
{
ExceptionHelper.NotNullType(this, this.ParamList[0], "log level not supplied", LTypes.String);
ExceptionHelper.NotNullType(this, this.ParamList[1], "console or log not supplied", LTypes.String);
// Param 1: Error level
settings.LogLevelName = ((LString)this.ParamList[0]).Value;
settings.LogLevelValue = LogPluginConstants.LevelFor(settings.LogLevelName);
// Param 2: Console or file?
var output = ((LString)this.ParamList[1]).Value;
if (string.Compare(output, "console", StringComparison.InvariantCultureIgnoreCase) == 0)
{
settings.OutputMode = LogPluginConstants.Console;
}
else if (string.Compare(output, "callback", StringComparison.InvariantCultureIgnoreCase) == 0)
{
settings.OutputMode = LogPluginConstants.Callback;
settings.Callback = Callback;
}
else
{
// Close any existing log
Dispose(settings);
SetupFileLog(settings);
}
}
public DescriptionTest(ITestOutputHelper testOutputHelper)
{
LogSettings.RegisterDefaultLogger <XUnitLogger>(LogLevels.Verbose, testOutputHelper);
_descriptionTest = new DescriptionImpl();
}
private void SetupFileLog(LogSettings settings)
{
settings.OutputMode = LogPluginConstants.File;
// 1st param
var filename = ((LString)ParamList[1]).Value;
var file = new FileInfo(filename);
var name = file.Name.Replace(file.Extension, string.Empty);
if (ParamList.Count > 2)
{
string format = Convert.ToString(ParamList[2]);
format = format.Replace("${yyyy-MM-dd}", DateTime.Now.ToString("yyyy-MM-dd"));
format = format.Replace("${HH-mm-ss}", DateTime.Now.ToString("HH-mm-ss"));
format = format.Replace("${yyyy}", DateTime.Now.ToString("yyyy"));
format = format.Replace("${yy}", DateTime.Now.ToString("yy"));
format = format.Replace("${MM}", DateTime.Now.ToString("MM"));
format = format.Replace("${dd}", DateTime.Now.ToString("dd"));
format = format.Replace("${HH}", DateTime.Now.ToString("HH"));
format = format.Replace("${mm}", DateTime.Now.ToString("mm"));
format = format.Replace("${ss}", DateTime.Now.ToString("ss"));
name = name + "-" + format + file.Extension;
}
settings.FileName = file.Directory.FullName + Path.DirectorySeparatorChar + name;
try
{
settings.Logger = new StreamWriter(settings.FileName);
settings.Logger.WriteLine("Starting log at : " + DateTime.Now.ToString("yyyy-MM-dd at HH-mm-ss"));
settings.Logger.Flush();
}
catch (Exception)
{
throw BuildRunTimeException("Unable to log to file : " + settings.FileName);
}
}
public TestGetDisplays(ITestOutputHelper testOutputHelper)
{
LogSettings.RegisterDefaultLogger <XUnitLogger>(LogLevels.Verbose, testOutputHelper);
}
