/// <inheritdoc/>
public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception?exception, Func <TState, Exception?, string> formatter)
{
if (!IsEnabled(logLevel))
{
return;
}
ICollection <object>?Scopes = null;
LoggerGroup? Group = null;
ScopeProvider?.ForEachScope(
(scope, state) =>
{
if (scope is LoggerGroup LoggerGroup)
{
if (Group == null || LoggerGroup.Priority >= Group.Priority)
{
Group = LoggerGroup;
}
return;
}
if (Scopes == null)
{
Scopes = new Collection <object>();
}
Scopes.Add(scope);
},
state);
_AddMessageAction(
LoggerJsonMessage.FromLoggerData(Group?.GroupName, _CategoryName, Scopes, logLevel, eventId, state, exception, formatter));
}
private void SerializeMessageToJson(LoggerJsonMessage message)
{
using (Utf8JsonWriter Writer = new Utf8JsonWriter(_Buffer))
{
try
{
JsonSerializer.Serialize(Writer, message, _JsonOptions);
}
catch (JsonException JsonException)
{
JsonSerializer.Serialize(
Writer,
new LoggerJsonMessage
{
LogLevel = message.LogLevel,
TimestampUtc = message.TimestampUtc,
ThreadId = message.ThreadId,
EventId = message.EventId,
GroupName = message.GroupName,
CategoryName = message.CategoryName,
Content = $"Message with Content [{message.Content}] contained data that could not be serialized into Json.",
Exception = LoggerJsonMessageException.FromException(JsonException)
},
_JsonOptions);
}
}
_Buffer.WriteToStream(_OutputStream);
_Buffer.Clear();
_OutputStream.Write(s_NewLine, 0, s_NewLine.Length);
_OutputStream.Flush();
}
private string SerializeMessageToJson(LoggerJsonMessage message)
{
try
{
return(JsonSerializer.Serialize(message, _JsonOptions));
}
#pragma warning disable CA1031 // Do not catch general exception types
catch (Exception JsonException)
#pragma warning restore CA1031 // Do not catch general exception types
{
return(JsonSerializer.Serialize(
new LoggerJsonMessage
{
LogLevel = message.LogLevel,
TimestampUtc = message.TimestampUtc,
ThreadId = message.ThreadId,
EventId = message.EventId,
GroupName = message.GroupName,
CategoryName = message.CategoryName,
Content = $"Message with Content [{message.Content}] contained data that could not be serialized into Json.",
Exception = LoggerJsonMessageException.FromException(JsonException)
},
_JsonOptions));
}
}
private void AddMessage(LoggerJsonMessage message)
{
if (string.IsNullOrWhiteSpace(message.GroupName))
{
message.GroupName = _LoggerGroupCache !.ResolveGroupNameForCategoryName(message.CategoryName);
}
_Messages.Enqueue(message);
_MessageReadyHandle.Set();
}
/// <inheritdoc/>
public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception?exception, Func <TState, Exception?, string> formatter)
{
if (!IsEnabled(logLevel))
{
return;
}
_MessageManager.AddMessage(
LoggerJsonMessage.FromLoggerData(_CategoryName, ScopeProvider, logLevel, eventId, state, exception, formatter));
}
/// <summary>
/// Adds a message to be displayed.
/// </summary>
/// <param name="message"><see cref="LoggerJsonMessage"/>.</param>
/// <param name="token">Optional <see cref="CancellationToken"/>.</param>
public void AddMessage(LoggerJsonMessage message, CancellationToken token = default)
{
ChannelWriter <LoggerJsonMessage> Writer = Messages.Writer;
while (Writer.WaitToWriteAsync(token).GetAwaiter().GetResult())
{
if (Writer.TryWrite(message))
{
return;
}
}
throw new InvalidOperationException("MessageManager has closed.");
}
public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception?exception, Func <TState, Exception?, string> formatter)
{
ICollection <object>?Scopes = null;
_ScopeProvider.ForEachScope(
(scope, state) =>
{
if (Scopes == null)
{
Scopes = new Collection <object>();
}
Scopes.Add(scope);
},
state);
Message = LoggerJsonMessage.FromLoggerData(null, "Category", Scopes, logLevel, eventId, state, exception, formatter);
}
/// <summary>
/// Adds a message to be displayed.
/// </summary>
/// <param name="message"><see cref="LoggerJsonMessage"/>.</param>
/// <param name="token">Optional <see cref="CancellationToken"/>.</param>
public void AddMessage(LoggerJsonMessage message, CancellationToken token = default)
{
ChannelWriter <LoggerJsonMessage> Writer = Messages.Writer;
while (true)
{
ValueTask <bool> Task = Writer.WaitToWriteAsync(token);
if (!(Task.IsCompleted ? Task.Result : Task.AsTask().GetAwaiter().GetResult()))
{
break;
}
if (Writer.TryWrite(message))
{
return;
}
}
throw new InvalidOperationException("MessageManager has closed.");
}
public void SerializeMessageToJson(LoggerJsonMessage message, Stream stream)
{
try
{
_Writer.Reset();
try
{
JsonSerializer.Serialize(_Writer, message, _Options);
}
catch (JsonException JsonException)
{
JsonSerializer.Serialize(
_Writer,
new LoggerJsonMessage
{
LogLevel = message.LogLevel,
TimestampUtc = message.TimestampUtc,
ThreadId = message.ThreadId,
EventId = message.EventId,
GroupName = message.GroupName,
CategoryName = message.CategoryName,
Content = $"Message with Content [{message.Content}] contained data that could not be serialized into Json.",
Exception = LoggerJsonMessageException.FromException(JsonException)
},
_Options);
}
finally
{
LoggerJsonMessage.Return(message);
}
_Buffer.WriteToStream(stream);
stream.Write(s_NewLine, 0, s_NewLine.Length);
stream.Flush();
}
finally
{
_Buffer.Clear();
}
}
public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception?exception, Func <TState, Exception?, string> formatter)
=> Message = LoggerJsonMessage.FromLoggerData("Category", _ScopeProvider, logLevel, eventId, state, exception, formatter);
