/// <summary>
/// Create a new instance of <see cref="FutureLoggerBase"/>
/// </summary>
/// <param name="logger"></param>
/// <param name="memberName"></param>
/// <param name="filePath"></param>
/// <param name="lineNumber"></param>
protected FutureLoggerBase(ILogger logger, [CallerMemberName] string memberName = null, [CallerFilePath] string filePath = null, [CallerLineNumber] int lineNumber = 0)
{
_internalLogger = logger ?? throw new ArgumentNullException(nameof(logger));
_loggerLifetimeContextData = new ContextData();
_callerInfo = new LogCallerInfo(memberName, filePath, lineNumber);
SetCurrentState(_callerInfo);
}
/// <summary>
/// Create a new instance of <see cref="FutureLogEventDescriptor"/>
/// </summary>
/// <param name="callerInfo"></param>
/// <param name="loggerLifetimeContextData"></param>
public FutureLogEventDescriptor(ILogCallerInfo callerInfo, ContextData loggerLifetimeContextData)
{
_callerInfo = callerInfo ?? NullLogCallerInfo.Instance;
_ownLifetimeContextData = new ContextData();
_loggerLifetimeContextData = loggerLifetimeContextData;
Context = new LogEventContext(_ownLifetimeContextData);
}
private void ParseAndInsertLogEventIntoQueueAutomatically(LogEventId eventId, LogEventLevel level, Exception exception, string messageTemplate,
ILogCallerInfo callerInfo, LogEventContext context = null, params object[] messageTemplateParameters)
{
var task = CreateEnqueueTask();
task.ContinueWith(t => DispatchForAutomatic());
task.Start();
Task CreateEnqueueTask()
{
var taskResult = new Task(async() => {
var writer = await _automaticAsyncQueue.AcquireWriteAsync(1, CancellationToken.None);
writer.Visit(
succeeded => {
_messageParameterProcessor.Process(messageTemplate, __as(messageTemplateParameters, context),
out var parsedTemplate, out var namedMessageProperties, out var positionalMessageProperties);
var logEvent = new LogEvent(StateNamespace, eventId, level, parsedTemplate, exception,
LogEventSendMode.Automatic, callerInfo, _upstreamRenderingOptions,
namedMessageProperties, positionalMessageProperties, context,
messageProcessorShortcut: _messageParameterProcessor);
if (succeeded.ItemCount >= 1)
{
_automaticAsyncQueue.ReleaseWrite(logEvent);
}
else
{
_automaticAsyncQueue.ReleaseWrite();
}
return(logEvent);
},
cancelled => {
InternalLogger.WriteLine("When insert log event(0) into async queue, task has been cancelled.");
return(null);
},
faulted => {
InternalLogger.WriteLine(
$@"Thrown an exception when insert log event(0) into async queue:{Environment.NewLine}{faulted.Exception.ToUnwrappedString()}",
faulted.Exception);
return(null);
});
});
return(taskResult);
object[] __as(object[] __paramObjs, LogEventContext __context)
{
if (__paramObjs == null || !__paramObjs.Any())
{
return(__context?.Parameters.ToArray());
}
return(__paramObjs.GetType() != typeof(object[]) ? new object[] { __paramObjs } : __paramObjs);
}
}
}
public ManuallyLogEventDescriptor(LogEventId eventId, LogEventLevel level, Exception exception, string messageTemplate,
ILogCallerInfo callerInfo, LogEventContext context = null, params object[] messageTemplateParameters)
{
EventId = eventId;
Level = level;
Exception = exception;
MessageTemplate = messageTemplate;
CallerInfo = callerInfo;
Context = context;
MessageTemplateParameters = messageTemplateParameters;
}
/// <summary>
/// Write
/// </summary>
/// <param name="logTrack"></param>
/// <param name="level"></param>
/// <param name="exception"></param>
/// <param name="messageTemplate"></param>
/// <param name="sendMode"></param>
/// <param name="callerInfo"></param>
/// <param name="context"></param>
/// <param name="messageTemplateParameters"></param>
public void Write(LogTrack?logTrack, LogEventLevel level, Exception exception, string messageTemplate, LogEventSendMode sendMode, ILogCallerInfo callerInfo,
LogEventContext context = null, params object[] messageTemplateParameters)
{
if (!IsEnabled(level))
{
return;
}
if (string.IsNullOrWhiteSpace(messageTemplate))
{
return;
}
var cleanMessageTemplateParameters = ArgsHelper.CleanUp(messageTemplateParameters);
var logEventId = TouchLogEventId(logTrack, StateNamespace);
if (IsManuallySendMode(sendMode))
{
ParseAndInsertLogEvenDescriptorManually(logEventId, level, exception, messageTemplate, callerInfo, context, cleanMessageTemplateParameters);
}
else
{
ParseAndInsertLogEventIntoQueueAutomatically(logEventId, level, exception, messageTemplate, callerInfo, context, cleanMessageTemplateParameters);
}
}
private void SetCurrentState(ILogCallerInfo callerInfo)
{
CurrentDescriptor = new FutureLogEventDescriptor(callerInfo, _loggerLifetimeContextData);
}
private void ParseAndInsertLogEvenDescriptorManually(LogEventId eventId, LogEventLevel level, Exception exception, string messageTemplate,
ILogCallerInfo callerInfo, LogEventContext context = null, params object[] messageTemplateParameters)
{
_manuallyLogEventDescriptors[CurrentManuallyTransId]
.Add(new ManuallyLogEventDescriptor(eventId, level, exception, messageTemplate, callerInfo, context, messageTemplateParameters));
}
public void Write(LogEventId eventId, LogEventLevel level, Exception exception, string messageTemplate, LogEventSendMode sendMode, ILogCallerInfo callerInfo,
LogEventContext context = null, params object[] messageTemplateParameters)
{
if (!IsEnabled(level))
{
return;
}
if (string.IsNullOrWhiteSpace(messageTemplate))
{
return;
}
if (IsManuallySendMode(sendMode))
{
ParseAndInsertLogEvenDescriptorManually(eventId ?? new LogEventId(), level, exception, messageTemplate, callerInfo, context, messageTemplateParameters);
}
else
{
ParseAndInsertLogEventIntoQueueAutomatically(eventId ?? new LogEventId(), level, exception, messageTemplate, callerInfo, context, messageTemplateParameters);
}
}
