public void Debug(string message, params object[] arguments)
{
if (_debug)
{
Console.WriteLine(_logFormatter.Format("DEBUG", message, arguments));
}
}
public void Log(RequestData requestData, ResponseData responseData)
{
var info = _formatter.Format(requestData, responseData);
info.LoggerName = _logger.Name;
_logger.Log(info);
}
public void Format_ShouldReturn_LogEventInfo()
{
var requestData = new RequestData();
var responseData = new ResponseData();
var result = _formatter.Format(requestData, responseData);
Assert.IsNotNull(result);
Assert.IsInstanceOf <LogEventInfo>(result);
}
public void Log(object sender, LogEventArgs args)
{
if (_logColors.TryGetValue(args.Level, out ConsoleColor color))
{
Console.ForegroundColor = color;
Console.WriteLine(_formatter.Format(args));
Console.ResetColor();
}
else
{
Console.WriteLine(_formatter.Format(args));
}
}
/// <inheritdoc cref="ILogTarget"/>
public void OnLog(LogLevel level, object caller, string message)
{
var formattedMessage = _formatter.Format(level, caller, message);
switch (level)
{
case LogLevel.Info:
case LogLevel.Debug:
{
Debug.Log(formattedMessage);
break;
}
case LogLevel.Warning:
{
Debug.LogWarning(formattedMessage);
break;
}
case LogLevel.Error:
case LogLevel.Fatal:
{
Debug.LogError(formattedMessage);
break;
}
}
}
/// <inheritdoc cref="ILogTarget"/>
public void OnLog(LogLevel level, object caller, string message)
{
Debug.WriteLine(_formatter.Format(
level,
caller,
message));
}
private void Log(LogEntry entry, EventLogEntryType logType, ILogFormatter formatter)
{
string logLine = formatter.Format(entry);
try { _EventLog.WriteEntry(logLine, logType); }
catch { return; }
}
public void RedirectsToCommonLogging()
{
CapturingLoggerFactoryAdapter testLoggerFactoryAdapter = new CapturingLoggerFactoryAdapter();
LogManager.Adapter = testLoggerFactoryAdapter;
// force entlib logging init
Logger.Write("init");
var listener = (CommonLoggingEntlibTraceListener)((TraceListenerWrapper)EnterpriseLibraryContainer.Current.GetInstance <TraceListener>("Test Capturing Listener")).InnerTraceListener;
// ensure external configuration didn't change
// change to starts with because entlib now wraps all listeners and changes the name
Assert.IsTrue(listener.Name.StartsWith("Test Capturing Listener"));
LogEntry logEntry = new LogEntry();
logEntry.Categories.Add("mycategory");
logEntry.Message = "testmessage";
ILogFormatter formatter = listener.Formatter;
string s = formatter.Format(logEntry);
Assert.AreEqual("Category: mycategory, Message: testmessage", s);
// note that output depends on the formatter configured for the entlib listener!
Logger.Write("message1");
Assert.AreEqual("Category: General, Message: message1", testLoggerFactoryAdapter.LastEvent.RenderedMessage);
Assert.AreEqual(LogLevel.Info, testLoggerFactoryAdapter.LastEvent.Level);
Logger.Write("message2", "custom category", -1, -1, TraceEventType.Warning);
Assert.AreEqual("Category: custom category, Message: message2", testLoggerFactoryAdapter.LastEvent.RenderedMessage);
Assert.AreEqual("Test Capturing Listener/All Events", testLoggerFactoryAdapter.LastEvent.Source.Name);
Assert.AreEqual(LogLevel.Warn, testLoggerFactoryAdapter.LastEvent.Level);
}
/// <summary>
/// Creates a full populated new <see cref="ApplicationLogEntity"/> from a given <see cref="LogEntry"/>
/// </summary>
/// <param name="logEntry"></param>
/// <param name="formatter"></param>
/// <returns></returns>
public static ApplicationLogEntity CreateFromLogEntry(LogEntry logEntry, ILogFormatter formatter)
{
Guard.ArgumentNotNull(logEntry, "logEntry");
ApplicationLogEntity entity = new ApplicationLogEntity
{
AppDomainName = logEntry.AppDomainName,
ApplicationName = logEntry.ApplicationName,
Category = logEntry.Categories.Join(","),
EventId = logEntry.EventId,
MachineName = Environment.MachineName,
Message = logEntry.Message,
Priority = logEntry.Priority,
ProcessId = logEntry.ProcessId,
ProcessName = logEntry.ProcessName,
Severity = logEntry.Severity.ToString(),
ThreadName = logEntry.ManagedThreadName,
Title = logEntry.Title,
Win32ThreadId = logEntry.Win32ThreadId
};
entity.Timestamp = new DateTimeOffset(logEntry.TimeStamp, TimeSpan.Zero);
entity.PartitionKey = CreatePartitionKey(entity.ApplicationName, entity.Timestamp);
entity.RowKey = ApplicationLogEntityManager.CreateRowKey(SortOrder.Descending);
entity.FormattedMessage = formatter != null?formatter.Format(logEntry) : logEntry.Message;
return(entity);
}
public void RedirectsToCommonLogging()
{
CapturingLoggerFactoryAdapter testLoggerFactoryAdapter = new CapturingLoggerFactoryAdapter();
LogManager.Adapter = testLoggerFactoryAdapter;
// force entlib logging init
Logger.Write("init");
// ensure external configuration didn't change
Assert.AreEqual("Test Capturing Listener", TestCommonLoggingEntlibTraceListener.Instance.Name);
LogEntry logEntry = new LogEntry();
logEntry.Categories.Add("mycategory");
logEntry.Message = "testmessage";
ILogFormatter formatter = TestCommonLoggingEntlibTraceListener.Instance.Formatter;
string s = formatter.Format(logEntry);
Assert.AreEqual("Category: mycategory, Message: testmessage", s);
using (TestCommonLoggingEntlibTraceListener.Instance.Capture())
{
// note that output depends on the formatter configured for the entlib listener!
Logger.Write("message1");
Assert.AreEqual("Category: General, Message: message1", testLoggerFactoryAdapter.LastEvent.RenderedMessage);
Assert.AreEqual(LogLevel.Info, testLoggerFactoryAdapter.LastEvent.Level);
Logger.Write("message2", "custom category", -1, -1, TraceEventType.Warning);
Assert.AreEqual("Category: custom category, Message: message2", testLoggerFactoryAdapter.LastEvent.RenderedMessage);
Assert.AreEqual("Test Capturing Listener/All Events", testLoggerFactoryAdapter.LastEvent.Source.Name);
Assert.AreEqual(LogLevel.Warn, testLoggerFactoryAdapter.LastEvent.Level);
}
}
public void Write(string MsgStr)
{
string _MsgStr = _format.Format(MsgStr);
_MsgStr += _target;
//Output Message
Console.WriteLine("Output " + _MsgStr);
}
private async Task WriteFile()
{
await foreach (var log in _queue.Reader.ReadAllAsync(_cts.Token))
{
_formatter.Format(log, _fs);
_fs.Flush();
}
}
public string Format(int scopeLevel, string name, LogLevel logLevel, EventId eventId, string message, Exception exception)
{
var formatted = formatter.Format(scopeLevel, name, logLevel, eventId, message, exception);
var sanitized = formatted.Replace(apiKeyToRemove, RemovedApiKey);
return(sanitized);
}
void Write(string message, LogLevel level)
{
if (_defaultLogLevel > level)
{
return;
}
var logItem = new LogItem
{
LogLevel = level, LoggerName = _name,
TimeStamp = DateTime.Now,
Thread = string.IsNullOrEmpty(Thread.CurrentThread.Name) ? Thread.CurrentThread.ManagedThreadId.ToString() : Thread.CurrentThread.Name,
AppDomain = AppDomain.CurrentDomain.FriendlyName,
Message = message
};
_logTarget.WriteMessage(_logFormatter.Format(logItem));
}
public void Flush()
{
while (_queue.TryDequeue(out var logEntry))
{
var text = _formatter.Format(logEntry);
_logFile.Write(logEntry.CreationTime, text);
}
}
public void Append(string scopeName, LogLevel level, object model)
{
ILogger log = GetLog(scopeName);
// If requested level is not enabled, do nothing.
if (!IsEnabled(log, level))
{
return;
}
object message;
Exception exception = null;
// If we have formatter, use formatter.
if (formatter != null)
{
message = formatter.Format(scopeName, level, model);
}
else if (!Converts.Try(model.GetType(), typeof(string), model, out message))
{
// Try convert to exception model.
ExceptionModel exceptionModel = model as ExceptionModel;
if (exceptionModel != null)
{
message = exceptionModel.Message;
exception = exceptionModel.Exception;
}
else
{
// Use model as message.
message = model;
}
}
// Log to defined level.
switch (level)
{
case LogLevel.Debug:
log.Debug(model, exception);
break;
case LogLevel.Info:
log.Info(model);
break;
case LogLevel.Warning:
log.Warn(model, exception);
break;
case LogLevel.Error:
log.Error(model, exception);
break;
case LogLevel.Fatal:
log.Fatal(model, exception);
break;
}
}
public void Log(LogLevel logLevel, EventId eventId, string message, object state)
{
if (IsEnabled(logLevel))
{
string entry = _logFormatter.Format(logLevel, eventId, message, state);
LockQueue(() => _entryQueue.Enqueue(entry));
StartWriteTask();
}
}
private void FormatAndWrite(Level level, Exception exception, string message)
{
var formattedLog = _formatter.Format(level, exception, message);
var rules = _config.GetRules(DestinationType.File);
foreach (var rule in rules)
{
_writer.Write(rule.Destination, formattedLog);
}
}
private void WritesLogToConsole(ILogFormatter formatter)
{
var logInfo = new LogInfo(LogLevel.INFO, new InvokerModel("", ""), "");
var consoleLogWriter = new ConsoleLogWriter(formatter);
TestConsoleOutput(
() => consoleLogWriter.Write(logInfo),
(output) => Assert.AreEqual(formatter.Format(logInfo), output)
);
}
/// <summary>
/// Initializes a new instance of <see cref="AsyncConsoleSink"/>.
/// </summary>
/// <param name="formatter">Log formatter.</param>
/// <param name="renderer">Renderer factory method.</param>
public AsyncConsoleSink(ILogFormatter formatter, Func <IDataRenderer> renderer)
{
Formatter = formatter;
this.renderer = renderer;
asyncWriter = new AsyncWriter((level, entries) =>
{
System.Console.WriteLine(Formatter.Format(level, entries, renderer()));
});
asyncWriter.Start();
}
/// <summary>
/// When called, logs to the file.
/// </summary>
/// <param name="level"></param>
/// <param name="caller"></param>
/// <param name="message"></param>
public void OnLog(LogLevel level, object caller, string message)
{
try
{
_writer?.Write(_formatter.Format(level, caller, message));
}
catch
{
//
}
}
public void Write(string msg)
{
StringBuilder sb = new StringBuilder();
if (!string.IsNullOrWhiteSpace(_message))
{
sb.Append(_message);
}
sb.Append(_iLogFormatter.Format(msg));
System.IO.File.AppendAllText(_filePath, sb.ToString(), Encoding.UTF8);
}
/// <summary>
/// Formats the given <see cref="LogEntry"></see> through the given <see cref="ILogFormatter"></see>
/// </summary>
/// <param name="formatter">Instance of class implementing the <see cref="ILogFormatter"></see> interface</param>
/// <param name="logEntry">The <see cref="LogEntry"></see> to format</param>
/// <returns>The formatted <see cref="LogEntry"></see></returns>
protected virtual string FormatEntry(ILogFormatter formatter, LogEntry logEntry)
{
string formattedMessage = formatter.Format(logEntry);
if (logEntry.ErrorMessages != null)
{
formattedMessage = logEntry.ErrorMessages.ToString() + "Message: " +
Environment.NewLine + formattedMessage;
}
return(formattedMessage);
}
/// <inheritdoc cref="ILogTarget"/>
public void OnLog(LogLevel level, object caller, string message, object meta)
{
if (level < Filter)
{
return;
}
Debug.WriteLine(_formatter.Format(
level,
caller,
message));
}
public string ToString(ILogFormatter formatter)
{
if (formatter == null) return ToString();
try
{
return formatter.Format(this);
}
catch
{
return ToString();
}
}
public string ToString(ILogFormatter formatter)
{
if (formatter == null)
{
return(ToString());
}
try
{
return(formatter.Format(this));
}
catch
{
return(ToString());
}
}
public override string ToString()
{
if (_cachedResult == null)
{
if (_logFormatter == null)
{
_cachedResult = _logEntry.ToString();
}
else
{
_cachedResult = _logFormatter.Format(_logEntry);
}
}
return(_cachedResult);
}
/// <summary>
/// Logs the specified entry.
/// </summary>
/// <param name="entry">The entry.</param>
/// <param name="formatter">The formatter.</param>
public void Log(LogEntry entry, ILogFormatter formatter)
{
if (!_Enabled)
{
return;
}
SplitLog();
try
{
string logLine = formatter.Format(entry) + "\r\n";
File.AppendAllText(_Location, logLine);
}
catch { return; }
}
public override string ToString()
{
if (cachedResult == null)
{
if (logFormatter == null)
{
cachedResult = logEntry.ToString();
}
else
{
cachedResult = logFormatter.Format(logEntry);
}
}
return(cachedResult);
}
/// <summary>
/// When called, logs to the file.
/// </summary>
/// <param name="level"></param>
/// <param name="caller"></param>
/// <param name="message"></param>
public void OnLog(LogLevel level, object caller, string message, object meta)
{
if (level < Filter)
{
return;
}
try
{
_writer?.Write(_formatter.Format(level, caller, message));
}
catch
{
//
}
}
private MailMessage CreateMailMessage()
{
string header = GenerateSubjectPrefix(configurationData.SubjectLineStarter);
string footer = GenerateSubjectSuffix(configurationData.SubjectLineEnder);
string sendToSmtpSubject = header + logEntry.Severity + footer;
MailMessage message = new MailMessage();
message.Body = formatter.Format(logEntry);
message.From = configurationData.FromAddress;
message.To = configurationData.ToAddress;
message.Subject = sendToSmtpSubject;
message.BodyEncoding = Encoding.UTF8;
return(message);
}
public void Log(string message, LogLevel logLevel, ILogFormatter logFormatter)
{
Debug.WriteLine(logFormatter.Format(message, logLevel, DateTime.Now));
}
/// <summary>
/// Escreve o resultado de um <see cref="LogEntry"/> no <see cref="System.Console"/>.
/// </summary>
/// <param name="logger">O logger</param>
/// <param name="formatter">O formatador</param>
/// <param name="entry">A entrada no log</param>
public void Append(ILogger logger, ILogFormatter formatter, LogEntry entry)
{
Console.WriteLine(formatter.Format(entry));
}
/// <summary>
/// Formats the given <see cref="LogEntry"></see> through the given <see cref="ILogFormatter"></see>
/// </summary>
/// <param name="formatter">Instance of class implementing the <see cref="ILogFormatter"></see> interface</param>
/// <param name="logEntry">The <see cref="LogEntry"></see> to format</param>
/// <returns>The formatted <see cref="LogEntry"></see></returns>
protected virtual string FormatEntry(ILogFormatter formatter, LogEntry logEntry)
{
string formattedMessage = formatter.Format(logEntry);
if (logEntry.ErrorMessages != null)
{
formattedMessage = logEntry.ErrorMessages.ToString() + "Message: " +
Environment.NewLine + formattedMessage;
}
return formattedMessage;
}
public void Log(LogEntry entry, ILogFormatter formatter)
{
if (!_Enabled) return;
SplitLog();
try
{
string logLine = formatter.Format(entry) + "\r\n";
File.AppendAllText(_Location, logLine);
}
catch { return; }
}
private void Log(LogEntry entry, EventLogEntryType logType, ILogFormatter formatter)
{
string logLine = formatter.Format(entry);
try { _EventLog.WriteEntry(logLine, logType); }
catch { return; }
}
public void Log(LogEntry entry, ILogFormatter formatter)
{
Console.WriteLine(formatter.Format(entry));
}
public void Log(string message, LogLevel logLevel, ILogFormatter logFormatter)
{
this.LastMessage = logFormatter.Format(message, logLevel, LogTime);
this.LastLogLevel = logLevel;
this.LastLogFormatter = logFormatter;
}
internal static void AssertSerializingLogFormatter(ILogFormatter logFormatter, Mock<ISerializer> mockSerializer)
{
Assert.That(logFormatter.Format(null), Is.EqualTo("Hello, world!"));
mockSerializer.Verify(m => m.SerializeToString(It.IsAny<object>(), It.IsAny<Type>()), Times.Once());
}