public bool Initialize(ILogOptions logoptions, string[] args)
{
var newOptions = this.CreateOptions(logoptions);
newOptions.Parse(args);
newOptions.ForceValueOfOverriddenArguments(this.options);
var optionshash = newOptions.GetCheckCode();
if (!this.hashes.Contains(optionshash))
{
if (this.options.Count > 0)
{
// Disable obligation collecting
newOptions.noObl = true;
// Disable disequalities
newOptions.diseq = false;
}
this.options.Add(newOptions);
this.hashes.Add(optionshash);
}
return(!newOptions.HasErrors);
}
public ArrayAnalysisBasePlugIn(int id, string methodName,
IMethodDriver <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly, Expression, Variable, ILogOptions> driver,
ILogOptions options,
Predicate <APC> cachePCs)
: base(id, methodName, driver, new PlugInAnalysisOptions(options), cachePCs)
{
}
/// <summary>
/// Write a new log object into an Xml file
/// </summary>
/// <param name="logOptions">The log object that implement <b><see cref="ILogOptions"/></b></param>
private void LogToXmlFile(ILogOptions logOptions)
{
if (LogFileBuilder.IsFileExists(_logFileOptions.Path))
{
// Load the created xml log file
var xDoc = XDocument.Load(_logFileOptions.Path);
// Build the new log as Xml Element
var logElement =
new XElement("Log",
new XAttribute(nameof(logOptions.LogLevel),
logOptions.LogLevel),
new XAttribute(nameof(logOptions.DateTime),
logOptions.DateTime
.ToString("MM/dd/yyyy hh:mm:ss.fff")),
new XAttribute(nameof(logOptions.MessageTemplate),
logOptions.MessageTemplate));
// Add and save the log element to the log xml file
xDoc.Root?.Add(logElement);
xDoc.Save(_logFileOptions.Path);
}
else
{
// If the xml log file not created yet this method will recall itself
LogToXmlFile(logOptions);
}
}
private void SetPipelineLevels(ILogOptions logSettings, ILogPipelineProvider extraPipelineProvider = null)
{
var switchKey = GetLogLevelSwitchKey(extraPipelineProvider);
var minLevel = logSettings.MinimumLevel;
SetPipelineMinLevel(switchKey, minLevel);
foreach (var sourceName in logSettings.Overrides.Keys)
{
var overrideKey = GetOverrideMapKey(sourceName, extraPipelineProvider);
SetOverrideMinLevel(overrideKey, logSettings.Overrides[sourceName]);
}
switchKey = GetLogLevelSwitchKey(LogSinkType.MongoDb, extraPipelineProvider);
minLevel = logSettings.MongoDb.MinimumLevel;
SetPipelineMinLevel(switchKey, minLevel);
switchKey = GetLogLevelSwitchKey(LogSinkType.Slack, extraPipelineProvider);
minLevel = logSettings.Slack.MinimumLevel;
SetPipelineMinLevel(switchKey, minLevel);
switchKey = GetLogLevelSwitchKey(LogSinkType.Email, extraPipelineProvider);
minLevel = logSettings.Email.MinimumLevel;
SetPipelineMinLevel(switchKey, minLevel);
switchKey = GetLogLevelSwitchKey(LogSinkType.Seq, extraPipelineProvider);
minLevel = logSettings.Seq.MinimumLevel;
SetPipelineMinLevel(switchKey, minLevel);
switchKey = GetLogLevelSwitchKey(LogSinkType.ElasticSearch, extraPipelineProvider);
minLevel = logSettings.ElasticSearch.MinimumLevel;
SetPipelineMinLevel(switchKey, minLevel);
}
/// <summary>
/// Write a new log object into a Json file
/// </summary>
/// <param name="logOptions">The log object that implement <b><see cref="ILogOptions"/></b></param>
private void LogToJsonFile(ILogOptions logOptions)
{
//Load the old log
string oldLogAsString = File.ReadAllText(_logFileOptions.Path);
//Deserialize the old log content to objects
var oldLogAsObjects =
JsonConvert.DeserializeObject <List <LogOptions> >(oldLogAsString) ??
new List <LogOptions>();
//Add the new log object to the old ones
oldLogAsObjects.Add(new LogOptions()
{
LogLevel = logOptions.LogLevel,
DateTime = logOptions.DateTime,
MessageTemplate = logOptions.MessageTemplate
});
//Serialize the log objects collecion to JSON format
var logAsJson =
JsonConvert.SerializeObject(oldLogAsObjects,
Formatting.Indented);
//Save the log objects into the file
File.WriteAllText(_logFileOptions.Path,
logAsJson);
}
/// <summary>
/// Write a new log line/object into a text file
/// </summary>
/// <param name="logOptions">The log object that implement <b><see cref="ILogOptions"/></b></param>
private void LogToTextFile(ILogOptions logOptions)
{
string newLogLine =
$"[{logOptions.LogLevel}] [{logOptions.DateTime}] [{logOptions.MessageTemplate}]";
File.AppendAllText(_logFileOptions.Path,
newLogLine + Environment.NewLine);
}
public EnumAnalysisWrapperPlugIn(EnumAnalysis enumAnalysis, int id, string methodName,
IMethodDriver <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly, Expression, Variable, ILogOptions> mdriver,
ILogOptions options, Predicate <APC> cachePCs)
: base(id, methodName, mdriver, new PlugInAnalysisOptions(options), cachePCs)
{
Contract.Requires(enumAnalysis != null);
this.enumAnalysis = enumAnalysis;
}
/// <summary>
///
/// </summary>
/// <param name="logManager"></param>
/// <param name="globalLogSettings"></param>
/// <returns></returns>
// ReSharper disable once UnusedMember.Global
public static ILogManager ConfigureLogging(this ILogManager logManager,
ILogOptions globalLogSettings)
{
Ensure.Argument.NotNull(logManager, nameof(logManager));
logManager.Configure(globalLogSettings);
return(logManager);
}
public bool Initialize(ILogOptions logoptions, string[] args)
{
var newoptions = new UnsafeOptions(logoptions);
newoptions.Parse(args);
this.options.Add(newoptions);
return(!newoptions.HasErrors);
}
public void Log(string message, LogType type = LogType.Info, ILogOptions options = null)
{
SetColors(type, options);
Console.Write(message);
if (options?.IsEndOfLine ?? true)
{
LineFeed();
}
Console.ResetColor();
}
public ExistentialAnalysisPlugIn(
int pluginCount,
string name,
IMethodDriver <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly, Expression, Variable, ILogOptions> driver,
ILogOptions options,
Predicate <APC> cachePCs
)
: base(pluginCount, name, driver, options, cachePCs)
{
}
public RuntimeTypesPlugIn(int id,
string methodName,
IMethodDriver <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly, Expression, Variable, ILogOptions> mdriver,
ILogOptions options,
Predicate <APC> cachePCs
)
: base(id, methodName, mdriver, new PlugInAnalysisOptions(options), cachePCs)
{
Contract.Requires(id >= 0);
Contract.Requires(mdriver != null);
}
/// <inheritdoc />
protected override void WriteLog(ILogOptions logOptions)
{
switch (_logFileOptions.FileFormat)
{
case LogFileFormat.Text:
LogToTextFile(logOptions);
break;
case LogFileFormat.Json:
LogToJsonFile(logOptions);
break;
case LogFileFormat.Xml:
LogToXmlFile(logOptions);
break;
}
}
/// <summary>
/// Initializes and enable the logging and his <paramref name="level"/>.
/// </summary>
/// <param name="level">The level of logging (verbosity).</param>
public static void InitializeLogging(ILogOptions logOptions)
{
LogOptions = logOptions;
if (logOptions.LogLevel == LogLevel.None) logOptions.LogLevel = LogLevel.Info;
if (logOptions.LogPattern == null) logOptions.LogPattern = "[%-5level] %message%newline";
Hierarchy hierarchy = (Hierarchy)LogManager.GetRepository();
hierarchy.Root.RemoveAllAppenders();
hierarchy.Root.Level = logOptions.LogLevel.ToLog4NetLevel();
var appenders = new List<IAppender>();
//appenders.Add(CreateConsoleAppender(logOptions));
appenders.Add(CreateColoredConsoleAppender(logOptions));
if (!string.IsNullOrWhiteSpace(logOptions.LogFilePath))
appenders.Add(CreateFileAppender(logOptions));
log4net.Config.BasicConfigurator.Configure(appenders.ToArray());
}
public void Reconfigure(ILogOptions newLogSettings = null)
{
if (!IsConfigured)
{
Configure(newLogSettings);
return;
}
var oldLogSettings = GlobalLogSettings;
newLogSettings = newLogSettings ?? new LogSettings();
SetGlobalPipelineSettings(newLogSettings);
// Check if the log settings have actually changed.
if (new LogSettingsComparer().Equals(newLogSettings, oldLogSettings))
{
return;
}
CloseAndFlush();
ConfigureLoggingPipelines();
}
public void Configure(ILogOptions globalLogSettings = null,
IEnumerable <ILogPipelineProvider> extraPipelines = null)
{
if (IsConfigured)
{
throw new InvalidOperationException("LogManager.Configure() cannot be called more than once.");
}
IsConfigured = true;
SetGlobalPipelineSettings(globalLogSettings ?? new LogSettings());
if (extraPipelines != null)
{
foreach (var pipelineProvider in extraPipelines)
{
SetPipelineSettings(pipelineProvider);
}
}
ConfigureLoggingPipelines();
LoggerFactory?.AddSerilog(dispose: true);
}
public ClassInitOptions(ILogOptions options)
{
mLogOptions = options;
}
private void SetGlobalPipelineSettings(ILogOptions logSettings)
{
GlobalLogSettings = logSettings;
SetPipelineLevels(logSettings);
}
/// <summary>
/// Creates the console appender according options.
/// </summary>
/// <returns>The created console appender.</returns>
/// <param name="logOptions">The log options.</param>
private static IAppender CreateColoredConsoleAppender(ILogOptions logOptions)
{
var appender = new AnsiColorTerminalAppender();
var pl = new PatternLayout();
pl.ConversionPattern = logOptions.LogPattern;
pl.ActivateOptions();
appender.Layout = pl;
appender.ActivateOptions();
appender.AddMapping(new AnsiColorTerminalAppender.LevelColors() { Level = Level.Trace, ForeColor = AnsiColorTerminalAppender.AnsiColor.Blue });
appender.AddMapping(new AnsiColorTerminalAppender.LevelColors() { Level = Level.Debug, ForeColor = AnsiColorTerminalAppender.AnsiColor.White });
appender.AddMapping(new AnsiColorTerminalAppender.LevelColors() { Level = Level.Info, ForeColor = AnsiColorTerminalAppender.AnsiColor.Green });
appender.AddMapping(new AnsiColorTerminalAppender.LevelColors() { Level = Level.Warn, ForeColor = AnsiColorTerminalAppender.AnsiColor.Yellow });
appender.AddMapping(new AnsiColorTerminalAppender.LevelColors() { Level = Level.Error, ForeColor = AnsiColorTerminalAppender.AnsiColor.Red });
appender.AddMapping(new AnsiColorTerminalAppender.LevelColors() { Level = Level.Fatal, BackColor = AnsiColorTerminalAppender.AnsiColor.Red, ForeColor = AnsiColorTerminalAppender.AnsiColor.White });
return appender;
}
public BoundsOptions(ILogOptions logoptions)
: base(logoptions)
{
}
protected override Bounds.BoundsOptions CreateOptions(ILogOptions options)
{
return(new Bounds.BoundsOptions(options));
}
internal StringOptions(ILogOptions logoptions)
: base(logoptions)
{
}
override protected Strings.StringOptions CreateOptions(ILogOptions options)
{
return(new StringOptions(options));
}
protected override Arithmetic.ArithmeticOptions CreateOptions(ILogOptions options)
{
return(new ArithmeticOptions(options));
}
private static FileAppender CreateFileAppender(ILogOptions logOptions)
{
var appender = new FileAppender();
var pl = new PatternLayout();
pl.ConversionPattern = logOptions.LogPattern;
pl.ActivateOptions();
appender.Layout = pl;
appender.ActivateOptions();
appender.AppendToFile = true;
appender.File = logOptions.LogFilePath;
return appender;
}
public ArithmeticOptions(ILogOptions logoptions)
: base(logoptions)
{
this.type = DomainKind.Pentagons;
this.diseq = true;
}
abstract protected Options CreateOptions(ILogOptions options);
/// <summary>
/// Creates the console appender according options.
/// </summary>
/// <returns>The created console appender.</returns>
/// <param name="logOptions">The log options.</param>
private static ConsoleAppender CreateConsoleAppender(ILogOptions logOptions)
{
var appender = new ConsoleAppender();
var pl = new PatternLayout();
pl.ConversionPattern = logOptions.LogPattern;
pl.ActivateOptions();
appender.Layout = pl;
appender.ActivateOptions();
return appender;
}
public UnsafeOptions(ILogOptions logoptions)
: base(logoptions)
{
this.type = DomainKind.StripesIntervalsKarr;
}
public bool Initialize(ILogOptions logoptions, string[] args)
{
this.options = new StringOptions(logoptions);
this.options.Parse(args);
return(!this.options.HasErrors);
}
/// <summary>
///
/// </summary>
/// <param name="logSettings"></param>
// ReSharper disable once UnusedMember.Global
public static void Setup(ILogOptions logSettings)
{
Instance.Value.Configure(logSettings);
}
public virtual ClassInitOptions CreateOptions(ILogOptions options)
{
return(new ClassInitOptions(options));
}
internal StringOptions(ILogOptions logoptions)
{
this.logoptions = logoptions;
}
public bool Initialize(ILogOptions options, string[] args)
{
return(true);
}
