/// <summary>
/// Initializes a new instance of the <see cref="JsonInterceptedLogger"/> class.
/// </summary>
/// <param name="innerLogger">The inner logger.</param>
/// <param name="interceptor">The interceptor.</param>
public JsonInterceptedLogger(IJsonLogger innerLogger, [CanBeNull] JsonLogEntryInterceptor interceptor)
{
_innerLogger = innerLogger ?? throw new ArgumentNullException(nameof(innerLogger));
interceptor = interceptor.DoNothingIfNull();
_builder = interceptor(this);
}
/// <summary>
/// Adds <c>data</c> to the json entry.
/// </summary>
/// <param name="builder">Entry <c>builder</c>.</param>
/// <param name="data">Object with <c>data</c>.</param>
/// <returns>The same <c>builder</c> for fluent syntax.</returns>
public static ILogEntryBuilder Data(this ILogEntryBuilder builder, object data)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
return(new DelegateLogEntryBuilderForLogEntry(
builder,
e =>
{
try
{
JObject jsonData = JObject.FromObject(data, builder.SerializerSource.Serializer);
foreach (JProperty jProperty in jsonData.Properties())
{
e.SetExtensionData(jProperty.Name, jProperty.Value);
}
}
catch (Exception ex) when(ex.IsProcessable())
{
// TODO: Dump exception.
e.SetExtensionData("DataSerializationError", ex.ToString());
}
return e;
}));
}
public static T Create(T decorated, ILogger logger, ILogEntryBuilder logEntryBuilder)
{
object proxy = Create <T, LoggingProxy <T> >();
((LoggingProxy <T>)proxy).SetParameters(decorated, logger, logEntryBuilder);
return((T)proxy);
}
private static void WriteLogEntry <T1, T2, T3>(
IJsonLogger logger,
LogSeverity severity,
T1 arg1,
T2 arg2,
T3 arg3,
Func <Func <string, ILogEntryBuilder>, T1, T2, T3, ILogEntryBuilder> logEntryBuilder,
string callerFilePath,
string callerMemberName,
int callerLineNumber)
{
if (callerFilePath == null)
{
throw new ArgumentNullException(nameof(callerFilePath));
}
if (callerMemberName == null)
{
throw new ArgumentNullException(nameof(callerMemberName));
}
Instant instant = SystemClock.Instance.GetCurrentInstant();
logger.AsyncHandler.RunAsync(
(instantArg, callInfo, a1, a2, a3) =>
{
ILogEntryBuilder entryBuilder = logEntryBuilder(
msg => new DelegateLogEntryBuilderForLogEntry(
e =>
{
e.Message = msg;
return(e);
},
logger.SerializerSource),
a1,
a2,
a3);
var entry = new LogEntry
{
Severity = severity,
Instant = instant,
CallerInfo = callInfo
};
object buildedEntry = entryBuilder.Build(entry);
logger.Log(buildedEntry);
},
instant,
new CallerInfo(callerFilePath, callerMemberName, callerLineNumber),
arg1,
arg2,
arg3);
}
private void SetParameters(T decorated, ILogger logger, ILogEntryBuilder logEntryBuilder)
{
if (decorated == null)
{
throw new ArgumentNullException(nameof(decorated));
}
_decorated = decorated;
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_logEntryBuilder = logEntryBuilder ?? throw new ArgumentNullException(nameof(logEntryBuilder));
}
/// <summary>
/// Initializes a new instance of the <see cref="DelegateLogEntryBuilderForLogEntry"/> class.
/// </summary>
/// <param name="innerBuilder">Previous build block in a fluent chain.</param>
/// <param name="buildDelegate">Delegate that performs build.</param>
public DelegateLogEntryBuilderForLogEntry(ILogEntryBuilder innerBuilder, Func <LogEntry, LogEntry> buildDelegate)
{
if (innerBuilder == null)
{
throw new ArgumentNullException(nameof(innerBuilder));
}
if (buildDelegate == null)
{
throw new ArgumentNullException(nameof(buildDelegate));
}
_innerBuilder = innerBuilder;
_buildDelegate = buildDelegate;
SerializerSource = innerBuilder.SerializerSource;
}
/// <summary>
/// Adds <c>exception</c> dump to the json entry.
/// </summary>
/// <param name="builder">Entry <c>builder</c>.</param>
/// <param name="exception">Exception to log.</param>
/// <returns>The same <c>builder</c> for fluent syntax.</returns>
public static ILogEntryBuilder Exception(this ILogEntryBuilder builder, Exception exception)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (exception == null)
{
throw new ArgumentNullException(nameof(exception));
}
var exceptionDump = new JsonExceptionDumper().Dump <ExceptionDto>(exception);
return(new DelegateLogEntryBuilderForLogEntry(
builder,
e =>
{
e.Exception = exceptionDump;
return e;
}));
}
/// <summary>
/// Adds <c>details</c> text to a log entry.
/// </summary>
/// <param name="builder">Log entry <c>builder</c>.</param>
/// <param name="details">Details text.</param>
/// <returns>Updated <c>builder</c>.</returns>
public static ILogEntryBuilder Details(this ILogEntryBuilder builder, [NotNull] string details)
{
if (details == null)
{
throw new ArgumentNullException(nameof(details));
}
return(new DelegateLogEntryBuilderForLogEntry(
builder,
e =>
{
if (string.IsNullOrWhiteSpace(e.Details))
{
e.Details = details;
}
else
{
e.Details = $"{e.Details}{Environment.NewLine}{details}";
}
return e;
}));
}
