/// <summary>
/// Logs a message to the given log target and also displays a print statement.
/// </summary>
/// <param name="message">The message to log. Can include newline (\n) characters to split into multiple lines.</param>
/// <param name="target">The logging target (file).</param>
/// <param name="level">The verbosity level.</param>
public static void LogPrint(string message, LoggingTarget target = LoggingTarget.Runtime, LogLevel level = LogLevel.Verbose)
{
#if DEBUG
System.Diagnostics.Debug.Print(message);
#endif
Log(message, target, level);
}
/// <summary>
/// Log an arbitrary string to a specific log target.
/// </summary>
/// <param name="message">The message to log. Can include newline (\n) characters to split into multiple lines.</param>
/// <param name="target">The logging target (file).</param>
/// <param name="level">The verbosity level.</param>
public static void Log(string message, LoggingTarget target = LoggingTarget.Runtime, LogLevel level = LogLevel.Verbose)
{
try
{
GetLogger(target, true).Add(message, level);
}
catch { }
}
/// <summary>
/// For classes that regularly log to the same target, this method may be preferred over the static Log method.
/// </summary>
/// <param name="target">The logging target.</param>
/// <returns></returns>
public static Logger GetLogger(LoggingTarget target = LoggingTarget.Runtime)
{
Logger l;
if (!static_loggers.TryGetValue(target, out l))
{
static_loggers[target] = l = new Logger(target);
l.Clear();
}
return(l);
}
public static void Error(Exception e, string description, LoggingTarget target = LoggingTarget.Runtime, bool recursive = false)
{
Log($@"ERROR: {description}", target, LogLevel.Error);
Log(e.ToString(), target, LogLevel.Error);
if (recursive)
{
for (Exception inner = e.InnerException; inner != null; inner = inner.InnerException)
{
Log(inner.ToString(), target, LogLevel.Error);
}
}
}
/// <summary>
/// For classes that regularly log to the same target, this method may be preferred over the static Log method.
/// </summary>
/// <param name="target">The logging target.</param>
/// <param name="clearOnConstruct">Decides whether we clear any existing content from the log the first time we construct this logger.</param>
/// <returns></returns>
public static Logger GetLogger(LoggingTarget target = LoggingTarget.Runtime, bool clearOnConstruct = false)
{
Logger l;
if (!staticLoggers.TryGetValue(target, out l))
{
staticLoggers[target] = l = new Logger(target);
if (clearOnConstruct)
{
l.Clear();
}
}
return(l);
}
public static void AddLoggingTarget(LoggingTarget.LoggingTarget loggingTarget)
{
var appender = (AppenderSkeleton) loggingTarget.Appender;
var layout = new PatternLayout {ConversionPattern = "[%date] [%thread] %-5level %logger - %message%newline"};
layout.ActivateOptions();
appender.Layout = layout;
appender.ActivateOptions();
BasicConfigurator.Configure(appender);
Type appenderType = loggingTarget.Appender.GetType();
if (!AppendersTypes.Contains(appenderType))
{
AppendersTypes.Add(appenderType);
Logger.Parent.AddAppender(appender);
}
}
public bool LogMessage(string message, LoggingTarget target)
{
ILogger Logger = null;
switch (target)
{
case LoggingTarget.Console:
Logger = new WindowsLogger();
break;
case LoggingTarget.Database:
//Logger = new DatabaseLogger();
break;
}
if (Logger != null)
{
return(Logger.LogMessage(message));
}
else
{
return(false);
}
}
/// <summary>
/// For classes that regularly log to the same target, this method may be preferred over the static Log method.
/// </summary>
/// <param name="target">The logging target.</param>
/// <returns>The logger responsible for the given logging target.</returns>
public static Logger GetLogger(LoggingTarget target = LoggingTarget.Runtime)
{
// there can be no name conflicts between LoggingTarget-based Loggers and named loggers because
// every name that would coincide with a LoggingTarget-value is reserved and cannot be used (see ctor).
return(GetLogger(target.ToString()));
}
/// <summary>
/// Log an arbitrary string to the specified logging target.
/// </summary>
/// <param name="message">The message to log. Can include newline (\n) characters to split into multiple lines.</param>
/// <param name="target">The logging target (file).</param>
/// <param name="level">The verbosity level.</param>
public static void Log(string message, LoggingTarget target = LoggingTarget.Runtime, LogLevel level = LogLevel.Verbose)
{
log(message, target, null, level);
}
/// <summary>
/// Logs the given exception with the given description to the specified logging target.
/// </summary>
/// <param name="e">The exception that should be logged.</param>
/// <param name="description">The description of the error that should be logged with the exception.</param>
/// <param name="target">The logging target (file).</param>
/// <param name="recursive">Whether the inner exceptions of the given exception <paramref name="e"/> should be logged recursively.</param>
public static void Error(Exception e, string description, LoggingTarget target = LoggingTarget.Runtime, bool recursive = false)
{
error(e, description, target, null, recursive);
}
public void ShouldBeAbleToUsePredicateExtensionMethod()
{
LoggingTarget.ShouldHaveLogged(x => x == _message);
}
public static void RemoveLoggingTarget(LoggingTarget.LoggingTarget loggingTarget)
{
Type appenderType = loggingTarget.Appender.GetType();
AppendersTypes.Remove(appenderType);
Logger.Parent.Appenders.ToArray().ToList().RemoveAll(item => item.GetType() == appenderType);
}
public void Log(string Message, LoggingTarget Target = LoggingTarget.Runtime, LogLevel LogLevel = LogLevel.Verbose) => Logger.Log(Message, Target, LogLevel);
public void ShouldBeAbleToUseStringExtensionMethod()
{
LoggingTarget.ShouldHaveLogged(_message);
}
private Logger(LoggingTarget target = LoggingTarget.Runtime)
{
Target = target;
}
public static void Error(Exception e, string description, LoggingTarget target = LoggingTarget.Runtime)
{
Log($@"ERROR: {description}", target, LogLevel.Error);
Log(e.ToString(), target, LogLevel.Error);
}
private void ClearLogs()
{
LoggingTarget.Clear();
}
