public void LogFatal(string methodInfo, LogMessageGenerator messageFunc)
{
if (_logger.IsFatalEnabled)
{
LogMessage(LogLevel.Fatal, methodInfo, null, messageFunc());
}
}
public void LogWarn(string methodInfo, LogMessageGenerator messageFunc)
{
if (_logger.IsWarnEnabled)
{
LogMessage(LogLevel.Warn, methodInfo, null, messageFunc());
}
}
public void LogError(string methodInfo, LogMessageGenerator messageFunc)
{
if (_logger.IsErrorEnabled)
{
LogMessage(LogLevel.Error, methodInfo, null, messageFunc());
}
}
public void LogDebug(string methodInfo, LogMessageGenerator messageFunc)
{
if (_logger.IsDebugEnabled)
{
LogMessage(LogLevel.Debug, methodInfo, null, messageFunc());
}
}
public void LogInfo(string methodInfo, LogMessageGenerator messageFunc)
{
if (_logger.IsInfoEnabled)
{
LogMessage(LogLevel.Info, methodInfo, null, messageFunc());
}
}
public void LogTrace(string methodInfo, LogMessageGenerator messageFunc)
{
if (_logger.IsTraceEnabled)
{
LogMessage(LogLevel.Trace, methodInfo, null, messageFunc());
}
}
public void Verbose(LogMessageGenerator deferredMessage)
{
if (ShouldLog(NatvisLoggingLevel.VERBOSE))
{
Write(LogLevel.Info, $"INFO: {deferredMessage()}");
}
}
public void Warning(LogMessageGenerator deferredMessage)
{
if (ShouldLog(NatvisLoggingLevel.WARNING))
{
Write(LogLevel.Warn, $"WARNING: {deferredMessage()}");
}
}
public void Fatal(LogMessageGenerator messageFunc)
{
if (_logger != null)
{
_logger.Fatal(messageFunc);
}
}
public void Warn(LogMessageGenerator messageFunc)
{
if (_logger != null)
{
_logger.Warn(messageFunc);
}
}
public void Error(LogMessageGenerator messageFunc)
{
if (_logger != null)
{
_logger.Error(messageFunc);
}
}
public void Debug(LogMessageGenerator messageFunc)
{
if (_logger != null)
{
_logger.Debug(messageFunc);
}
}
public void Trace(LogMessageGenerator messageFunc)
{
if (_logger != null)
{
_logger.Trace(messageFunc);
}
}
public void Info(LogMessageGenerator messageFunc)
{
if (_logger != null)
{
_logger.Info(messageFunc);
}
}
public void Error(LogMessageGenerator deferredMessage)
{
if (ShouldLog(NatvisLoggingLevel.ERROR))
{
Write(LogLevel.Error, $"ERROR: {deferredMessage()}");
}
}
internal static void LogEventsSummary(IEnumerable <ILibraryOperationResult> totalResults, OperationType operationType, TimeSpan elapsedTime)
{
LogErrors(totalResults);
LogEvent(LogMessageGenerator.GetSummaryHeaderString(operationType, null), LogLevel.Task);
LogOperationSummary(totalResults, operationType, elapsedTime);
LogEvent(string.Format(LibraryManager.Resources.Text.TimeElapsed, elapsedTime), LogLevel.Operation);
LogEvent(LibraryManager.Resources.Text.SummaryEndLine + Environment.NewLine, LogLevel.Operation);
}
protected void LogResultsSummary(IEnumerable <ILibraryOperationResult> results, OperationType operation, TimeSpan elapsedTime)
{
string messageText = LogMessageGenerator.GetOperationSummaryString(results, operation, elapsedTime);
if (!string.IsNullOrEmpty(messageText))
{
Logger.Log(messageText, LogLevel.Operation);
}
}
private static void LogOperationSummary(IEnumerable <ILibraryOperationResult> totalResults, OperationType operation, TimeSpan elapsedTime)
{
string messageText = LogMessageGenerator.GetOperationSummaryString(totalResults, operation, elapsedTime);
if (!string.IsNullOrEmpty(messageText))
{
LogEvent(messageText, LogLevel.Operation);
}
}
public void Creates_initial_log_message_for_database_create()
{
ILogMessageGenerator generator = new LogMessageGenerator();
var settings = new ConnectionSettings("server", "db", true, null, null);
var taskAttributes = new TaskAttributes(settings, "c:\\scripts");
string message = generator.GetInitialMessage(taskAttributes);
Assert.That(message, Is.EqualTo("Create db on server using scripts from c:\\scripts\n"));
}
/// <summary>
/// Logs the summary messages for a given <see cref="OperationType"/>
/// </summary>
/// <param name="totalResults"></param>
/// <param name="operationType"></param>
/// <param name="elapsedTime"></param>
/// <param name="endOfMessage"></param>
public static void LogEventsSummary(IEnumerable <ILibraryOperationResult> totalResults, OperationType operationType, TimeSpan elapsedTime, bool endOfMessage = true)
{
LogErrors(totalResults);
LogEvent(LogMessageGenerator.GetSummaryHeaderString(operationType), LogLevel.Task);
LogOperationSummary(totalResults, operationType, elapsedTime);
if (endOfMessage)
{
LogEventsFooter(operationType, elapsedTime);
}
}
public static void Debug(this ILogger logger, Exception exception, LogMessageGenerator messageFunc)
{
if (logger.IsDebugEnabled)
{
if (messageFunc == null)
{
throw new ArgumentNullException(nameof(messageFunc));
}
logger.Debug(exception, messageFunc());
}
}
public static void Trace(this ILogger logger, Exception exception, LogMessageGenerator messageFunc)
{
if (logger.IsTraceEnabled)
{
if (messageFunc == null)
{
throw new ArgumentNullException("messageFunc");
}
logger.Trace(exception, messageFunc());
}
}
/// <summary>
/// Writes the diagnostic message at the specified level.
/// </summary>
/// <param name="level">The log level.</param>
/// <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
public void Log(LogLevel level, LogMessageGenerator messageFunc)
{
if (this.IsEnabled(level))
{
if (messageFunc == null)
{
throw new ArgumentNullException("messageFunc");
}
this.WriteToTargets(level, null, messageFunc());
}
}
public void Creates_initial_log_message_for_database_create_while_skiping_some_files()
{
ILogMessageGenerator generator = new LogMessageGenerator();
var settings = new ConnectionSettings("server", "db", true, null, null);
var taskAttributes = new TaskAttributes(settings, "c:\\scripts")
{
SkipFileNameContaining = "_data_"
};
string message = generator.GetInitialMessage(taskAttributes);
Assert.That(message, Is.EqualTo("Create db on server using scripts from c:\\scripts while skipping file containing _data_\n"));
}
public void Creates_initial_log_message_for_database_drop()
{
ILogMessageGenerator generator = new LogMessageGenerator();
var settings = new ConnectionSettings("server", "db", true, null, null);
var taskAttributes = new TaskAttributes(settings, "c:\\scripts")
{
RequestedDatabaseAction = RequestedDatabaseAction.Drop
};
string message = generator.GetInitialMessage(taskAttributes);
Assert.That(message, Is.EqualTo("Drop db on server\n"));
}
/// <summary>
/// Logs errors messages for a given <see cref="OperationType"/>
/// </summary>
/// <param name="errorMessages">Messages to be logged</param>
/// <param name="operationType"><see cref="OperationType"/></param>
/// <param name="endOfMessage">Whether or not to log end of message lines</param>
public static void LogErrorsSummary(IEnumerable <string> errorMessages, OperationType operationType, bool endOfMessage = true)
{
foreach (string error in errorMessages)
{
LogEvent(error, LogLevel.Operation);
}
LogEvent(LogMessageGenerator.GetErrorsHeaderString(operationType), LogLevel.Task);
if (endOfMessage)
{
LogEvent(LibraryManager.Resources.Text.SummaryEndLine + Environment.NewLine, LogLevel.Operation);
}
}
/// <param name="level">The severity of this message.</param>
/// <param name="deferredMessage">
/// A lambda returning the message string, which will only be called if the message is
/// actually going to be logged.
/// </param>
/// <exception cref="System.ComponentModel.InvalidEnumArgumentException">
/// Thrown if the <paramref name="level"/> is not a valid <c>LoggingLevel</c>.
/// </exception>
public void Log(NatvisLoggingLevel level, LogMessageGenerator deferredMessage)
{
switch (level)
{
case NatvisLoggingLevel.OFF: return;
case NatvisLoggingLevel.ERROR: Error(deferredMessage); return;
case NatvisLoggingLevel.WARNING: Warning(deferredMessage); return;
case NatvisLoggingLevel.VERBOSE: Verbose(deferredMessage); return;
default: throw new System.ComponentModel.InvalidEnumArgumentException(
$"Unhandled logging level [{level}] for message [{deferredMessage()}]");
}
}
public void Write(EventType eventType, Func <string> logMessage)
{
LogMessageGenerator logMessageGenerator = () => logMessage();
if (eventType == EventType.Info)
{
Logger.Info(logMessageGenerator);
}
else if (eventType == EventType.Error)
{
Logger.Error(logMessageGenerator);
}
else
{
Logger.Trace(logMessageGenerator);
}
}
public static void InicializaLog(ArchivoConfig lee, EnumNivelLog lvlLog, string fileName, string tipo = "")
{
try
{
BASE_DIR = lee.LogPath;
MAX_SIZE_FILE = lee.LogMaxFileSize;
NUMERING_WITH_SEQUENTIAL = lee.NumeringWithSecuential;
LEVEL_LOG = lvlLog; //(LogLevel)lee.LevelLog;
FILE_NAME = fileName;
}
catch
{
}
if (!Directory.Exists(BASE_DIR))
{
Directory.CreateDirectory(BASE_DIR);
}
LoggingConfiguration confLog = new LoggingConfiguration();
console = new ColoredConsoleTarget {
Name = "console",
Layout = "${shortdate} ${level} ${message}"
};
fileTargetM = new FileTarget
{
FileName = BASE_DIR + FILE_NAME,
Layout = "${message}",
ArchiveAboveSize = MAX_SIZE_FILE,
ArchiveNumbering = ArchiveNumberingMode.Sequence
};
LogLevel lv = LogLevel.Off;
switch(LEVEL_LOG)
{
case EnumNivelLog.Trace: lv = LogLevel.Trace; break;
case EnumNivelLog.Debug: lv = LogLevel.Debug; break;
case EnumNivelLog.Info: lv = LogLevel.Info; break;
case EnumNivelLog.Error: lv = LogLevel.Error; break;
case EnumNivelLog.Warn: lv = LogLevel.Warn; break;
case EnumNivelLog.Fatal: lv = LogLevel.Fatal; break;
}
logRuleConsole = new NLog.Config.LoggingRule("*", lv, console);
logRuleFileM = new NLog.Config.LoggingRule("*", lv, fileTargetM);
confLog.AddTarget("console", console);
confLog.AddTarget("fileM", fileTargetM);
confLog.LoggingRules.Add(logRuleConsole);
confLog.LoggingRules.Add(logRuleFileM);
#if DEBUG
LogManager.ThrowExceptions = true;
#endif
LogManager.Configuration = confLog;
logM += new LogMessageGenerator(LogMensaje);
}
public void LogError(string methodInfo, LogMessageGenerator messageFunc)
{
_logger.Error(messageFunc);
}
public void WriteLog(LogSeverityType level, string title, LogMessageGenerator messageFunc)
{
if (messageFunc == null)
{
throw new ArgumentNullException("messageFunc");
}
WriteLogInternal(new LogRecord(level, title, messageFunc()), "T");
}
public void WriteLog(LogSeverityType level, string title, LogMessageGenerator messageFunc, Exception exception)
{
if (messageFunc == null)
{
throw new ArgumentNullException("messageFunc");
}
if (IsSeverityEnabledForLogging(level))
{
string message = messageFunc();
if (exception is SqlException)
{
string sqlErrorsMessage = GetSqlErrors(exception as SqlException);
message += Environment.NewLine + sqlErrorsMessage;
}
WriteLogBase(new LogRecord(level, title, message) { Exception = exception }, "T");
}
}
public void LogFatal(string methodInfo, LogMessageGenerator messageFunc)
{
_logger.Fatal(messageFunc);
}
public void WriteLog(LogSeverityType level, string title, LogMessageGenerator messageFunc)
{
if (messageFunc == null)
{
throw new ArgumentNullException("messageFunc");
}
if (IsSeverityEnabledForLogging(level))
{
string message = messageFunc();
WriteLogBase(new LogRecord(level, title, message), "T");
}
}
