public void Configure(
IApplicationBuilder app,
IHostingEnvironment env,
ILoggerFactory loggerFactory,
Tuple <IJsonLogger, IIxResolver> arguments,
LoggerWebAppConfig webAppConfig)
{
IJsonLogger jsonLogger = arguments.Item1;
app.UseForwardedHeaders(
new ForwardedHeadersOptions
{
KnownNetworks =
{
new IPNetwork(IPAddress.Any, 0)
},
ForwardedHeaders =
ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto
| ForwardedHeaders.XForwardedHost
});
// TODO: Add request dumping.
app.UseDelegateExceptionHandler(
async(context, ex) =>
{
jsonLogger.Error(
ex,
(_, e) =>
_("WebApp pipeline error").Exception(e));
});
app.UseCors("CorsPolicy");
app.UseMvc();
}
public QueryDumpMiddleware(
RequestDelegate next,
IJsonLogger logger)
{
_next = next;
Log = new ClassJsonLogger <QueryDumpMiddleware>(logger);
}
/// <summary>
/// Initializes a new instance of the <see cref="AsyncResponseHandler{TResponseKey}"/> class.
/// </summary>
/// <param name="keyExtractor">The "key extractor" delegate.</param>
/// <param name="logger">The logger.</param>
/// <param name="useRequestBodyBuffering">Enables request body buffering (required for key extraction from the body).</param>
/// <param name="handlerRegistrationTimeOut">Maximum allowed time to register receive delegate.</param>
public AsyncResponseHandler(
Func <HttpContext, TResponseKey> keyExtractor,
IJsonLogger logger,
bool useRequestBodyBuffering = true,
TimeSpan handlerRegistrationTimeOut = default(TimeSpan))
{
if (keyExtractor == null)
{
throw new ArgumentNullException(nameof(keyExtractor));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (handlerRegistrationTimeOut < TimeSpan.Zero)
{
throw new ArgumentOutOfRangeException(
nameof(handlerRegistrationTimeOut),
"Trap registration timeout should be positive.");
}
_keyExtractor = keyExtractor;
Log = new ClassJsonLogger <AsyncResponseHandler <TResponseKey> >(logger);
_useRequestBodyBuffering = useRequestBodyBuffering;
if (handlerRegistrationTimeOut == default(TimeSpan))
{
handlerRegistrationTimeOut = TimeSpan.FromSeconds(10);
}
_handlerRegistrationTimeOut = handlerRegistrationTimeOut;
}
public Logger(IJsonLogger jsonLogger, IHtmlLogger htmlLogger, IStringHelper stringHelper, IConsoleManager consoleManager)
{
_jsonLogger = jsonLogger;
_htmlLogger = htmlLogger;
_stringHelper = stringHelper;
_consoleManager = consoleManager;
}
public Logger(IJsonLogger jsonLogger, IHtmlLogger htmlLogger, IStringHelper stringHelper, IConsoleManager consoleManager)
{
_jsonLogger = jsonLogger;
_htmlLogger = htmlLogger;
_stringHelper = stringHelper;
_consoleManager = consoleManager;
}
/// <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);
}
public void SimpleTest()
{
IJsonLogger log = RootTestingEnvironment.Logger;
log.Debug(
10,
(_, a) => _("Test")
.Details(a.ToString()));
}
/// <summary>
/// Initializes a new instance of the <see cref="ScopedLogger"/> class.
/// </summary>
/// <param name="inner">The parent logger.</param>
/// <param name="scopeId">Scope identifier object.</param>
public ScopedLogger(IJsonLogger inner, object scopeId)
{
if (inner == null)
{
throw new ArgumentNullException(nameof(inner));
}
_inner = inner;
_scopeId = scopeId;
}
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);
}
public SimplePersistence(
IJsonLogger logger,
ICollection <IPersistenceInitializer <SimplePersistence> > initializers)
: base(logger)
{
if (initializers == null)
{
throw new ArgumentNullException(nameof(initializers));
}
foreach (IPersistenceInitializer <SimplePersistence> initializer in initializers)
{
initializer.Initialize(this);
}
Initialize();
}
/// <summary>
/// Writes warning log entry.
/// </summary>
/// <param name="logger">Logger to write to.</param>
/// <param name="logEntryBuilder">Log entry builder <c>delegate</c>.</param>
/// <param name="callerFilePath">Log entry origin file path.</param>
/// <param name="callerMemberName">Log entry origin member name.</param>
/// <param name="callerLineNumber">Log entry origin line number.</param>
public static void Warning(
this IJsonLogger logger,
Func <Func <string, ILogEntryBuilder>, ILogEntryBuilder> logEntryBuilder,
[CallerFilePath] string callerFilePath = null,
[CallerMemberName] string callerMemberName = null,
[CallerLineNumber] int callerLineNumber = 0)
{
// ReSharper disable AssignNullToNotNullAttribute
WriteLogEntry(
logger,
LogSeverity.Warning,
logEntryBuilder,
callerFilePath,
callerMemberName,
callerLineNumber);
// ReSharper restore AssignNullToNotNullAttribute
}
private ClusterNode(
IIxHost indirectXHost,
IWebHostBuilder webHostBuilder,
IConfigurationRoot configRoot,
IJsonLogger logger)
{
Log = new ClassJsonLogger <ClusterNode>(logger);
_executeCts = new CancellationTokenSource();
_executeCancellationToken = _executeCts.Token;
_indirectXHost = indirectXHost;
_configRoot = configRoot;
Log.Info(_ => _("Starting Asp.Net core..."));
_webHost = webHostBuilder
.UseStartup <ClusterNodeStartup>()
.Build();
_webHost.Start();
_hostLifetimeService = _webHost.Services.GetRequiredService <IApplicationLifetime>();
Key = new ClusterNodeKey(_configRoot.GetValue(ClusterNodeIdKey, "single-node"));
var addressesFeature = _webHost.ServerFeatures.Get <IServerAddressesFeature>();
foreach (string addressesFeatureAddress in addressesFeature.Addresses)
{
Log.Info(
addressesFeatureAddress,
(_, addr) => _($"NodeId = '{Key.Code}' listening on: {addr}").Data(new { ListenAddress = addr }));
}
Console.CancelKeyPress += (sender, e) =>
{
if (!_executeCancellationToken.IsCancellationRequested)
{
Log.Trace(_ => _("Termination raised by system."));
_executeCts.Cancel();
}
e.Cancel = true;
};
}
/// <summary>
/// Writes trace log entry.
/// </summary>
/// <typeparam name="T1">Log entry builder argument 1 type.</typeparam>
/// <typeparam name="T2">Log entry builder argument 2 type.</typeparam>
/// <param name="logger">Logger to write to.</param>
/// <param name="arg1">Log entry builder argument 1.</param>
/// <param name="arg2">Log entry builder argument 2.</param>
/// <param name="logEntryBuilder">Log entry builder <c>delegate</c>.</param>
/// <param name="callerFilePath">Log entry origin file path.</param>
/// <param name="callerMemberName">Log entry origin member name.</param>
/// <param name="callerLineNumber">Log entry origin line number.</param>
public static void Trace <T1, T2>(
this IJsonLogger logger,
T1 arg1,
T2 arg2,
Func <Func <string, ILogEntryBuilder>, T1, T2, ILogEntryBuilder> logEntryBuilder,
[CallerFilePath] string callerFilePath = null,
[CallerMemberName] string callerMemberName = null,
[CallerLineNumber] int callerLineNumber = 0)
{
// ReSharper disable AssignNullToNotNullAttribute
WriteLogEntry(
logger,
LogSeverity.Debug,
arg1,
arg2,
logEntryBuilder,
callerFilePath,
callerMemberName,
callerLineNumber);
// ReSharper restore AssignNullToNotNullAttribute
}
// [Require(typeof(IClusterNode))]
private LoggerWebApp(
IIxResolver resolver,
IWebHostBuilder webHostBuilder,
IJsonLogger logger,
ILogReader logReader,
LoggerWebAppConfig config)
{
Log = new ClassJsonLogger <LoggerWebApp>(logger);
Log.Info(_ => _("Starting Asp.Net core..."));
_webHost = webHostBuilder
// Should be removed after adoption IndirectX to Asp.Net core.
.ConfigureServices(
x => x
.AddHttpRequestScopeService()
.AddScopedHttpContextAccessor()
.AddSingleton(new Tuple <IJsonLogger, IIxResolver>(Log, resolver))
.AddSingleton <ILogReader>(logReader)
.AddSingleton(config))
.UseStartup <LoggerWebAppStartup>()
.ConfigureJsonFormatters(JsonDefaults.RestRpcSerializerSource.Settings)
.Build();
_webHost.Start();
var addressesFeature = _webHost.ServerFeatures.Get <IServerAddressesFeature>();
var addresses = new HashSetEx <string>();
foreach (string addressesFeatureAddress in addressesFeature.Addresses)
{
addresses.Add(addressesFeatureAddress);
Log.Info(
addressesFeatureAddress,
(_, addr) => _($"Now listening on: {addr}").Data(new { ListenAddress = addr }));
}
HostingUrls = addresses;
}
public HttpClientWithDumpingFactory(IJsonLogger logger)
{
_logger = logger;
}
public DumpHandler(HttpMessageHandler inner, IJsonLogger logger)
: base(inner)
{
Log = new ClassJsonLogger <DumpHandler>(logger);
}
/// <summary>
/// Enables request/response dumping to the provided logger.
/// </summary>
/// <param name="url">Flurl url.</param>
/// <param name="logger">The logger.</param>
/// <returns></returns>
public static IFlurlRequest WithDump(this Url url, IJsonLogger logger)
{
return(new FlurlRequest(url).WithClient(
new FlurlClient().Configure(
client => client.HttpClientFactory = new HttpClientWithDumpingFactory(logger))));
}
/// <summary>
/// Enables request/response dumping to the provided logger.
/// </summary>
/// <param name="flurlRequest">Flurl fluent syntax.</param>
/// <param name="logger">The logger.</param>
/// <returns></returns>
public static IFlurlClient WithDump(this IFlurlClient flurlRequest, IJsonLogger logger)
{
return(flurlRequest.Configure(
client => client.HttpClientFactory = new HttpClientWithDumpingFactory(logger)));
}
/// <summary>
/// Creates logger proxy for the provided scope id.
/// </summary>
/// <param name="logger">The parent logger.</param>
/// <param name="scopeId">Scope identifier.</param>
/// <returns>The scoped logger.</returns>
public static IJsonLogger UseScope(this IJsonLogger logger, object scopeId)
{
return(new ScopedLogger(logger, scopeId));
}
/// <summary>
/// Initializes a new instance of the <see cref="innerLogger"/> class.
/// </summary>
/// <param name="innerLogger">Inner logger.</param>
public SerializerJsonLogger([NotNull] IJsonLogger innerLogger)
{
_innerLogger = innerLogger;
SerializerSource = innerLogger.SerializerSource;
}
/// <summary>
/// Initializes a new instance of the <see cref="ClassJsonLogger{T}"/> class.
/// </summary>
/// <param name="innerLogger">Next logger in chain.</param>
public ClassJsonLogger(IJsonLogger innerLogger)
{
VxArgs.NotNull(innerLogger, nameof(innerLogger));
_innerLogger = innerLogger;
SerializerSource = innerLogger.SerializerSource;
}
/// <summary>
/// Initializes a new instance of the <see cref="PersistenceBase{TPersistence,TUnitOfWork}"/> class.
/// </summary>
/// <param name="logger">Logger for persistence.</param>
/// <remarks>
/// Do not forget to call Initialize method as last operation in the constructor.
/// </remarks>
protected PersistenceBase(IJsonLogger logger)
{
// Do nothing.
Log = new ClassJsonLogger <TPersistence>(logger);
}
