public void Log <TState>(LogLevel logLevel, EventId eventId,
TState state, Exception exception, Func <TState, Exception, string> formatter)
{
if (!IsEnabled(logLevel))
{
return;
}
LoggerFormatter fmt = _formater?.Invoke();
if (fmt == null)
{
fmt = LoggerFormatter.Get(this, Provider.GetSettings()?.Formatter, out _formater);
}
using (var c = StringBuilderCache.Acquire()) {
var handler = TypeHandler <TState> .Default;
fmt.Init(c, handler);
handler.Log(fmt, logLevel, eventId, state, exception, formatter);
if (IncludeScopes)
{
fmt.AppendScopes(_current);
}
fmt.Flush();
}
}
public override void Log(LoggerFormatter f, LogLevel logLevel, EventId eventId,
T state, Exception exception, Func <T, Exception, string> formatter)
{
f.AppendHead(logLevel, eventId, formatter(state, exception));
if (exception != null)
{
f.AppendException(exception);
}
AppendProperties(f, state);
}
public override void Log(LoggerFormatter f, LogLevel logLevel, EventId eventId, string state, Exception exception, Func <string, Exception, string> formatter)
{
if (string.IsNullOrEmpty(state))
{
if (exception != null)
{
f.AppendHead(logLevel, eventId, exception.Message);
f.AppendException(exception);
}
return;
}
f.AppendHead(logLevel, eventId, state);
if (exception != null)
{
f.AppendException(exception);
}
}
/// <summary>
/// Creates a new logger provider.
/// </summary>
/// <param name="stringLog">The underlying string log to which all logs are written. May not be <c>null</c>.</param>
/// <param name="formatter">The formatter used to translate log events into single-line strings. May not be <c>null</c>.</param>
/// <param name="filter">The filter for determining which log events to log. May not be <c>null</c>.</param>
public AnankeLoggerProvider(IStringLog stringLog, LoggerFormatter formatter, LoggerIsEnabledFilter filter)
{
if (stringLog == null)
{
throw new ArgumentNullException(nameof(stringLog));
}
if (formatter == null)
{
throw new ArgumentNullException(nameof(formatter));
}
if (filter == null)
{
throw new ArgumentNullException(nameof(filter));
}
m_stringLog = stringLog;
m_formatter = formatter;
m_filter = filter;
m_loggers = new ConcurrentDictionary <string, ILogger>();
}
private void AppendProperties(LoggerFormatter formatter, T state, bool scoped = false)
{
bool propertyFound = false;
int count = state.Count;
for (int i = 0; i < count;)
{
var pair = state[i];
i++;
if (i == count)
{
// last property
if (pair.Key == "{OriginalFormat}")
{
break;
}
}
if (!propertyFound)
{
if (scoped)
{
formatter.BeginScope();
}
formatter.BeginProperties();
propertyFound = true;
}
formatter.AppendProperty(pair.Key, pair.Value);
}
if (propertyFound)
{
formatter.CloseProperties();
if (scoped)
{
formatter.CloseScope();
}
}
}
internal static AnankeSettings InternalCreate(TimeSpan?maximumRuntime = null, ILoggerFactory loggerFactory = null,
LoggerIsEnabledFilter loggerIsEnabledFilter = null, LoggerFormatter loggerFormatter = null,
TimeSpan?exitTimeout = null, double?randomMaximumRuntimeRelativeDelta = null, StdoutParser stdoutParser = null,
IStringLog consoleLog = null,
IExitProcessService exitProcessService = null, ISignalService signalService = null)
{
if (signalService == null)
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
signalService = new WindowsSignalService();
}
else
{
signalService = new UnixSignalService();
}
}
consoleLog = consoleLog ?? new TextWriterStringLog(Console.Out);
loggerFormatter = loggerFormatter ?? AnankeFormatters.FormattedText;
loggerIsEnabledFilter = loggerIsEnabledFilter ?? ((_, __) => true);
var loggerProvider = new AnankeLoggerProvider(consoleLog, loggerFormatter, loggerIsEnabledFilter);
if (loggerFactory == null)
{
loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(loggerProvider);
}
return(new AnankeSettings(maximumRuntime ?? Timeout.InfiniteTimeSpan,
loggerFactory,
exitTimeout ?? TimeSpan.FromSeconds(10),
randomMaximumRuntimeRelativeDelta ?? 0.10,
stdoutParser ?? ((message, provider) => provider.CreateLogger("App").LogInformation(message)),
consoleLog,
exitProcessService ?? new ExitProcessService(),
signalService));
}
/// <summary>
/// Creates an instance of <see cref="AnankeSettings"/>, with default settings for any setting not specified.
/// </summary>
/// <param name="maximumRuntime">The amount of time application code should run until it is requested to exit. Defaults to infinite, but most apps should use a non-infinite time.</param>
/// <param name="loggerFactory">The core logging factory used by all structured logging. Defaults to a logging factory with a single provider that writes formatted text to <see cref="ConsoleLog"/>.</param>
/// <param name="loggerIsEnabledFilter">The filter used by the <see cref="AnankeLoggerProvider"/> if <paramref name="loggerFactory"/> is <c>null</c>.</param>
/// <param name="loggerFormatter">The formatter used by the <see cref="AnankeLoggerProvider"/> if <paramref name="loggerFactory"/> is <c>null</c>.</param>
/// <param name="exitTimeout">The amount of time application code has after it is requested to exit, before the process forcibly exits. Defaults to 10 seconds.</param>
/// <param name="randomMaximumRuntimeRelativeDelta">The amount of random fluction in <see cref="MaximumRuntime"/>. E.g., <c>0.10</c> is a 10% change; if <see cref="MaximumRuntime"/> is 30 minutes, then the actual maximum runtime would be a random value between 27 and 33 minutes. Defaults to 0.10 (10%).</param>
/// <param name="stdoutParser">A method that parses text written to stdout.</param>
public static AnankeSettings Create(TimeSpan?maximumRuntime = null, ILoggerFactory loggerFactory = null,
LoggerIsEnabledFilter loggerIsEnabledFilter = null, LoggerFormatter loggerFormatter = null,
TimeSpan?exitTimeout = null, double?randomMaximumRuntimeRelativeDelta = null, StdoutParser stdoutParser = null)
{
return(InternalCreate(maximumRuntime, loggerFactory, loggerIsEnabledFilter, loggerFormatter,
exitTimeout, randomMaximumRuntimeRelativeDelta, stdoutParser));
}
public override void Log(LoggerFormatter f, LogLevel logLevel, EventId eventId,
T state, Exception exception, Func <T, Exception, string> formatter)
{
f.AppendHead(logLevel, eventId, formatter(state, exception));
}
protected override void AppendScope(LoggerFormatter formatter)
{
formatter.BeginScalar();
((ScalarHandler <T>)formatter.Handler).AppendValue(formatter.Builder, _state);
formatter.CloseScalar();
}
protected override void AppendScope(LoggerFormatter formatter)
{
formatter.BeginScalar();
formatter.Builder.Append(_state);
formatter.CloseScalar();
}
protected virtual void AppendScope(LoggerFormatter formatter)
{
}
//public static Scope[] GetAll(Scope scope) {
// if ( scope == null )
// return Array.Empty<Scope>();
// List<Scope> list = new List<Scope>();
// do {
// list.Add( scope );
// scope = scope._parent;
// } while ( scope != null );
// list.Reverse();
// return list.ToArray();
//}
public void AppendTo(LoggerFormatter formatter)
{
_parent?.AppendTo(formatter);
AppendScope(formatter);
}
protected override void AppendScope(LoggerFormatter formatter)
{
((KeyValueHandler <T>)formatter.Handler)
.AppendProperties(formatter, _state, true);
}
