public ApplicationInsightLoggerFactory(
LogLevelEnum defaultMinimumLogLevel,
IFullyQualifiedName defaultLoggerSource)
{
_defaultMinimumLogLevel = defaultMinimumLogLevel;
_defaultLoggerSource = defaultLoggerSource;
}
public static IDependencyResolver UseAzureApplicationInsightsLogger(
this IDependencyResolver dependencyResolver,
LogLevelEnum defaultMinimumLogLevel = LogLevelEnum.Warning,
IFullyQualifiedName defaultLoggerSource = null)
{
return dependencyResolver
.Register<ILoggerFactory>(() => new ApplicationInsightLoggerFactory(defaultMinimumLogLevel, defaultLoggerSource))
.Register(() => new ApplicationInsightLoggerFactory(defaultMinimumLogLevel, defaultLoggerSource).CreateLogger());
}
public global::Serilog.ILogger CreateSerilog(IFullyQualifiedName source, LogLevelEnum? minimumLogLevel = null)
{
LoggerConfiguration loggerConfiguration = GetLoggerConfiguration(minimumLogLevel);
source = source ?? _defaultLoggerSource;
if (source != null)
{
loggerConfiguration.Enrich.With(new FullyQualifiedNameEnricher(source, _sourceFqnPropertyName));
}
return new LoggerFacade(loggerConfiguration.CreateLogger());
}
public ILogger CreateLogger(IFullyQualifiedName source, LogLevelEnum? minimumLogLevel = null)
{
return new AzureQueueLogger.Implementation.QueueLogger(_runtimeEnvironment,
GetQueue(),
_queueSerializer,
source ?? _defaultLoggerSource,
_queueLoggerExtension,
minimumLogLevel.GetValueOrDefault(_defaultMinimumLogLevel),
_correlationIdProvider);
}
/// <summary>
/// Register Serilog as the frameworks default logger.
/// </summary>
/// <param name="dependencyResolver">Dependency resolver to register Serilog in</param>
/// <param name="configurationProvider">A function that returns a SeriLog LoggerConfiguration class.
/// If null then Serilog is configured to write using the Trace sink. Note that a LoggerConfiguration returned from this function
/// will be further annotated with a minimum log level and property enrichment for correlation ID and source. If you don't want
/// any of that then use the CreateSerilog(LoggerConfiguration loggerConfiguration) on ISerilogFactory</param>
/// <param name="defaultMinimumLogLevel">The default minimum log level for loggers created by the factory</param>
/// <param name="defaultLoggerSource">The component source to use for a logger when no source is specified - defaults to null.</param>
/// <param name="sourceFqnPropertyName">The Serilog property name for the source component fully qualified name</param>
/// <param name="correlationIdPropertyName">The Serilog property name for the correlation ID</param>
/// <returns></returns>
public static IDependencyResolver UseSerilog(this IDependencyResolver dependencyResolver,
Func<LoggerConfiguration> configurationProvider = null,
LogLevelEnum defaultMinimumLogLevel = LogLevelEnum.Warning,
IFullyQualifiedName defaultLoggerSource = null,
string sourceFqnPropertyName = "SourceFqn",
string correlationIdPropertyName = "CorrelationId")
{
return dependencyResolver
.Register<ILoggerFactory>(() => new SerilogFactory(configurationProvider, dependencyResolver.Resolve<ICorrelationIdProvider>(), defaultMinimumLogLevel, defaultLoggerSource, sourceFqnPropertyName, correlationIdPropertyName))
.Register<ISerilogFactory>(() => new SerilogFactory(configurationProvider, dependencyResolver.Resolve<ICorrelationIdProvider>(), defaultMinimumLogLevel, defaultLoggerSource, sourceFqnPropertyName, correlationIdPropertyName))
.Register(() => new SerilogFactory(configurationProvider, dependencyResolver.Resolve<ICorrelationIdProvider>(), defaultMinimumLogLevel, defaultLoggerSource, sourceFqnPropertyName, correlationIdPropertyName).CreateLogger())
.Register(() => new SerilogFactory(configurationProvider, dependencyResolver.Resolve<ICorrelationIdProvider>(), defaultMinimumLogLevel, defaultLoggerSource, sourceFqnPropertyName, correlationIdPropertyName).CreateSerilog());
}
/// <summary>
/// Register the dependencies in a container
/// </summary>
/// <param name="container">The container to use</param>
/// <param name="correlationIdKey">The correlation ID key. Defaults to correlation-id</param>
/// <param name="defaultTraceLoggerMinimumLogLevel"></param>
/// <param name="defaultLoggerSource">The component source to use for a default logger when no source is specified - defaults to null.</param>
public static IDependencyResolver UseCore(
this IDependencyResolver container,
string correlationIdKey = "correlation-id",
LogLevelEnum defaultTraceLoggerMinimumLogLevel = LogLevelEnum.Warning,
IFullyQualifiedName defaultLoggerSource = null)
{
Func<ICorrelationIdProvider> createCorrelationIdProvider;
if (!string.IsNullOrWhiteSpace(correlationIdKey))
{
createCorrelationIdProvider = () => new CallContextCorrelationIdProvider(correlationIdKey);
}
else
{
createCorrelationIdProvider = () => new NullCorrelationIdProvider();
}
return container
.Register<IAsynchronousDelay, AsynchronousDelay>()
.Register<ITimerThreadPoolExecuter, TimerThreadPoolExecuter>()
.Register<ITimerFactory, TimerFactory>()
.Register<IBackoffPolicy, BackoffPolicy>()
.Register<IBackoffPolicyTimingProvider, BackoffPolicyDefaultTimingProvider>()
.Register<IAsynchronousBackoffPolicy, AsynchronousBackoffPolicy>()
.Register<IBackoffPolicyFactory, BackoffPolicyFactory>()
.Register<ILeasedRetry, LeasedRetry>()
.Register<IWaitHandle, ManualResetEventWaitHandle>()
.Register<IApplicationResourceSettingNameProvider, ApplicationResourceSettingNameProvider>()
.Register<IAsyncApplicationResourceSettingProvider, AsyncApplicationResourceSettingProvider>()
.Register<IAsyncApplicationResourceFactory, AsyncApplicationResourceFactory>()
.Register<IApplicationResourceFactory, ApplicationResourceFactory>()
.Register<IApplicationResourceSettingProvider, ApplicationResourceSettingProvider>()
.Register<IQueueFactory, NotSupportedQueueFactory>()
.Register<ILeaseManagerFactory, NotSupportedLeaseManagerFactory>()
.Register<IBlobRepositoryFactory, NotSupportedBlobRepositoryFactory>()
.Register(createCorrelationIdProvider)
.Register<ILoggerFactory>(() => new TraceLoggerFactory(defaultTraceLoggerMinimumLogLevel, defaultLoggerSource))
.Register(() => new TraceLoggerFactory(defaultTraceLoggerMinimumLogLevel, defaultLoggerSource).CreateLogger())
.Register(() => new TraceLoggerFactory(defaultTraceLoggerMinimumLogLevel, defaultLoggerSource).CreateAsynchronousLogger(defaultTraceLoggerMinimumLogLevel))
.Register<IComponentHost, ComponentHost>()
.Register<IEmailQueueDispatcher, EmailQueueDispatcher>()
.Register<IUnitOfWorkFactoryProvider, NotSupportedUnitOfWorkFactoryProvider>()
.Register<IRuntimeEnvironment, DefaultRuntimeEnvironment>()
.Register<IConfiguration>(() => new DefaultConfiguration())
.Register<IAsyncConfiguration>(() => new DefaultAsyncConfiguration())
.Register<IComponentFactory>(() => new ComponentFactory(container))
.Register<IComponentHostRestartHandler, DefaultComponentHostRestartHandler>()
.Register<ILargeMessageQueueFactory, LargeMessageQueueFactory>()
// internal
.Register<ICoreAssemblyLogger>(() =>
new CoreAssemblyLogger(container.Resolve<ILoggerFactory>().CreateLogger(new LoggerSource("AccidentalFish.ApplicationSupport.Core"))));
}
public SerilogFactory(Func<LoggerConfiguration> loggerConfigurationProvider,
ICorrelationIdProvider correlationIdProvider,
LogLevelEnum defaultMinimumLogLevel,
IFullyQualifiedName defaultLoggerSource,
string sourceFqnPropertyName,
string correlationIdPropertyName)
{
_loggerConfigurationProvider = loggerConfigurationProvider;
_correlationIdProvider = correlationIdProvider;
_defaultMinimumLogLevel = defaultMinimumLogLevel;
_defaultLoggerSource = defaultLoggerSource;
_sourceFqnPropertyName = sourceFqnPropertyName;
_correlationIdPropertyName = correlationIdPropertyName;
}
private static ILoggerFactory GetLoggerFactory(
IDependencyResolver dependencyResolver,
LogLevelEnum defaultMinimumLogLevel,
IFullyQualifiedName defaultLoggerSource)
{
IRuntimeEnvironment runtimeEnvironment = dependencyResolver.Resolve<IRuntimeEnvironment>();
IConfiguration configuration = dependencyResolver.Resolve<IConfiguration>();
IQueueLoggerExtension queueLoggerExtension = dependencyResolver.Resolve<IQueueLoggerExtension>();
ICorrelationIdProvider correlationIdProvider = dependencyResolver.Resolve<ICorrelationIdProvider>();
IQueueSerializer queueSerializer = dependencyResolver.Resolve<IQueueSerializer>();
IApplicationResourceSettingNameProvider nameProvider = dependencyResolver.Resolve<IApplicationResourceSettingNameProvider>();
return new QueueLoggerFactory(runtimeEnvironment, nameProvider, configuration, queueSerializer, queueLoggerExtension,
correlationIdProvider, defaultMinimumLogLevel, defaultLoggerSource);
}
public static IDependencyResolver UseQueueLogger(this IDependencyResolver dependencyResolver,
Type loggerExtension = null,
LogLevelEnum defaultMinimumLogLevel = LogLevelEnum.Warning,
IFullyQualifiedName defaultLoggerSource = null)
{
if (loggerExtension == null)
{
loggerExtension = typeof (NullQueueLoggerExtension);
}
return dependencyResolver
.Register(typeof (IQueueLoggerExtension), loggerExtension)
.Register(() => GetLoggerFactory(dependencyResolver, defaultMinimumLogLevel, defaultLoggerSource))
.Register(() => GetLoggerFactory(dependencyResolver, defaultMinimumLogLevel, defaultLoggerSource).CreateLogger())
.Register(() => GetLoggerFactory(dependencyResolver, defaultMinimumLogLevel, defaultLoggerSource).CreateAsynchronousLogger());
}
public QueueLoggerFactory(
IRuntimeEnvironment runtimeEnvironment,
IApplicationResourceSettingNameProvider nameProvider,
IConfiguration configuration,
IQueueSerializer queueSerializer,
IQueueLoggerExtension queueLoggerExtension,
ICorrelationIdProvider correlationIdProvider,
LogLevelEnum defaultMinimumLogLevel,
IFullyQualifiedName defaultLoggerSource)
{
_runtimeEnvironment = runtimeEnvironment;
_queueSerializer = queueSerializer;
_queueLoggerExtension = queueLoggerExtension;
_correlationIdProvider = correlationIdProvider;
_defaultMinimumLogLevel = defaultMinimumLogLevel;
_defaultLoggerSource = defaultLoggerSource;
_queueName = configuration[nameProvider.SettingName(ApplicationSupportComponentIdentity, "logger-queue")];
_storageAccountConnectionString = configuration[nameProvider.StorageAccountConnectionString(ApplicationSupportComponentIdentity)];
}
public ILogger CreateLongLivedLogger(IFullyQualifiedName source)
{
return CreateShortLivedLogger(source);
// TODO: throw new NotImplementedException("Work in progress - this will be a self refreshing minimum log level component");
}
public ILogger CreateShortLivedLogger(IAsynchronousQueue<LogQueueItem> queue, IFullyQualifiedName source, LogLevelEnum minimumLogLevel)
{
return new Logger(_runtimeEnvironment, queue, source, _loggerExtension, GetMinimumLogLevel(source), _correlationIdProvider);
}
public ILogger CreateShortLivedLogger(IFullyQualifiedName source)
{
return new Logger(_runtimeEnvironment, _applicationResourceFactory.GetLoggerQueue(), source, _loggerExtension, GetMinimumLogLevel(source), _correlationIdProvider);
}
public FullyQualifiedNameEnricher(IFullyQualifiedName source, string propertyName)
{
_source = source;
_propertyName = propertyName;
}
public FullyQualifiedNameEnricher(IFullyQualifiedName source) : this(source, "SourceFqn")
{
}
public ILogger CreateLongLivedLogger(IAsynchronousQueue<LogQueueItem> queue, IFullyQualifiedName source, LogLevelEnum minimumLogLevel)
{
return new ApplicationInsightLogger(source, minimumLogLevel);
}
public IAsynchronousLogger CreateAsynchronousLogger(IFullyQualifiedName source, LogLevelEnum? minimumLogLevel)
{
return new ConsoleAsynchronousLogger(source ?? _defaultLoggerSource, minimumLogLevel.GetValueOrDefault(_defaultMinimumLoggingLevel));
}
public ILogger CreateShortLivedLogger(IFullyQualifiedName source)
{
return new ConsoleLogger();
}
public ILogger CreateLongLivedLogger(IAsynchronousQueue<LogQueueItem> queue, IFullyQualifiedName source, LogLevelEnum minimumLogLevel)
{
return new ConsoleLogger();
}
public ILogger CreateLogger(IFullyQualifiedName source, LogLevelEnum? minimumLogLevel = null)
{
return new TraceLogger(source ?? _defaultLoggerSource, minimumLogLevel.GetValueOrDefault(_defaultMinimumLogLevel));
}
public static IDependencyResolver UseConsoleLogger(this IDependencyResolver dependencyResolver,
LogLevelEnum defaultMinimumLogLevel = LogLevelEnum.Warning,
IFullyQualifiedName defaultLoggerSource = null)
{
return dependencyResolver.Register<ILoggerFactory>(() => new ConsoleLoggerFactory(defaultMinimumLogLevel, defaultLoggerSource));
}
public ApplicationInsightLogger(IFullyQualifiedName fullyQualifiedName, LogLevelEnum minimumLogLevel)
{
_fullyQualifiedName = fullyQualifiedName;
_minimumLogLevel = minimumLogLevel;
}
public ILogger CreateLongLivedLogger(IAsynchronousQueue<LogQueueItem> queue, IFullyQualifiedName source, LogLevelEnum minimumLogLevel)
{
return CreateLongLivedLogger(queue, source, minimumLogLevel);
// TODO: throw new NotImplementedException("Work in progress - this will be a self refreshing minimum log level component");
}
public ILogger CreateLogger(IFullyQualifiedName source, LogLevelEnum? minimumLogLevel = null)
{
return new ApplicationInsightLogger(source ?? _defaultLoggerSource, GetMinimumLogLevel(minimumLogLevel));
}
private LogLevelEnum GetMinimumLogLevel(IFullyQualifiedName source)
{
// TODO: Pick this up from the realtime settings
return LogLevelEnum.Debug;
}
public TraceAsynchronousLogger(IFullyQualifiedName source, LogLevelEnum minimumLogLevel)
{
_source = source;
_minimumLogLevel = minimumLogLevel;
}
public ConsoleLogger(IFullyQualifiedName source, LogLevelEnum minimumLogLevel)
{
_source = source;
_minimumLogLevel = minimumLogLevel;
}
public ILogger CreateShortLivedLogger(IFullyQualifiedName source)
{
return new ApplicationInsightLogger(source, LogLevelEnum.Warning);
}
public TraceLoggerFactory(LogLevelEnum defaultMinimumLogLevel, IFullyQualifiedName defaultLoggerSource)
{
_defaultMinimumLogLevel = defaultMinimumLogLevel;
_defaultLoggerSource = defaultLoggerSource;
}
public ICircuitBreaker Create(IFullyQualifiedName fullyQualifiedName)
{
ICircuitBreakerStateStore stateStore = _stateStores.GetOrAdd(fullyQualifiedName, fqn => new InMemoryCircuitBreakerStateStore());
return new CircuitBreaker(stateStore);
}
