private static void AddTraceIdGenerator(this ILogServiceCollection services)
{
services.AddDependency(s => s.TryAddScoped <FallbackTraceIdAccessor, FallbackTraceIdAccessor>());
if (!ExpectedTraceIdGeneratorName.HasValue())
{
services.AddDependency(s => s.TryAddScoped <ILogTraceIdGenerator, IServiceProvider>(__traceIdGeneratorFactory));
ExpectedTraceIdGeneratorName.Value = nameof(SystemTraceIdGenerator);
}
// ReSharper disable once InconsistentNaming
ILogTraceIdGenerator __traceIdGeneratorFactory(IServiceProvider provider)
{
//1. Get traceIdAccessor and fallbackTraceIdAccessor from ServiceProvider
var traceIdAccessor = provider.GetService <TraceIdAccessor>();
var fallbackAccessor = provider.GetRequiredService <FallbackTraceIdAccessor>();
//2. Create a new instance of SystemTraceIdGenerator
var generator = new SystemTraceIdGenerator(traceIdAccessor, fallbackAccessor);
//3. Scoped update
LogTraceIdGenerator.ScopedUpdate(generator);
//4. Done, and return.
return(generator);
}
}
private static ILogServiceCollection UseExceptionExtensionsCore(this ILogServiceCollection service, IOptions <ExceptionOptions> settings,
Action <IConfiguration, ExceptionConfiguration, LoggingConfiguration> config = null)
{
var exceptionDestructuringAccessor = new ExceptionDestructuringAccessor();
service.AddExtraSinkSettings(settings.Value, config);
service.AddDependency(s => s.TryAddSingleton(settings));
service.AddDependency(s => s.TryAddSingleton <IExceptionDestructuringAccessor>(exceptionDestructuringAccessor));
service.AddEnricher(() => new ExceptionEnricher(exceptionDestructuringAccessor.Get()));
RegisterCoreComponentsTypes();
return(service);
}
public static ILogServiceCollection AddExceptionless(this ILogServiceCollection services, IOptions <ExceptionlessSinkOptions> settings,
Action <IConfiguration, ExceptionlessSinkConfiguration> configAct = null)
{
services.AddSinkSettings <ExceptionlessSinkOptions, ExceptionlessSinkConfiguration>(settings.Value, (conf, sink) => configAct?.Invoke(conf, sink));
services.AddDependency(s => {
s.AddScoped <ILogPayloadClient, ExceptionlessPayloadClient>();
s.AddSingleton <ILogPayloadClientProvider, ExceptionlessPayloadClientProvider>();
s.TryAdd(ServiceDescriptor.Singleton(settings));
});
if (!string.IsNullOrWhiteSpace(settings.Value.OriginConfigFilePath))
{
services.ModifyConfigurationBuilder(b => b.AddFile(settings.Value.OriginConfigFilePath, settings.Value.OriginConfigFileType));
services.AddOriginConfigAction(root => ExceptionlessClient.Default.Configuration.ReadFromConfiguration(root));
}
else if (services.BeGivenConfigurationBuilder || services.BeGivenConfigurationRoot)
{
services.AddOriginConfigAction(root => ExceptionlessClient.Default.Configuration.ReadFromConfiguration(root));
}
if (!string.IsNullOrWhiteSpace(settings.Value.ApiKey))
{
services.AddOriginConfigAction(root => ExceptionlessClient.Default.Startup(settings.Value.ApiKey));
}
else
{
services.AddOriginConfigAction(root => ExceptionlessClient.Default.Startup());
}
RegisterCoreComponentsTypes();
return(services);
}
/// <summary>
/// Register System TraceId generator for Autofac
/// </summary>
/// <param name="services"></param>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
public static ILogServiceCollection RegisterSystemTraceIdGenerator(this ILogServiceCollection services)
{
if (services is null)
{
throw new ArgumentNullException(nameof(services));
}
if (!ExpectedTraceIdGeneratorName.HasValue())
{
services.AddDependency(s => s.AddScoped <ILogTraceIdGenerator, IComponentContext>(__traceIdGeneratorFactory));
ExpectedTraceIdGeneratorName.Value = nameof(SystemTraceIdGenerator);
}
// ReSharper disable once InconsistentNaming
ILogTraceIdGenerator __traceIdGeneratorFactory(IComponentContext provider)
{
//1. Get traceIdAccessor and fallbackTraceIdAccessor from ServiceProvider
var traceIdAccessor = provider.ResolveOptional <TraceIdAccessor>();
var fallbackAccessor = provider.Resolve <FallbackTraceIdAccessor>();
//2. Create a new instance of SystemTraceIdGenerator
var generator = new SystemTraceIdGenerator(traceIdAccessor, fallbackAccessor);
//3. Scoped update
LogTraceIdGenerator.ScopedUpdate(generator);
//4. Done, and return.
return(generator);
}
return(services);
}
private static void RegisterEntityFrameworkInterceptor(ILogServiceCollection services, IOptions <EfEnricherOptions> settings)
{
services.AddDependency(s => s.TryAddSingleton <IServiceProvider>(__efDescriptorFactory, typeof(EfInterceptorDescriptor)));
services.AddDependency(s => s.TryAddSingleton <IServiceProvider>(__efIntegrationFactory, typeof(EfIntegrationActivation)));
// ReSharper disable once InconsistentNaming
object __efDescriptorFactory(IServiceProvider provider)
{
return(new EfInterceptorDescriptor(provider.GetService <ILoggingServiceProvider>(), settings));
}
// ReSharper disable once InconsistentNaming
object __efIntegrationFactory(IServiceProvider provider)
{
return(new EfIntegrationActivation(provider.GetService <EfInterceptorDescriptor>()));
}
}
private static void RegisterCoreComponents(ILogServiceCollection services, IOptions <ConsoleSinkOptions> settings)
{
services.AddDependency(s => {
s.AddScoped <ILogPayloadClient, ConsolePayloadClient>();
s.AddSingleton <ILogPayloadClientProvider, ConsolePayloadClientProvider>();
s.TryAdd(ServiceDescriptor.Singleton(settings));
});
}
private static void RegisterNHibernateInitialization(ILogServiceCollection services, IOptions <NhEnricherOptions> settings)
{
services.AddDependency(s => s.TryAddSingleton <IServiceProvider>(__nhibernateInitFactory, typeof(StaticServiceResolveInitialization)));
// ReSharper disable once InconsistentNaming
object __nhibernateInitFactory(IServiceProvider provider)
{
return(new StaticServiceResolveInitialization(provider.GetRequiredService <ILoggingServiceProvider>(), settings.Value));
}
}
/// <summary>
/// Register Microsoft ASP.NET Core Trace Id generator
/// </summary>
/// <param name="services"></param>
/// <returns></returns>
public static ILogServiceCollection RegisterAspNetCoreTraceIdGenerator(this ILogServiceCollection services)
{
if (!ExpectedTraceIdGeneratorName.HasValue())
{
services.AddDependency(s => s.AddScoped <ILogTraceIdGenerator, AspNetCoreTraceIdGenerator>());
ExpectedTraceIdGeneratorName.Value = nameof(AspNetCoreTraceIdGenerator);
}
return(services);
}
private static void RegisterSqlSugarInterceptor(ILogServiceCollection services, IOptions <SqlSugarEnricherOptions> settings)
{
services.AddDependency(s => s.TryAddSingleton <IServiceProvider>(__sqlsugarInterceptorFactory, typeof(SqlSugarInterceptorDescriptor)));
// ReSharper disable once InconsistentNaming
object __sqlsugarInterceptorFactory(IServiceProvider provider)
{
return(new SqlSugarInterceptorDescriptor(provider.GetService <ILoggingServiceProvider>(), settings));
}
}
private static void RegisterFreeSqlInterceptor(ILogServiceCollection services, IOptions <FreeSqlEnricherOptions> settings)
{
services.AddDependency(s => s.TryAdd(ServiceDescriptor.Singleton(typeof(FreeSqlInterceptorDescriptor), __freesqlInterceptorFactory)));
// ReSharper disable once InconsistentNaming
object __freesqlInterceptorFactory(IServiceProvider provider)
{
return(new FreeSqlInterceptorDescriptor(provider.GetService <ILoggingServiceProvider>(), settings));
}
}
/// <summary>
/// Add CorrelationId Integration
/// </summary>
/// <param name="service"></param>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
public static ILogServiceCollection AddCorrelationIdIntegration(this ILogServiceCollection service)
{
if (service is null)
{
throw new ArgumentNullException(nameof(service));
}
service.AddDependency(s => s.TryAdd(ServiceDescriptor.Scoped <ILogTraceIdGenerator, CorrelationIdGenerator>()));
ExpectedTraceIdGeneratorName.Value = nameof(CorrelationIdGenerator);
return(service);
}
private static void RegisterEntityFrameworkCoreInterceptor(ILogServiceCollection services, IOptions <EfCoreEnricherOptions> settings)
{
services.AddDependency(s => s.TryAddSingleton <IServiceProvider>(__efcoreInterceptorFactory, typeof(EfCoreInterceptorDescriptor)));
// ReSharper disable once InconsistentNaming
object __efcoreInterceptorFactory(IServiceProvider provider)
{
var instance = new EfCoreInterceptorDescriptor(provider.GetService <ILoggingServiceProvider>(), settings);
EfCoreInterceptorDescriptor.Instance = instance;
return(instance);
}
}
private static void RegisterPostgresActivation(ILogServiceCollection services, IOptions <PostgresEnricherOptions> settings)
{
services.AddDependency(s => s.TryAddSingleton <IServiceProvider>(__activationFactory, typeof(NpgsqlLogActivation)));
// ReSharper disable once InconsistentNaming
object __activationFactory(IServiceProvider provider)
{
var implementation = new NpgsqlLogActivation(provider.GetService <ILoggingServiceProvider>(), settings);
implementation.Invoke();
return(implementation);
}
}
/// <summary>
/// Add Tencent Cloud CLS support for Cosmos.Logging
/// </summary>
/// <param name="services"></param>
/// <param name="settings"></param>
/// <param name="configAct"></param>
/// <returns></returns>
public static ILogServiceCollection AddTencentCloudCls(this ILogServiceCollection services, IOptions <TencentCloudClsSinkOptions> settings,
Action <IConfiguration, TencentCloudClsSinkConfiguration> configAct = null)
{
services.AddSinkSettings(settings.Value, configAct);
services.AddDependency(s => {
s.AddScoped <ILogPayloadClient, TencentCloudClsPayloadClient>();
s.AddSingleton <ILogPayloadClientProvider, TencentCloudClsPayloadClientProvider>();
s.TryAddSingleton(settings);
});
RegisterCoreComponentsTypes();
return(services);
}
/// <summary>
/// Add sample log
/// </summary>
/// <param name="services"></param>
/// <param name="settings"></param>
/// <param name="config"></param>
/// <returns></returns>
public static ILogServiceCollection AddSampleLog(this ILogServiceCollection services, IOptions <SampleOptions> settings,
Action <IConfiguration, SampleLogConfiguration> config = null)
{
services.AddSinkSettings <SampleOptions, SampleLogConfiguration>(settings.Value, (conf, sink) => config?.Invoke(conf, sink));
services.AddDependency(s => {
s.AddScoped <ILogPayloadClient, SampleLogPayloadClient>();
s.AddSingleton <ILogPayloadClientProvider, SampleLogPayloadClientProvider>();
s.TryAddSingleton(settings);
});
RegisterCoreComponentsTypes();
return(services);
}
/// <summary>
/// Add TomatoLog for Cosmos.Logging
/// </summary>
/// <param name="services"></param>
/// <param name="settings"></param>
/// <param name="configAct"></param>
/// <returns></returns>
public static ILogServiceCollection AddTomatoLog(this ILogServiceCollection services, IOptions <TomatoLogSinkOptions> settings,
Action <IConfiguration, TomatoLogSinkConfiguration> configAct = null)
{
services.AddSinkSettings <TomatoLogSinkOptions, TomatoLogSinkConfiguration>(settings.Value, (conf, sink) => configAct?.Invoke(conf, sink));
services.AddDependency(s => {
s.AddScoped <ILogPayloadClient, TomatoLogPayloadClient>();
s.AddSingleton <ILogPayloadClientProvider, TomatoLogPayloadClientProvider>();
s.TryAdd(ServiceDescriptor.Singleton(settings));
});
RegisterCoreComponentsTypes();
return(services);
}
/// <summary>
/// Add file log for Cosmos.Logging
/// </summary>
/// <param name="services"></param>
/// <param name="settings"></param>
/// <param name="config"></param>
/// <returns></returns>
public static ILogServiceCollection AddFilelog(this ILogServiceCollection services, IOptions <FileSinkOptions> settings,
Action <IConfiguration, FileSinkLogConfiguration> config = null)
{
services.AddSinkSettings(settings.Value, config);
services.AddDependency(s => {
s.AddScoped <ILogPayloadClient, LocalFileLogPayloadClient>();
s.AddSingleton <ILogPayloadClientProvider, LocalFileLogPayloadClientProvider>();
s.TryAddSingleton(settings);
});
InternalRendererActivation.Action();
RegisterCoreComponentsTypes();
return(services);
}
/// <summary>
/// Add Log4Net support for Cosmos.Logging
/// </summary>
/// <param name="services"></param>
/// <param name="settings"></param>
/// <param name="configAct"></param>
/// <returns></returns>
public static ILogServiceCollection AddLog4Net(this ILogServiceCollection services, IOptions <Log4NetSinkOptions> settings,
Action <IConfiguration, Log4NetSinkConfiguration> configAct = null)
{
services.AddSinkSettings(settings.Value, configAct);
services.AddDependency(s => {
s.AddScoped <ILogPayloadClient, Log4NetPayloadClient>();
s.AddSingleton <ILogPayloadClientProvider, Log4NetPayloadClientProvider>();
s.TryAdd(ServiceDescriptor.Singleton(settings));
});
RegisterNativeConfigurationFile(services, settings);
RegisterCoreComponentsTypes();
return(services);
}
/// <summary>
/// Add exceptionless support for Cosmos.Logging
/// </summary>
/// <param name="services"></param>
/// <param name="settings"></param>
/// <param name="configAct"></param>
/// <returns></returns>
public static ILogServiceCollection AddExceptionless(this ILogServiceCollection services, IOptions <ExceptionlessSinkOptions> settings,
Action <IConfiguration, ExceptionlessSinkConfiguration> configAct = null)
{
services.AddSinkSettings(settings.Value, configAct);
services.AddDependency(s => {
s.AddScoped <ILogPayloadClient, ExceptionlessPayloadClient>();
s.AddSingleton <ILogPayloadClientProvider, ExceptionlessPayloadClientProvider>();
s.TryAdd(ServiceDescriptor.Singleton(settings));
});
RegisterOriginalConfig(services, settings.Value.OriginalConfigFilePath, settings.Value.OriginalConfigFileType);
RegisterApiKey(services, settings.Value.ApiKey);
RegisterCoreComponentsTypes();
return(services);
}
public static ILogServiceCollection AddLog4Net(this ILogServiceCollection services, IOptions <Log4NetSinkOptions> settings,
Action <IConfiguration, Log4NetSinkConfiguration> configAct = null)
{
services.AddSinkSettings <Log4NetSinkOptions, Log4NetSinkConfiguration>(settings.Value, (conf, sink) => configAct?.Invoke(conf, sink));
services.AddDependency(s => {
s.AddScoped <ILogPayloadClient, Log4NetPayloadClient>();
s.AddSingleton <ILogPayloadClientProvider, Log4NetPayloadClientProvider>();
s.TryAdd(ServiceDescriptor.Singleton(settings));
});
if (!string.IsNullOrWhiteSpace(settings.Value.OriginConfigFilePath))
{
services.AddOriginConfigAction(root => InternalUseCustomConfigFilePath(settings.Value.OriginConfigFilePath, settings.Value.WatchOriginConfigFile));
}
RegisterCoreComponentsTypes();
return(services);
}
private static void RegisterCoreComponents(this ILogServiceCollection services)
{
services.AddDependency(s => s.TryAddSingleton <ILoggingServiceProvider, ConsoleLoggingServiceProvider>());
services.AddDependency(s => s.TryAddSingleton <IPropertyFactoryAccessor, ShortcutPropertyFactoryAccessor>());
}
private static void RegisterLoggerFactory(this ILogServiceCollection services)
{
services.AddDependency(s => s.TryAddSingleton <ILoggerFactory, IServiceProvider>(
provider => new MicrosoftLoggerFactory(provider.GetService <ILoggingServiceProvider>())));
}
private static void RegisterTraceIdGenerator(this ILogServiceCollection services)
{
services.AddDependency(s => s.TryAddScoped <FallbackTraceIdAccessor, FallbackTraceIdAccessor>());
}
public static void AppendOrOverride(this ILogServiceCollection services)
{
services.AddDependency(s => s.TryAddSingleton <ILoggingServiceProvider, HostingLoggingServiceProvider>());
}
private static ILogServiceCollection RegisterToRunsOnConsole(this ILogServiceCollection services)
{
services.AddDependency(s => s.AddSingleton <ILoggingServiceProvider, ConsoleLoggingServiceProvider>());
services.AddDependency(s => s.AddSingleton <IPropertyFactoryAccessor, ShortcutPropertyFactoryAccessor>());
return(services);
}
private static ILogServiceCollection RegisterToRunsOnConsole(this ILogServiceCollection services)
{
return(services.AddDependency(s => s.AddSingleton <ILoggingServiceProvider, ConsoleLoggingServiceProvider>()));
}
private static void RegisterCoreComponents(this ILogServiceCollection services)
{
services.AddDependency(s => s.TryAddSingleton <ILoggingServiceProvider, StandardLogServiceProvider>());
services.AddDependency(s => s.TryAddSingleton <IPropertyFactoryAccessor, ShortcutPropertyFactoryAccessor>());
services.AddDependency(s => s.TryAddSingleton(typeof(ILogger <>), typeof(MicrosoftLoggerAdapter <>)));
}