private void ReloadLoggerOptions(ConsoleLoggerOptions?options)
{
foreach (var logger in _loggers)
{
logger.Value.Options = options;
}
_optionsReloadToken = _options?.OnChange(ReloadLoggerOptions);
}
public Writable(
IHostEnvironment environment,
IOptionsMonitor <T> options,
string sectionPath,
string file)
{
_environment = environment;
_options = options;
_section = sectionPath;
_file = file;
_options?.OnChange((settings, path) =>
{
Console.WriteLine(path);
});
}
/// <summary>Keeps the validating.</summary>
/// <param name="monitor">The monitor.</param>
public void KeepValidating(IOptionsMonitor <object> monitor)
{
monitor?.OnChange(o =>
{
var settingType = monitor.GetType().GetGenericArguments().SingleOrDefault();
if (settingType == null)
{
return;
}
var result = Validate(Validators[settingType], o, settingType);
if (!result.IsValid)
{
throw new ValidationException(result, o.GetType(),
"Changed variable caused ValidationFailure.");
}
});
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app,
IHostingEnvironment env,
ILoggerFactory loggerFactory, IOptionsMonitor <Settings> monitor)
{
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug();
app
.UseMinionInject()
.UseMvc();
monitor.OnChange(
vals =>
{
loggerFactory
.CreateLogger <IOptionsMonitor <Settings> >()
.LogDebug($"Config changed: {string.Join(", ", vals)}");
});
}
public DefaultSecretManagerProvider(IOptionsMonitor <ScriptApplicationHostOptions> options, IHostIdProvider hostIdProvider,
IConfiguration configuration, IEnvironment environment, ILoggerFactory loggerFactory)
{
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
_options = options ?? throw new ArgumentNullException(nameof(options));
_hostIdProvider = hostIdProvider ?? throw new ArgumentNullException(nameof(hostIdProvider));
_configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
_environment = environment ?? throw new ArgumentNullException(nameof(environment));
_logger = loggerFactory.CreateLogger(ScriptConstants.LogCategoryHostGeneral);
_secretManagerLazy = new Lazy <ISecretManager>(Create);
// When these options change (due to specialization), we need to reset the secret manager.
options.OnChange(_ => ResetSecretManager());
}
public ScanWorkflowCommandHandler(IEntitiesRepository entitiesRepository,
IClusterStateService clusterStateService,
ILogger <ScanWorkflowCommandHandler> logger,
IOptionsMonitor <CindiClusterOptions> options,
IMediator mediator,
IClusterRequestHandler node
)
{
_entitiesRepository = entitiesRepository;
_clusterStateService = clusterStateService;
Logger = logger;
_option = options.CurrentValue;
options.OnChange((change) =>
{
_option = change;
});
_mediator = mediator;
_node = node;
}
public ModuleCatalogManager(
ILogger <ModuleCatalogManager> logger,
IOptionsMonitor <ModuleCatalogOptions> optionsMonitor,
IServiceProvider serviceProvider
)
{
this.logger = logger;
this.optionsMonitor = optionsMonitor;
this.serviceProvider = serviceProvider;
mode = optionsMonitor.CurrentValue.Mode;
optionsMonitor.OnChange(opt =>
{
mode = opt.Mode;
});
catalogCache = new SortedList <ModuleIdentifier, ConfigCatalog>();
}
public BackOfficeServerVariables(
LinkGenerator linkGenerator,
IRuntimeState runtimeState,
UmbracoFeatures features,
IOptionsMonitor <GlobalSettings> globalSettings,
IUmbracoVersion umbracoVersion,
IOptionsMonitor <ContentSettings> contentSettings,
IHttpContextAccessor httpContextAccessor,
TreeCollection treeCollection,
IHostingEnvironment hostingEnvironment,
IOptionsMonitor <RuntimeSettings> runtimeSettings,
IOptionsMonitor <SecuritySettings> securitySettings,
IRuntimeMinifier runtimeMinifier,
IBackOfficeExternalLoginProviders externalLogins,
IImageUrlGenerator imageUrlGenerator,
PreviewRoutes previewRoutes,
IEmailSender emailSender,
IOptionsMonitor <MemberPasswordConfigurationSettings> memberPasswordConfigurationSettings)
{
_linkGenerator = linkGenerator;
_runtimeState = runtimeState;
_features = features;
_globalSettings = globalSettings.CurrentValue;
_umbracoVersion = umbracoVersion;
_contentSettings = contentSettings.CurrentValue ?? throw new ArgumentNullException(nameof(contentSettings));
_httpContextAccessor = httpContextAccessor;
_treeCollection = treeCollection ?? throw new ArgumentNullException(nameof(treeCollection));
_hostingEnvironment = hostingEnvironment;
_runtimeSettings = runtimeSettings.CurrentValue;
_securitySettings = securitySettings.CurrentValue;
_runtimeMinifier = runtimeMinifier;
_externalLogins = externalLogins;
_imageUrlGenerator = imageUrlGenerator;
_previewRoutes = previewRoutes;
_emailSender = emailSender;
_memberPasswordConfigurationSettings = memberPasswordConfigurationSettings.CurrentValue;
globalSettings.OnChange(x => _globalSettings = x);
contentSettings.OnChange(x => _contentSettings = x);
runtimeSettings.OnChange(x => _runtimeSettings = x);
securitySettings.OnChange(x => _securitySettings = x);
memberPasswordConfigurationSettings.OnChange(x => _memberPasswordConfigurationSettings = x);
}
/// <summary>
/// Initializes a new instance of the <see cref="Notifier" /> class.
/// </summary>
public Notifier(
IBackOfficeSecurityAccessor backOfficeSecurityAccessor,
IHostingEnvironment hostingEnvironment,
INotificationService notificationService,
IUserService userService,
ILocalizedTextService textService,
IOptionsMonitor <GlobalSettings> globalSettings,
ILogger <Notifier> logger)
{
_backOfficeSecurityAccessor = backOfficeSecurityAccessor;
_hostingEnvironment = hostingEnvironment;
_notificationService = notificationService;
_userService = userService;
_textService = textService;
_globalSettings = globalSettings.CurrentValue;
_logger = logger;
globalSettings.OnChange(x => _globalSettings = x);
}
/// <summary>
/// Initializes a new instance of the <see cref="LogScrubber"/> class.
/// </summary>
/// <param name="mainDom">Representation of the main application domain.</param>
/// <param name="serverRegistrar">Provider of server registrations to the distributed cache.</param>
/// <param name="auditService">Service for handling audit operations.</param>
/// <param name="settings">The configuration for logging settings.</param>
/// <param name="scopeProvider">Provides scopes for database operations.</param>
/// <param name="logger">The typed logger.</param>
/// <param name="profilingLogger">The profiling logger.</param>
public LogScrubber(
IMainDom mainDom,
IServerRoleAccessor serverRegistrar,
IAuditService auditService,
IOptionsMonitor <LoggingSettings> settings,
IScopeProvider scopeProvider,
ILogger <LogScrubber> logger,
IProfilingLogger profilingLogger)
: base(logger, TimeSpan.FromHours(4), DefaultDelay)
{
_mainDom = mainDom;
_serverRegistrar = serverRegistrar;
_auditService = auditService;
_settings = settings.CurrentValue;
_scopeProvider = scopeProvider;
_logger = logger;
_profilingLogger = profilingLogger;
settings.OnChange(x => _settings = x);
}
/// <summary>
/// workaround for multiple OnChange calls when a monitored options value changes
/// (this is due to a problem with the way that file change notifications work - will Microsoft fix this?)
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="optionsMonitor"></param>
/// <param name="action"></param>
/// <param name="delay">in milliseconds, default value is 2000</param>
public static void OnChangeWithDelay <T>(this IOptionsMonitor <T> optionsMonitor, Action <T> action, int delay = 2000)
{
bool changeDelayStarted = false;
optionsMonitor.OnChange(async(opt) =>
{
if (!changeDelayStarted)
{
changeDelayStarted = true;
await Task.Run(async() =>
{
await Task.Delay(TimeSpan.FromMilliseconds(delay));
action(opt);
changeDelayStarted = false;
});
}
//Debug.WriteLine("OnChangeWithDelay");
});
}
public ClsWriter(IOptionsMonitor <ClsOptions> options, ILoggerFactory loggerFactory)
{
_settings = options.CurrentValue;
_loggerFactory = loggerFactory;
options.OnChange(setting =>
{
_settings = setting;
});
var ipv4s = Utils.IpUtils.GetIpv4s();
if (ipv4s?.Count > 0)
{
_hostIpOrName = string.Join(";", ipv4s);
}
else
{
_hostIpOrName = Environment.MachineName;
}
}
public HomeController(
ILogger <HomeController> logger,
IConfiguration configuration,
IOptions <DbConfigOptions> dbOptions,
IOptionsSnapshot <DbConfigOptions> dbOptionsSnapshot,
IOptionsMonitor <DbConfigOptions> dbOptionsMonitor,
IConfigClient configClient)
{
_logger = logger;
_IConfigClient = configClient;
_IConfiguration = configuration;
_dbOptions = dbOptions;
_dbOptionsSnapshot = dbOptionsSnapshot;
_dbOptionsMonitor = dbOptionsMonitor;
_dbOptionsMonitor.OnChange((o, s) => {
Console.WriteLine(o.connection);
Console.WriteLine(s);
});
}
/// <summary>
/// Creates an instance of <see cref="ConsoleLoggerProvider"/>.
/// </summary>
/// <param name="options">The options to create <see cref="ConsoleLogger"/> instances with.</param>
public ConsoleLoggerProvider(IOptionsMonitor <ConsoleLoggerOptions> options)
{
_options = options;
_loggers = new ConcurrentDictionary <string, ConsoleLogger>();
ReloadLoggerOptions(options.CurrentValue);
_optionsReloadToken = _options.OnChange(ReloadLoggerOptions);
_messageQueue = new ConsoleLoggerProcessor();
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
_messageQueue.Console = new WindowsLogConsole();
_messageQueue.ErrorConsole = new WindowsLogConsole(stdErr: true);
}
else
{
_messageQueue.Console = new AnsiLogConsole(new AnsiSystemConsole());
_messageQueue.ErrorConsole = new AnsiLogConsole(new AnsiSystemConsole(stdErr: true));
}
}
/// <summary>
/// 构造函数
/// </summary>
public CloudLoggerProvider(IOptionsMonitor <CloudLoggerOption> options) : base(null, new Func <string, LogLevel, bool>((name, logLevel) => logLevel >= LogLevel.Error))
{
optionsReloadToken = options.OnChange(op => option = op);
option = options.CurrentValue;
httpClient = new HttpClient
{
Timeout = TimeSpan.FromSeconds(10)
};
httpClient.DefaultRequestHeaders.Connection.Add("keep-alive");
LogCallback = new Action <string>(async message =>
{
if (!string.IsNullOrEmpty(option.Url))
{
try { await httpClient.PostAsJsonAsync(option.Url, message).ConfigureAwait(false); }
catch { }
}
});
}
public CertificateRenewalService(
CertificateSelector certificateSelector,
IOptionsMonitor <LetsEncryptOptions> letsEncryptOptions,
ICertificateStore certificateStore,
ILetsEncryptService letsEncryptService,
IOptionsMonitor <TimedHostedServiceOptions> options,
IEnumerable <ITimedHostedLifeCycleHook> lifeCycleHooks,
ILogger <ITimedHostedService> logger) : base(options, lifeCycleHooks, logger)
{
_certificateSelector = certificateSelector ?? throw new System.ArgumentNullException(nameof(certificateSelector));
_options = letsEncryptOptions.CurrentValue;
letsEncryptOptions.OnChange(newOptions => _options = newOptions);
_letsEncryptService = letsEncryptService ?? throw new System.ArgumentNullException(nameof(letsEncryptService));
_logger = logger ?? throw new System.ArgumentNullException(nameof(logger));
_certificateStore = certificateStore ?? throw new System.ArgumentNullException(nameof(certificateStore));
TaskToExecuteAsync = (token) => RequestCertificate(token);
}
//private readonly IOptionsMonitor<GreetingConfiguration> _greetingConfiguration;
public GreetingService(
IWebHostEnvironment webHostEnvironment,
ILogger <GreetingConfiguration> logger,
IOptionsMonitor <GreetingConfiguration> options)
{
var webRootPath = webHostEnvironment.WebRootPath;
var greetingsJson = System.IO.File.ReadAllText(webRootPath + "/greetings.json");
var greetingsData = JsonConvert.DeserializeObject <GreetingData>(greetingsJson);
Greetings = greetingsData.Greetings;
LoginGreetings = greetingsData.LoginGreetings;
_greetingConfiguration = options.CurrentValue;
options.OnChange(config =>
{
_greetingConfiguration = config;
logger.LogInformation("The greeting configuration has been updated.");
});
}
protected BatchingLoggerProvider(IOptionsMonitor <BatchingLoggerOptions> options)
{
var loggerOptions = options.CurrentValue;
if (loggerOptions.BatchSize <= 0)
{
throw new ArgumentOutOfRangeException(nameof(loggerOptions.BatchSize), $"{nameof(loggerOptions.BatchSize)} must be a positive number.");
}
if (loggerOptions.FlushPeriod <= TimeSpan.Zero)
{
throw new ArgumentOutOfRangeException(nameof(loggerOptions.FlushPeriod), $"{nameof(loggerOptions.FlushPeriod)} must be longer than zero.");
}
_interval = loggerOptions.FlushPeriod;
_batchSize = loggerOptions.BatchSize;
_queueSize = loggerOptions.BackgroundQueueSize;
_optionsChangeToken = options.OnChange(UpdateOptions);
UpdateOptions(options.CurrentValue);
}
/// <summary>
/// Initializes a new instance of the <see cref="TorahService"/> class.
/// </summary>
/// <param name="httpClient"></param>
/// <param name="options"></param>
public TorahService(
HttpClient httpClient,
IOptionsMonitor <TorahQuoteJobOptions> options)
{
_options = options.Get(nameof(TorahQuoteJob));
// updates on providers change
options.OnChange((opt, n) =>
{
if (n == nameof(TorahQuoteJob))
{
_options = opt;
}
});
httpClient.DefaultRequestHeaders.Add("Accept", "application/json");
httpClient.DefaultRequestHeaders.Add("User-Agent", nameof(TorahService));
Client = httpClient;
}
/// <summary>
/// Creates a new instance of <see cref="SmtpService"/>.
/// </summary>
/// <param name="logger">The <see cref="ILogger"/>.</param>
/// <param name="smtpSettings">The <see cref="IOptionsMonitor{TOptions}"/>.</param>
public SmtpService(ILogger <SmtpService> logger, IOptionsMonitor <Smtp> smtpSettings)
{
smtp = new Smtp();
this.logger = logger;
client = new SmtpClient();
Task.Run(async() => await ConfigureAsync(smtpSettings.CurrentValue));
// Adds an event listener for when 'appsettings.json' changes
optionsListener = smtpSettings.OnChange(async(change) =>
{
// Wait for an update to finish
// before invoking another one
if (configureTask is Task)
{
await configureTask;
}
configureTask = ConfigureAsync(change);
});
}
public SoapRequestMiddleware(
MessageVersion version,
IOptionsMonitor <SoapServiceOptions> monitor,
ILoggerFactory loggerFactory,
RequestDelegate next)
{
var type = typeof(TService);
_version = version;
_options = monitor.Get(type.FullName);
_optionsChangeToken = monitor.OnChange((options, name) =>
{
if (name == type.FullName)
{
_options = options;
}
});
_logger = loggerFactory.CreateLogger("Solid.Extensions.AspNetCore.Soap.Middleware.SoapRequestMiddleware");
_next = next;
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, IOptionsMonitor <MyOptions> optionsMonitor, ILogger <Startup> logger)
{
optionsMonitor
.OnChange((o) =>
{
logger.LogDebug($"option changed to {o.MyValue}");
}
);
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseHsts();
}
//app.UseHttpsRedirection();
app.UseMvc();
}
// private readonly string _memberName;
public OptionsItemChangesMonitor(
IOptionsMonitor <TOptions> optionsMonitor,
ILogger <OptionsItemChangesMonitor <TKey, TOptions, TOptionsItem> > logger,
IEnumerable <KeyedItemsAccessor <TOptions, TOptionsItem, TKey> > itemAccessors
)
{
// _optionsMonitor = optionsMonitor;
_instance = optionsMonitor.CurrentValue;
_logger = logger;
_itemAccessors = itemAccessors.ToList();
// _itemsAccessor = itemsAccessor;
_differ = new OptionsItemsDiffer <TKey, TOptions, TOptionsItem>();
// _itemAccessorExpression.Body.pro
var debouncer = new Debouncer(TimeSpan.FromMilliseconds(500));
_listening = optionsMonitor.OnChange((a) => debouncer.Debouce(() => OnChanged(a)));
}
public ElasticsearchLoggerProvider(IOptionsMonitor <ElasticsearchLoggerOptions> options,
IEnumerable <IChannelSetup> channelConfigurations
)
{
_options = options ?? throw new ArgumentNullException(nameof(options));
if (channelConfigurations is null)
{
throw new ArgumentNullException(nameof(channelConfigurations));
}
_channelConfigurations = channelConfigurations.ToArray();
var channelOptions = CreateChannelOptions(options.CurrentValue, _channelConfigurations);
_shipper = new ElasticsearchChannel <LogEvent>(channelOptions);
ReloadLoggerOptions(options.CurrentValue);
_optionsReloadToken = _options.OnChange(o => ReloadLoggerOptions(o));
}
/// <summary>
/// Creates a new <see cref="LoggerFactory"/> instance.
/// </summary>
/// <param name="providers">The providers to use in producing <see cref="ILogger"/> instances.</param>
/// <param name="filterOption">The filter option to use.</param>
/// <param name="options">The <see cref="LoggerFactoryOptions"/>.</param>
public LoggerFactory(IEnumerable <ILoggerProvider> providers, IOptionsMonitor <LoggerFilterOptions> filterOption, IOptions <LoggerFactoryOptions> options = null)
{
_factoryOptions = options == null || options.Value == null ? new LoggerFactoryOptions() : options.Value;
const ActivityTrackingOptions ActivityTrackingOptionsMask = ~(ActivityTrackingOptions.SpanId | ActivityTrackingOptions.TraceId | ActivityTrackingOptions.ParentId |
ActivityTrackingOptions.TraceFlags | ActivityTrackingOptions.TraceState);
if ((_factoryOptions.ActivityTrackingOptions & ActivityTrackingOptionsMask) != 0)
{
throw new ArgumentException(SR.Format(SR.InvalidActivityTrackingOptions, _factoryOptions.ActivityTrackingOptions), nameof(options));
}
foreach (ILoggerProvider provider in providers)
{
AddProviderRegistration(provider, dispose: false);
}
_changeTokenRegistration = filterOption.OnChange(RefreshFilters);
RefreshFilters(filterOption.CurrentValue);
}
/// <summary>
/// Initializes a new instance of the <see cref="KeepAlive"/> class.
/// </summary>
/// <param name="hostingEnvironment">The current hosting environment</param>
/// <param name="mainDom">Representation of the main application domain.</param>
/// <param name="keepAliveSettings">The configuration for keep alive settings.</param>
/// <param name="logger">The typed logger.</param>
/// <param name="profilingLogger">The profiling logger.</param>
/// <param name="serverRegistrar">Provider of server registrations to the distributed cache.</param>
/// <param name="httpClientFactory">Factory for <see cref="HttpClient" /> instances.</param>
public KeepAlive(
IHostingEnvironment hostingEnvironment,
IMainDom mainDom,
IOptionsMonitor <KeepAliveSettings> keepAliveSettings,
ILogger <KeepAlive> logger,
IProfilingLogger profilingLogger,
IServerRoleAccessor serverRegistrar,
IHttpClientFactory httpClientFactory)
: base(logger, TimeSpan.FromMinutes(5), DefaultDelay)
{
_hostingEnvironment = hostingEnvironment;
_mainDom = mainDom;
_keepAliveSettings = keepAliveSettings.CurrentValue;
_logger = logger;
_profilingLogger = profilingLogger;
_serverRegistrar = serverRegistrar;
_httpClientFactory = httpClientFactory;
keepAliveSettings.OnChange(x => _keepAliveSettings = x);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public virtual void Configure(IApplicationBuilder app, IOptionsMonitor <TOptions> appConfigMonitor, IOptionsMonitor <Extensions.Base.Configuration> extConfigMonitor, IApplicationLifetime applicationLifetime)
{
//Error handling
if (_env.IsDevelopment() || _env.IsEnvironment("Local") || (appConfigMonitor.CurrentValue?.DeveloperExceptionPage ?? false))
{
app.UseDeveloperExceptionPage();
}
app.UseExtCore();
Func <IDictionary <string, Extensions.Base.Configuration.Assembly>, string> _extSerialize = list => string.Join(" | ", list?.Where(ext => ext.Value.Priority > 0).OrderBy(ext => ext.Value.Priority).Select(_ => _.Key));
_extLastConfigAssembliesSerialized = _extSerialize(extConfigMonitor.CurrentValue.Assemblies);
extConfigMonitor.OnChange(extConfig =>
{
var _extCurrentAssembliesSerialized = _extSerialize(extConfig.Assemblies);
var isUpdatable = _extCurrentAssembliesSerialized == _extLastConfigAssembliesSerialized;
_logger.CreateLogger <Extensions.Base.Configuration>().LogInformation($"Config changed {DateTime.Now}; Is updatable: {isUpdatable} ");
if (isUpdatable)
{
_extLastConfigAssembliesSerialized = _extCurrentAssembliesSerialized;
}
if (!isUpdatable && extConfig.EnableShutDownOnChange)
{
applicationLifetime.StopApplication();
}
else
{
ExtCore.Events.Event <Extensions.Base.IConfigurationChangeEvent, Extensions.Base.ConfigurationChangeContext>
.Broadcast(new Extensions.Base.ConfigurationChangeContext()
{
App = app, Lifetime = applicationLifetime, Configuration = extConfig
}
);
}
});
}
/// <summary>
/// Initializes a new instance of the <see cref="TouchServerTask"/> class.
/// </summary>
/// <param name="runtimeState">Representation of the state of the Umbraco runtime.</param>
/// <param name="serverRegistrationService">Services for server registrations.</param>
/// <param name="requestAccessor">Accessor for the current request.</param>
/// <param name="logger">The typed logger.</param>
/// <param name="globalSettings">The configuration for global settings.</param>
public TouchServerTask(
IRuntimeState runtimeState,
IServerRegistrationService serverRegistrationService,
IHostingEnvironment hostingEnvironment,
ILogger <TouchServerTask> logger,
IOptionsMonitor <GlobalSettings> globalSettings,
IServerRoleAccessor serverRoleAccessor)
: base(logger, globalSettings.CurrentValue.DatabaseServerRegistrar.WaitTimeBetweenCalls, TimeSpan.FromSeconds(15))
{
_runtimeState = runtimeState;
_serverRegistrationService = serverRegistrationService ?? throw new ArgumentNullException(nameof(serverRegistrationService));
_hostingEnvironment = hostingEnvironment;
_logger = logger;
_globalSettings = globalSettings.CurrentValue;
globalSettings.OnChange(x =>
{
_globalSettings = x;
ChangePeriod(x.DatabaseServerRegistrar.WaitTimeBetweenCalls);
});
_serverRoleAccessor = serverRoleAccessor;
}
public BackOfficeAntiforgery(IOptionsMonitor <GlobalSettings> globalSettings)
{
// NOTE: This is the only way to create a separate IAntiForgery service :(
// Everything in netcore is internal. I have logged an issue here https://github.com/dotnet/aspnetcore/issues/22217
// but it will not be handled so we have to revert to this.
var services = new ServiceCollection();
services.AddLogging();
services.AddAntiforgery(x =>
{
x.HeaderName = Constants.Web.AngularHeadername;
x.Cookie.Name = Constants.Web.CsrfValidationCookieName;
});
ServiceProvider container = services.BuildServiceProvider();
_internalAntiForgery = container.GetRequiredService <IAntiforgery>();
_globalSettings = globalSettings.CurrentValue;
globalSettings.OnChange(x => {
_globalSettings = x;
});
}
/// <summary>
/// Creates an instance of <see cref="ConsoleLoggerProvider"/>.
/// </summary>
/// <param name="options">The options to create <see cref="ConsoleLogger"/> instances with.</param>
/// <param name="formatters">Log formatters added for <see cref="ConsoleLogger"/> insteaces.</param>
public ConsoleLoggerProvider(IOptionsMonitor <ConsoleLoggerOptions> options, IEnumerable <ConsoleFormatter> formatters)
{
_options = options;
_loggers = new ConcurrentDictionary <string, ConsoleLogger>();
SetFormatters(formatters);
ReloadLoggerOptions(options.CurrentValue);
_optionsReloadToken = _options.OnChange(ReloadLoggerOptions);
_messageQueue = new ConsoleLoggerProcessor();
if (DoesConsoleSupportAnsi())
{
_messageQueue.Console = new AnsiLogConsole();
_messageQueue.ErrorConsole = new AnsiLogConsole(stdErr: true);
}
else
{
_messageQueue.Console = new AnsiParsingLogConsole();
_messageQueue.ErrorConsole = new AnsiParsingLogConsole(stdErr: true);
}
}
