public async void StartAsync(X509Certificate2 certificate, AutoResetEvent closer, int threadCount)
{
Contract.Requires(certificate != null);
Contract.Requires(closer != null);
Contract.Requires(threadCount > 0);
theCloser = closer;
Console.WriteLine("Initializing Server...");
LoggerFactory loggerFactory = new LoggerFactory();
loggerFactory.AddConsole(Microsoft.Extensions.Logging.LogLevel.Error, false);
InternalLoggerFactory.DefaultFactory.AddProvider(new ConsoleLoggerProvider((s, level) => true, false));
var dispatcher = new DispatcherEventLoopGroup();
bossGroup = dispatcher;
workerGroup = new WorkerEventLoopGroup(dispatcher, threadCount);
try
{
var bootstrap = new ServerBootstrap();
bootstrap.Group(bossGroup, workerGroup);
bootstrap.Channel <TcpServerChannel>();
bootstrap
.Option(ChannelOption.SoBacklog, 100)
.Handler(new LoggingHandler("SRV_LSTN"))
.ChildHandler(new ActionChannelInitializer <IChannel>(channel =>
{
IChannelPipeline pipeline = channel.Pipeline;
if (certificate != null)
{
pipeline.AddLast("tls", TlsHandler.Server(certificate));
}
pipeline.AddLast("framing-enc", new LengthFieldPrepender(2));
pipeline.AddLast("framing-dec", new LengthFieldBasedFrameDecoder(ushort.MaxValue, 0, 2, 0, 2));
pipeline.AddLast("echo", new EchoServerHandler());
}));
theChannel = await bootstrap.BindAsync(IPAddress.Any, 3382);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
static void Main(string[] args)
{
// Build application configuration
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.SetBasePath(Environment.CurrentDirectory);
builder.AddJsonFile("appsettings.json");
builder.AddCloudFoundry();
var configuration = builder.Build();
// Setup logging
var factory = new LoggerFactory();
factory.AddConsole(configuration.GetSection("Logging"));
// Build Eureka clients config from configuration
var clientOpts = new EurekaClientOptions();
ConfigurationBinder.Bind(configuration.GetSection(EurekaClientOptions.EUREKA_CLIENT_CONFIGURATION_PREFIX), clientOpts);
// Build Eureka instance info config from configuration
var instOpts = new EurekaInstanceOptions();
ConfigurationBinder.Bind(configuration.GetSection(EurekaInstanceOptions.EUREKA_INSTANCE_CONFIGURATION_PREFIX), instOpts);
// if a Cloud Foundry Service Binding is found, update config
var si = configuration.GetServiceInfos <EurekaServiceInfo>();
if (si.Any())
{
EurekaPostConfigurer.UpdateConfiguration(configuration, si.First(), clientOpts);
EurekaPostConfigurer.UpdateConfiguration(configuration, instOpts);
}
// Initialize ApplicationManager with instance configuration
ApplicationInfoManager.Instance.Initialize(instOpts, factory);
// Create the Eureka client, the Application is registered and renewed with registry
var client = new DiscoveryClient(clientOpts, null, factory);
// Hang and keep renewing the registration
Console.ReadLine();
}
static void Main(string[] args)
{
using (var loggerFactory = new LoggerFactory())
{
var config = new JobHostConfiguration();
config.DashboardConnectionString = "UseDevelopmentStorage=true";
config.LoggerFactory = loggerFactory
.AddConsole();
config.UseTimers();
config.UseDurableTask(new DurableTaskExtension
{
HubName = "DemoDurableLocal",
});
var host = new JobHost(config);
host.RunAndBlock();
}
}
public WalletRepositoryFixture()
{
var secrets = new PasswordHashSecretProvider();
var addresses = new DeterministicWalletAddressProvider(secrets);
var factory = new LoggerFactory();
factory.AddConsole();
var baseDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
Value = new SqliteWalletRepository(
baseDirectory,
$"{Guid.NewGuid()}",
"wallets",
addresses,
factory.CreateLogger <SqliteWalletRepository>());
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseForwardedHeaders(new ForwardedHeadersOptions
{
ForwardedHeaders = Microsoft.AspNetCore.HttpOverrides.ForwardedHeaders.XForwardedFor | Microsoft.AspNetCore.HttpOverrides.ForwardedHeaders.XForwardedProto
});
app.UseIpRateLimiting();
app.UseMvc();
}
public static void Main(string[] arguments)
{
try
{
var loggerFactory = new LoggerFactory();
loggerFactory.AddConsole(LogLevel.Debug);
_controller = new WirehomeController(loggerFactory, arguments);
_controller.Startup();
}
catch (Exception exception)
{
global::System.Console.WriteLine(exception.ToString());
}
global::System.Console.WriteLine("Press <Enter> to exit.");
global::System.Console.ReadLine();
}
private ILogger initializeLogger()
{
var LoggerFactory = new LoggerFactory();
LoggerFactory.AddDebug();
LoggerFactory.AddConsole(LogLevel.Trace);
var Logger = LoggerFactory.CreateLogger <Startup>();
Logger.LogInformation("------------------------------------------------------------------------------------------------------");
Logger.LogInformation("Core Starting.");
Logger.LogInformation($"Operating System: { RuntimeInformation.OSDescription }");
Logger.LogInformation($"OS Architecture: { RuntimeInformation.OSArchitecture }");
Logger.LogInformation($"Process Architecture: { RuntimeInformation.ProcessArchitecture }");
Logger.LogInformation($"Framework: { RuntimeInformation.FrameworkDescription }");
Logger.LogInformation("------------------------------------------------------------------------------------------------------");
return(Logger);
}
static void Main(string[] args)
{
Console.WriteLine("Hello HTM Actor Model Cluster!");
//AkkaHostService svc = new AkkaHostService();
//svc.Start(args);
//--port 8081 --sysname HtmCluster --hosstname=localhost --publichostname=localhost
LoggerFactory factory = new LoggerFactory();
factory.AddConsole(LogLevel.Information);
factory.AddDebug(LogLevel.Information);
//--SystemName=node1 --RequestMsgQueue=actorsystem/actorqueue --ReplyMsgQueue=actorsystem/rcvnode1 --SbConnStr="Endpoint=sb://bastasample.servicebus.windows.net/;SharedAccessKeyName=demo;SharedAccessKey=MvwVbrrJdsMQyhO/0uwaB5mVbuXyvYa3WRNpalHi0LQ=" --TblStoragePersistenConnStr="DefaultEndpointsProtocol=https;AccountName=azfunctionsamples;AccountKey=NEjFcvFNL/G7Ugq9RSW59+PonNgql/yLq8qfaVZPhanV9aJUnQi2b6Oy3csvPZPGVJreD+RgVUJJFFTZdUBhAA==;EndpointSuffix=core.windows.net" --ActorSystemName=inst701 --SubscriptionName=node1
ActorSbHostService svc = new ActorSbHostService(factory.CreateLogger("logger"));
svc.Start(args);
}
public void Invoke_CreatesDump()
{
if (Environment.OSVersion.Platform == PlatformID.Win32NT)
{
LoggerFactory loggerFactory = new LoggerFactory();
loggerFactory.AddConsole(minLevel: LogLevel.Debug);
var logger1 = loggerFactory.CreateLogger <HeapDumper>();
var logger2 = loggerFactory.CreateLogger <HeapDumpEndpoint>();
var dumper = new HeapDumper(new HeapDumpEndpointOptions(), logger: logger1);
var ep = new HeapDumpEndpoint(new HeapDumpEndpointOptions(), dumper, logger2);
var result = ep.Invoke();
Assert.NotNull(result);
Assert.True(File.Exists(result));
File.Delete(result);
}
}
static void Main(string[] args)
{
var factory = new LoggerFactory().DemystifyExceptions();
factory.AddConsole();
var logger = factory.CreateLogger("Test");
try
{
new SampleExceptionGenerator();
} catch (Exception ex)
{
logger.LogError(ex, "While trying to test");
}
Console.ReadKey();
}
// public static SsoServiceInfo SsoServiceInfo;
public static void RegisterConfig(string environment)
{
// Set up configuration sources.
var builder = new ConfigurationBuilder()
.SetBasePath(GetContentRoot())
.AddJsonFile("appsettings.json", optional: false, reloadOnChange: false)
.AddJsonFile($"appsettings.{environment}.json", optional: true)
.AddEnvironmentVariables()
.AddCloudFoundry();
Configuration = builder.Build();
// var serviceInfos = CloudFoundryServiceInfoCreator.Instance(Configuration);
// SsoServiceInfo = serviceInfos.GetServiceInfos<SsoServiceInfo>().FirstOrDefault()
// ?? throw new NullReferenceException("Service info for an SSO Provider was not found!");
LoggerFactory = new LoggerFactory();
LoggerFactory.AddConsole(LogLevel.Trace);
}
public void TestLoggerScopes()
{
using (ILoggerFactory factory = new LoggerFactory()) {
factory.AddConsole(true);
ILogger logger = factory.CreateLogger <LoggerTests>();
logger.LogInformation("Before scope");
using (logger.BeginScope("First scope")) {
using (logger.BeginScope("Second scope")) {
logger.LogInformation("Within scopes");
}
}
logger.LogInformation("After scope");
}
}
private static void ConfigureServices(IServiceCollection services)
{
var env = PlatformServices.Default.Application;
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.RollingFile(Path.Combine($@"C:\logs\{env.ApplicationName}", "log-{Date}.txt"))
.CreateLogger();
var loggerFactory = new LoggerFactory();
loggerFactory.AddConsole((l, s) => s == LogLevel.Trace);
loggerFactory.AddSerilog(Log.Logger);
services.AddSingleton <ILoggerFactory, LoggerFactory>();
services.AddLogging();
services.AddTransient <IDatabase, Database>();
}
public Server()
{
_Configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("sshserver.json", optional: false)
.Build();
_LoggerFactory = new LoggerFactory();
_LoggerFactory.AddConsole(_Configuration.GetSection("Logging"));
_Logger = _LoggerFactory.CreateLogger("KSSHServer");
IConfigurationSection keys = _Configuration.GetSection("keys");
foreach (IConfigurationSection key in keys.GetChildren())
{
_HostKeys[key.Key] = key.Value;
}
}
private static void StartServerByAnnotaions()
{
var factory = new LoggerFactory();
factory.AddConsole(LogLevel.Debug);
var processor = new ThriftServiceProcessor(factory, new Thrifty.ScribeTest());
var config = new ThriftServerConfig()
{
BindingAddress = "0.0.0.0",
Port = 9999,
IdleConnectionTimeout = TimeSpan.FromMinutes(10),
QueueTimeout = TimeSpan.FromMinutes(10),
TaskExpirationTimeout = TimeSpan.FromMinutes(10)
};
var server = new ThriftServer(processor, config, loggerFactory: factory);
server.StartAsync();
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
// Add framework services.
var loggerFactory = new LoggerFactory();
loggerFactory.AddConsole();
loggerFactory.AddDebug();
services.AddMvc();
services.AddSingleton <IConfiguration>(Configuration);
services.AddSingleton <IFirstService, FirstService>();
services.AddScoped <ArticlesService>();
//services.AddTransient<ArticlesService>();
services.AddScoped <CustomLogActionOneFilter>();
services.AddScoped <CustomOneLoggingExceptionFilter>();
services.AddScoped <CustomOneResourceFilter>();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddSingleton <IConfiguration>(Configuration);
var loggerFactory = new LoggerFactory();
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug();
// Add framework services.
services.AddMvc(
config =>
{
config.Filters.Add(new OAuthValidationFilter(Configuration));
}
)
.AddJsonOptions(options => options.SerializerSettings.ContractResolver = new DefaultContractResolver());
}
public ExecutionResultProcessorFixture()
{
PointerFactory = A.Fake <IExecutionPointerFactory>();
DateTimeProvider = A.Fake <IDateTimeProvider>();
EventHub = A.Fake <ILifeCycleEventPublisher>();
ErrorHandlers = new HashSet <IWorkflowErrorHandler>();
Options = new WorkflowOptions(A.Fake <IServiceCollection>());
A.CallTo(() => DateTimeProvider.Now).Returns(DateTime.Now);
//config logging
var loggerFactory = new LoggerFactory();
loggerFactory.AddConsole(LogLevel.Debug);
Subject = new ExecutionResultProcessor(PointerFactory, DateTimeProvider, EventHub, ErrorHandlers, Options, loggerFactory);
}
private void InitDB(IServiceCollection services)
{
services.AddDbContext <HouseDataContext>(options =>
{
var loggerFactory = new LoggerFactory();
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
options.UseLoggerFactory(loggerFactory);
options.UseMySql(Configuration["MySQLConnectionString"].ToString());
});
services.AddDbContext <HouseMapContext>(options =>
{
var loggerFactory = new LoggerFactory();
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
options.UseLoggerFactory(loggerFactory);
options.UseMySql(Configuration["QCloudMySQL"].ToString());
});
}
static void Main()
{
var loggerFactory = new LoggerFactory();
loggerFactory.AddConsole();
var bootloader = Bootloader.Configure(_ => _
.UseLoggerFactory(loggerFactory)
.Development()
.IncludeAssembliesStartingWith("Microsoft"));
var result = bootloader.Start();
var logger = result.Container.Get <ILogger>();
result.Assemblies.GetAll().ForEach(_ => logger.Information($"Assembly '{_}' loaded and part of discovery"));
loggerFactory.Dispose();
}
private static void StartThriftyServer(int port)
{
var factory = new LoggerFactory();
factory.AddConsole(LogLevel.Debug);
var serverConfig = new ThriftyServerOptions();
var bootStrap = new ThriftyBootstrap(new DelegateServiceLocator(
(ctx, x) => new Thrifty.ScribeTest()), serverConfig, new InstanceDescription("SampleApp",
"TestApp122", PublicAddress), factory);
var future = bootStrap
.AddService(typeof(Thrifty.IScribe), "0.0.1")
.EurekaConfig(true, new EurekaClientConfig {
EurekaServerServiceUrls = "http://10.66.4.68:8761/eureka"
})
.Bind("localhost", port)
.StartAsync();
}
private void InitializeLogger()
{
IConfigureOptions <LoggerFilterOptions> options = new ConfigureOptions <LoggerFilterOptions>(filterOptions =>
{
filterOptions.MinLevel = LogLevel.Trace;
});
var loggerFactory = new LoggerFactory();
DataStore.Set(Constants.LoggerFactory, loggerFactory);
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
LoggerFactory = loggerFactory;
Services.AddOptions();
Services.TryAdd(ServiceDescriptor.Singleton <ILoggerFactory>(loggerFactory));
Services.TryAdd(ServiceDescriptor.Singleton(typeof(ILogger <>), typeof(Logger <>)));
Services.TryAddEnumerable(ServiceDescriptor.Singleton(options));
}
public override IServiceProvider ConfigureServices(IServiceCollection services)
{
var loggerFactory = new LoggerFactory();
loggerFactory.AddConsole(LogLevel.Warning);
services
.AddSingleton <ILoggerFactory>(loggerFactory)
.AddDbContext <AppDbContext>(options =>
options.UseNpgsql(GetDbConnectionString()), ServiceLifetime.Transient)
.AddJsonApi <AppDbContext>(options => {
options.Namespace = "api/v1";
options.DefaultPageSize = 5;
options.IncludeTotalRecordCount = true;
})
.AddScoped <IRequestMeta, MetaService>();
return(services.BuildServiceProvider());
}
private static ILoggerFactory CreateLoggerFactory()
{
var loggerFactory = new LoggerFactory();
// Writes log output to the VS "Debug" stream in the Output window
loggerFactory.AddDebug();
// Log to stdout
loggerFactory.AddConsole(LogLevel.Information);
// TODO use a "real" file logger. See https://github.com/aspnet/Logging/issues/441
// Example of how to capture granular logging
loggerFactory.AddProvider(new FileLoggerProvider("./query_plans.log",
(category, e) =>
category.EndsWith(nameof(RelationalQueryCompilationContextFactory)) &&
e.Id == (int)Microsoft.EntityFrameworkCore.Infrastructure.CoreEventId.QueryPlan));
return(loggerFactory);
}
public ConfigTest()
{
var loggerFactory = new LoggerFactory();
loggerFactory.AddConsole(
minLevel: LogLevel.Error,
includeScopes: false
);
loggerFactory.UseAsHibernateLoggerFactory();
//
var cfg = new Configuration();
var file = Path.Combine(
AppDomain.CurrentDomain.BaseDirectory,
"hibernate.config"
);
cfg.Configure(file);
sessionFactory = cfg.BuildSessionFactory();
}
static RaciLog()
{
_enabled = false;
_syncRoot = new object();
MinLevel = LogLevel.Debug;
LogPublisher = new SubscriptionLogProvider();
NullLogger = new LoggerFactory().AddNull().CreateLogger("Null");
_factory = new LoggerFactory();
_factory.AddConsole(EntryFilter, true);
_factory.AddProvider(LogPublisher);
#if DEBUG
_factory.AddDebug(LogLevel.Debug);
#endif
#if TRACE
//_factory.AddTraceSource()
#endif
Enabled = true;
DefaultLogger = _factory.CreateLogger("RACI");
}
public virtual IServiceProvider ConfigureServices(IServiceCollection services)
{
var loggerFactory = new LoggerFactory();
loggerFactory.AddConsole(LogLevel.Warning);
services.AddSingleton <ILoggerFactory>(loggerFactory);
services.AddDbContext <AppDbContext>(options => options
.UseNpgsql(GetDbConnectionString()),
ServiceLifetime.Transient);
services.AddScoped <IDbContextResolver, DbContextResolver <AppDbContext> >();
var mvcBuilder = services.AddMvcCore();
services.AddJsonApi(options => {
options.Namespace = "api/v1";
options.DefaultPageSize = 10;
options.IncludeTotalRecordCount = true;
options.BuildContextGraph((builder) => {
builder.AddResource <CourseResource>("courses");
builder.AddResource <DepartmentResource>("departments");
builder.AddResource <StudentResource>("students");
});
}, mvcBuilder);
services.AddAutoMapper();
services.AddScoped <IResourceMapper, AutoMapperAdapter>();
services.AddScoped <IResourceService <CourseResource, int>, EntityResourceService <CourseResource, CourseEntity, int> >();
services.AddScoped <IResourceService <DepartmentResource, int>, EntityResourceService <DepartmentResource, DepartmentEntity, int> >();
services.AddScoped <IResourceService <StudentResource, int>, EntityResourceService <StudentResource, StudentEntity, int> >();
var provider = services.BuildServiceProvider();
var appContext = provider.GetRequiredService <AppDbContext>();
if (appContext == null)
{
throw new ArgumentException();
}
return(provider);
}
static void Main(string[] args)
{
Options options;
try
{
options = Options.Create(args);
}
catch (InvalidDataException)
{
PrintHelp();
return;
}
var loggerFactory = new LoggerFactory(Enumerable.Empty <ILoggerProvider>(), new LoggerFilterOptions()
{
MinLevel = options.Verbose ? LogLevel.Trace : LogLevel.Information
});
if (options.ConsoleOutput)
{
loggerFactory.AddConsole();
}
s_logger = loggerFactory.CreateLogger <Program>();
var sourceResolver = new LocalSourceResolver(loggerFactory);
var referenceResolver = new LocalReferenceResolver(loggerFactory);
var buildConstructor = new BuildConstructor(referenceResolver, sourceResolver);
var artifactsDir = LocalReferenceResolver.GetArtifactsDirectory();
var thisCompilerVersion = options.IgnoreCompilerVersion
? null
: typeof(Compilation).Assembly.GetCustomAttribute <AssemblyInformationalVersionAttribute>()?.InformationalVersion;
var filesToValidate = artifactsDir.EnumerateFiles("*.exe", SearchOption.AllDirectories)
.Concat(artifactsDir.EnumerateFiles("*.dll", SearchOption.AllDirectories))
.Distinct(FileNameEqualityComparer.Instance);
ValidateFiles(filesToValidate, buildConstructor, thisCompilerVersion);
}
/// <summary>
/// Configuration options:
/// LogLevel
/// "Console"
/// "Debug"
/// "LocalTraceFile"
/// </summary>
/// <param name="settingsPath"></param>
/// <returns></returns>
public static ILogger GetLogger(string settingsPath)
{
lock (_objLock)
{
// Read from Configuration for Internal Loggging
IConfiguration config = DefaultConfiguration.LoadConfig(settingsPath, "appsettings.json");
var logLevelSection = config.GetSection(LoggingSettingsConfig.LoggingSection).GetSection(LoggingSettingsConfig.LogLevelSection);
LogLevel logLevelDefault = logLevelSection.GetValue <LogLevel>(LoggingSettingsConfig.LogLevelDefaultKey, LogLevel.None);
// Use Default as the loglevel for the types we support
LogLevel logLevelConsole = logLevelSection.GetValue <LogLevel>(LoggingSettingsConfig.LogLevelConsoleKey, logLevelDefault);
LogLevel logLevelDebug = logLevelSection.GetValue <LogLevel>(LoggingSettingsConfig.LogLevelDebugKey, logLevelDefault);
LogLevel logLevelLocalTraceFile = logLevelSection.GetValue <LogLevel>(LoggingSettingsConfig.LogLevelLocalTraceFileKey, logLevelDefault);
// Logger Factory for Options
Factory = new LoggerFactory();
// Console, Debug
if (logLevelConsole < LogLevel.None)
{
Factory.AddConsole(logLevelConsole);
}
if (logLevelDebug < LogLevel.None)
{
Factory.AddDebug(logLevelDebug);
}
// Write to Local File and Trace (DbgView)
if (logLevelLocalTraceFile < LogLevel.None)
{
var fileSwitch = new SourceSwitch("fileSwitch");
fileSwitch.Level = ConvertToTraceListenerLogLevel(logLevelLocalTraceFile); // SourceLevels.All;
Factory.AddTraceSource(fileSwitch,
new TextWriterTraceListener(File.Open(LocalFileName(), FileMode.OpenOrCreate | FileMode.Append, FileAccess.Write, FileShare.Write)));
Trace.AutoFlush = true;
}
// Create ILogger here
Logger = Factory.CreateLogger <InternalLogger>();
}
return(Logger);
}
public void AspNetCoreLogging_MinLogLevel_Debug()
{
var external = new LoggerFactory();
// TODO: remove in RC2
external.MinimumLevel = LogLevel.Debug;
// TODO: change Debug to Trace in RC2 (yes, in RC1 Verbose is higher than debug, and Verbose got renamed to Trace, later, too!)
external.AddConsole(LogLevel.Verbose);
var loggerFactory = new MicrosoftLoggerFactoryAdapter(external);
var logger = loggerFactory.CreateLogger("cat");
logger.Should().NotBeNull();
logger.IsEnabled(Core.Logging.LogLevel.Trace).Should().BeFalse();
logger.IsEnabled(Core.Logging.LogLevel.Debug).Should().BeTrue();
logger.IsEnabled(Core.Logging.LogLevel.Information).Should().BeTrue();
logger.IsEnabled(Core.Logging.LogLevel.Warning).Should().BeTrue();
logger.IsEnabled(Core.Logging.LogLevel.Error).Should().BeTrue();
logger.IsEnabled(Core.Logging.LogLevel.Critical).Should().BeTrue();
}
public void ConsoleLogger_ReloadSettings_CanChangeLogLevel()
{
// Arrange
var settings = new MockConsoleLoggerSettings()
{
Cancel = new CancellationTokenSource(),
Switches =
{
["Test"] = LogLevel.Information,
}
};
var loggerFactory = new LoggerFactory();
loggerFactory.AddConsole(settings);
var logger = loggerFactory.CreateLogger("Test");
Assert.False(logger.IsEnabled(LogLevel.Verbose));
settings.Switches["Test"] = LogLevel.Verbose;
var cancellationTokenSource = settings.Cancel;
settings.Cancel = new CancellationTokenSource();
// Act
cancellationTokenSource.Cancel();
// Assert
Assert.True(logger.IsEnabled(LogLevel.Verbose));
}
public void ConsoleLogger_ReloadSettings_CanReloadMultipleTimes()
{
// Arrange
var settings = new MockConsoleLoggerSettings()
{
Cancel = new CancellationTokenSource(),
Switches =
{
["Test"] = LogLevel.Information,
}
};
var loggerFactory = new LoggerFactory();
loggerFactory.AddConsole(settings);
var logger = loggerFactory.CreateLogger("Test");
Assert.False(logger.IsEnabled(LogLevel.Verbose));
// Act & Assert
for (var i = 0; i < 10; i++)
{
settings.Switches["Test"] = i % 2 == 0 ? LogLevel.Information : LogLevel.Verbose;
var cancellationTokenSource = settings.Cancel;
settings.Cancel = new CancellationTokenSource();
cancellationTokenSource.Cancel();
Assert.Equal(i % 2 == 1, logger.IsEnabled(LogLevel.Verbose));
}
}
