private static LogEventContext TouchLogEventContext(Action <LogEventContext> additionalOptContextAct)
{
var context = new LogEventContext();
additionalOptContextAct?.Invoke(context);
return(context);
}
/// <summary>
/// Add NancyFX Context into LogEventContext
/// </summary>
/// <param name="context"></param>
/// <param name="nancyContext"></param>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
public static LogEventContext AddNancyContext(this LogEventContext context, NancyContext nancyContext)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
context.AddData(Constants.NancyContextName, new NancyContextSolo(nancyContext), false);
return(context);
}
/// <summary>
/// Additional operation for exceptionless
/// </summary>
/// <param name="context"></param>
/// <param name="additionalOptHandle"></param>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
public static LogEventContext ForExceptionless(this LogEventContext context, Func <EventBuilder, EventBuilder> additionalOptHandle)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (additionalOptHandle == null)
{
return(context);
}
var opt = new LogSinkAdditionalOperation(typeof(ExceptionlessPayloadClient), additionalOptHandle);
context.ImportOpt(opt);
return(context);
}
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);
}
}
/// <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 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);
}
}
}
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));
}
