private void ReloadLoggerOptions(ConsoleLoggerOptions options)
{
foreach (var logger in _loggers)
{
logger.Value.Options = options;
}
}
public static void Main(string[] args)
{
var gom = new GreenlightOMatic();
var options = new ConsoleLoggerOptions();
options.Format = ConsoleLoggerFormat.Default;
var loggerFactory = LoggerFactory.Create(builder =>
{
builder
.AddFilter("Microsoft", LogLevel.Warning)
.AddFilter("System", LogLevel.Warning)
.AddFilter("LoggingConsoleApp.Program", LogLevel.Debug)
.AddConsole(o =>
{
o.Format = ConsoleLoggerFormat.Default;
}
);
});
try
{
gom.Run(loggerFactory).GetAwaiter().GetResult();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
}
loggerFactory.Dispose();
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
}
private static async Task UseConfiguration(RaftCluster.NodeConfiguration config, string?persistentStorage)
{
config.Members.Add(new IPEndPoint(IPAddress.Loopback, 3262));
config.Members.Add(new IPEndPoint(IPAddress.Loopback, 3263));
config.Members.Add(new IPEndPoint(IPAddress.Loopback, 3264));
var loggerFactory = new LoggerFactory();
var loggerOptions = new ConsoleLoggerOptions
{
LogToStandardErrorThreshold = LogLevel.Warning
};
loggerFactory.AddProvider(new ConsoleLoggerProvider(new FakeOptionsMonitor <ConsoleLoggerOptions>(loggerOptions)));
config.LoggerFactory = loggerFactory;
using var cluster = new RaftCluster(config);
cluster.LeaderChanged += ClusterConfigurator.LeaderChanged;
var modifier = default(DataModifier?);
if (!string.IsNullOrEmpty(persistentStorage))
{
var state = new SimplePersistentState(persistentStorage);
cluster.AuditTrail = state;
modifier = new DataModifier(cluster, state);
}
await cluster.StartAsync(CancellationToken.None);
await(modifier?.StartAsync(CancellationToken.None) ?? Task.CompletedTask);
using var handler = new CancelKeyPressHandler();
Console.CancelKeyPress += handler.Handler;
await handler.WaitAsync();
Console.CancelKeyPress -= handler.Handler;
await(modifier?.StopAsync(CancellationToken.None) ?? Task.CompletedTask);
await cluster.StopAsync(CancellationToken.None);
}
static async Task RunTcpServerAsyncLibuv()
{
Console.WriteLine("Initializing Server...");
ConsoleLoggerOptions loggeroptions = new ConsoleLoggerOptions()
{
IncludeScopes = false
};
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);
X509Certificate2 tlsServerCertificate = new X509Certificate2(@"protocol-gateway.contoso.com.pfx", "password");
IChannel boundChannel = null;
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 (tlsServerCertificate != null)
{
var tlsSettings = new ServerTlsSettings(tlsServerCertificate, true, true, System.Security.Authentication.SslProtocols.Tls);
var handler = new TlsHandler(stream => new System.Net.Security.SslStream(stream, true, ValidateClientCertificate), tlsSettings);
pipeline.AddLast("certTls", handler);
}
pipeline.AddLast("framing-enc", new LengthFieldPrepender(2));
pipeline.AddLast("framing-dec", new LengthFieldBasedFrameDecoder(ushort.MaxValue, 0, 2, 0, 2));
pipeline.AddLast("echo", new EchoServerHandler());
}));
boundChannel = await bootstrap.BindAsync(IPAddress.Any, 3382);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
finally
{
//boundChannel.CloseAsync().Wait();
//await bossGroup.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1));
//await workerGroup.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1));
}
}
/// <summary>
/// Adds the new console logger with default options to logger hub.
/// If a XLogger:Console section exists in the application settings, it will be used.
/// </summary>
/// <param name="hub">logger hub instance.</param>
/// <returns>The logger hub.</returns>
public static ILoggerHub AddConsole(this ILoggerHub hub)
{
var options = new ConsoleLoggerOptions();
if (hub.Configuration != null)
{
options.ReadFromConfiguration(hub.Configuration);
}
return(AddConsole(hub, new ConsoleLogger(options)));
}
private void ReloadLoggerOptions(ConsoleLoggerOptions options)
{
this.includeScopes = options.IncludeScopes;
this.disableColors = options.DisableColors;
var scopeProvider = GetScopeProvider();
foreach (var logger in this.loggers.Values)
{
logger.ScopeProvider = scopeProvider;
logger.DisableColors = options.DisableColors;
}
}
static void Main(string[] args)
{
ILoggerFactory loggerFactory = new LoggerFactory();
//Deprecated method, maar kan even niet anders
ConsoleLoggerOptions options = new ConsoleLoggerOptions();
loggerFactory.AddProvider(
new ConsoleLoggerProvider(
(text, logLevel) => logLevel >= LogLevel.Debug, true));
//192.168.99.100
var connectionBuilder = new RabbitMQContextBuilder()
.WithExchange("MVM.EventExchange")
.WithAddress("localhost", 5672)
.WithCredentials(userName: "******", password: "******");
var context = new TestBusContext();
var builder = new MicroserviceHostBuilder()
.SetLoggerFactory(loggerFactory)
.RegisterDependencies((services) =>
{
services.AddTransient <IDataMapper, SinaasAppelDataMapper>();
services.AddTransient <ICommandPublisher, CommandPublisher>();
services.AddTransient <IEventPublisher, EventPublisher>();
services.AddSingleton <IBusContext <IConnection> >(context);
})
.WithContext(context)
.UseConventions();
var host = builder.CreateHost();
host.StartListeningInOtherThread();
Console.WriteLine("ServiceHost is listening to incoming events...");
Console.WriteLine("Press any key to quit.");
var publisher = new EventPublisher(context);
var commandpublisher = new CommandPublisher(context);
publisher.Publish(new PolisToegevoegdEvent("MVM.Polisbeheer.PolisToegevoegd")
{
Message = "Hey"
});
publisher.Publish(new HenkToegevoegdEvent("Test")
{
Test = "Oi"
});
}
/// <summary>
/// Adds logging services to the current service collection.
/// </summary>
/// <param name="options">Provides programmatic configuration
/// for the Console logger.</param>
/// <returns>Reference to the current ApiBuilder.</returns>
/// <exception cref="InvalidOperationException">If this method
/// was already called.</exception>
internal ApiBuilder <TLoggerCategory, TDbContext> AddLogging(
ConsoleLoggerOptions options = null)
{
if (IsInvoked(nameof(AddLogging)))
{
throw new InvalidOperationException(
ServiceResources.Get("ApiBuilder.MethodAlreadyCalled", nameof(AddLogging))
);
}
_services.AddLogging(builder =>
{
builder.ClearProviders();
var logConfig = _config.GetSection(ApiConfigKeys.Logging);
builder.AddConfiguration(logConfig);
var providerString = _config[ApiConfigKeys.LoggingProvider]
?? string.Empty;
var providerTokens = providerString.Split(
",", StringSplitOptions.RemoveEmptyEntries);
var providerList = providerTokens.Select(
provider => provider.ToLowerInvariant().Trim());
if (providerList.Contains(ApiLogProvider.Console.GetDescription()))
{
builder.AddConsole(opts =>
{
if (options != null)
{
opts.IncludeScopes = options.IncludeScopes;
opts.DisableColors = options.DisableColors;
opts.Format = options.Format;
opts.LogToStandardErrorThreshold = options.LogToStandardErrorThreshold;
opts.TimestampFormat = options.TimestampFormat;
}
});
}
if (providerList.Contains(ApiLogProvider.Debug.GetDescription()))
{
builder.AddDebug();
}
if (providerList.Contains(ApiLogProvider.EventSource.GetDescription()))
{
builder.AddEventSourceLogger();
}
});
_invokedMethods.Add(nameof(AddLogging));
return(this);
}
internal static (ConsoleLogger Logger, ConsoleSink Sink, ConsoleSink ErrorSink, Func <LogLevel, string> GetLevelPrefix, int WritesPerMsg) SetUp(
ConsoleLoggerOptions options = null,
SimpleConsoleFormatterOptions simpleOptions = null,
ConsoleFormatterOptions systemdOptions = null,
JsonConsoleFormatterOptions jsonOptions = null)
{
// Arrange
var sink = new ConsoleSink();
var errorSink = new ConsoleSink();
var console = new TestConsole(sink);
var errorConsole = new TestConsole(errorSink);
var consoleLoggerProcessor = new TestLoggerProcessor();
consoleLoggerProcessor.Console = console;
consoleLoggerProcessor.ErrorConsole = errorConsole;
var logger = new ConsoleLogger(_loggerName, consoleLoggerProcessor);
logger.ScopeProvider = new LoggerExternalScopeProvider();
logger.Options = options ?? new ConsoleLoggerOptions();
var formatters = new ConcurrentDictionary <string, ConsoleFormatter>(ConsoleLoggerTest.GetFormatters(simpleOptions, systemdOptions, jsonOptions).ToDictionary(f => f.Name));
Func <LogLevel, string> levelAsString;
int writesPerMsg;
switch (logger.Options.FormatterName)
{
case ConsoleFormatterNames.Simple:
levelAsString = ConsoleLoggerTest.LogLevelAsStringDefault;
writesPerMsg = 2;
logger.Formatter = formatters[ConsoleFormatterNames.Simple];
break;
case ConsoleFormatterNames.Systemd:
levelAsString = ConsoleLoggerTest.GetSyslogSeverityString;
writesPerMsg = 1;
logger.Formatter = formatters[ConsoleFormatterNames.Systemd];
break;
case ConsoleFormatterNames.Json:
levelAsString = ConsoleLoggerTest.GetJsonLogLevelString;
writesPerMsg = 1;
logger.Formatter = formatters[ConsoleFormatterNames.Json];
break;
default:
throw new ArgumentOutOfRangeException(nameof(logger.Options.FormatterName));
}
return(logger, sink, errorSink, levelAsString, writesPerMsg);
}
internal static (ConsoleLogger Logger, ConsoleSink Sink, ConsoleSink ErrorSink, Func <LogLevel, string> GetLevelPrefix, int WritesPerMsg) SetUp(
ConsoleLoggerOptions options = null,
SimpleConsoleFormatterOptions simpleOptions = null,
ConsoleFormatterOptions systemdOptions = null,
JsonConsoleFormatterOptions jsonOptions = null)
{
// Arrange
var sink = new ConsoleSink();
var errorSink = new ConsoleSink();
var console = new TestConsole(sink);
var errorConsole = new TestConsole(errorSink);
var bufferMode = options == null ? ConsoleLoggerQueueFullMode.Wait : options.QueueFullMode;
var maxQueueLength = options == null ? ConsoleLoggerOptions.DefaultMaxQueueLengthValue : options.MaxQueueLength;
var consoleLoggerProcessor = new TestLoggerProcessor(console, errorConsole, bufferMode, maxQueueLength);
var formatters = new ConcurrentDictionary <string, ConsoleFormatter>(ConsoleLoggerTest.GetFormatters(simpleOptions, systemdOptions, jsonOptions).ToDictionary(f => f.Name));
ConsoleFormatter?formatter = null;
var loggerOptions = options ?? new ConsoleLoggerOptions();
Func <LogLevel, string> levelAsString;
int writesPerMsg;
switch (loggerOptions.FormatterName)
{
case ConsoleFormatterNames.Simple:
levelAsString = ConsoleLoggerTest.LogLevelAsStringDefault;
writesPerMsg = 2;
formatter = formatters[ConsoleFormatterNames.Simple];
break;
case ConsoleFormatterNames.Systemd:
levelAsString = ConsoleLoggerTest.GetSyslogSeverityString;
writesPerMsg = 1;
formatter = formatters[ConsoleFormatterNames.Systemd];
break;
case ConsoleFormatterNames.Json:
levelAsString = ConsoleLoggerTest.GetJsonLogLevelString;
writesPerMsg = 1;
formatter = formatters[ConsoleFormatterNames.Json];
break;
default:
throw new ArgumentOutOfRangeException(nameof(loggerOptions.FormatterName));
}
var logger = new ConsoleLogger(_loggerName, consoleLoggerProcessor, formatter, new LoggerExternalScopeProvider(), loggerOptions);
return(logger, sink, errorSink, levelAsString, writesPerMsg);
}
static LogSettings()
{
LoggerFactory = new LoggerFactory();
var fileOptions = new FileLoggerOptions
{
IsLogCallingMethodsSequence = false,
LogFilePath = GetLogSessionFilePath()
};
LoggerFactory.AddFileProvider(fileOptions);
var consoleOptions = new ConsoleLoggerOptions()
{
IsLogCallingMethodsSequence = false,
};
LoggerFactory.AddConsoleProvider(consoleOptions);
}
/// <summary>
/// Initializes a new instance of the ConsoleLogger class
/// </summary>
/// <param name="options"></param>
public ConsoleLogger(ConsoleLoggerOptions options = ConsoleLoggerOptions.None)
{
_options = options;
if (_options.HasFlag(ConsoleLoggerOptions.UseLabels))
{
_successMarker = "[suc]";
_failureMarker = "[ftl]";
_actionMarker = "[act]";
_warningMarker = "[wrn]";
_informationMarker = "[inf]";
_detailMarker = "[dtl]";
_debugMarker = "[dbg]";
}
if (options.HasFlag(ConsoleLoggerOptions.DisplayBanner))
{
this.ConsoleBanner();
}
}
private static void UpdateFormatterOptions(ConsoleFormatter formatter, ConsoleLoggerOptions deprecatedFromOptions)
{
#pragma warning disable CS0618
// kept for deprecated apis:
if (formatter is SimpleConsoleFormatter defaultFormatter)
{
defaultFormatter.FormatterOptions.ColorBehavior = deprecatedFromOptions.DisableColors ?
LoggerColorBehavior.Disabled : LoggerColorBehavior.Enabled;
defaultFormatter.FormatterOptions.IncludeScopes = deprecatedFromOptions.IncludeScopes;
defaultFormatter.FormatterOptions.TimestampFormat = deprecatedFromOptions.TimestampFormat;
defaultFormatter.FormatterOptions.UseUtcTimestamp = deprecatedFromOptions.UseUtcTimestamp;
}
else
if (formatter is SystemdConsoleFormatter systemdFormatter)
{
systemdFormatter.FormatterOptions.IncludeScopes = deprecatedFromOptions.IncludeScopes;
systemdFormatter.FormatterOptions.TimestampFormat = deprecatedFromOptions.TimestampFormat;
systemdFormatter.FormatterOptions.UseUtcTimestamp = deprecatedFromOptions.UseUtcTimestamp;
}
#pragma warning restore CS0618
}
// IConsoleLoggerSettings
static void LoggingDemo4(string scopeName = null)
{
Debugger.Break();
ConsoleLoggerOptions options = new ConsoleLoggerOptions();
options.IncludeScopes = true;
// Logger Factory konfigurieren
ILoggerFactory loggerFactory = LoggerFactory.Create(builder =>
{
builder
.AddConsole(configure =>
{
configure.IncludeScopes = options.IncludeScopes;
})
.AddDebug();
});
ILogger logger = loggerFactory.CreateLogger <Program>();
demoLogging(logger, scopeName);
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
optionsBuilder.UseSqlServer(@"Server=(LocalDB)\BABUSQL;Database=Customer;Trusted_Connection=True;");
LoggerFactory program_logger = new LoggerFactory();
// Console logger: Logs to Console
ConsoleLoggerOptions console_options = new ConsoleLoggerOptions();
console_options.DisableColors = false;
console_options.IncludeScopes = false;
ConsoleLoggerProvider console_logger = new ConsoleLoggerProvider((category, level) => level >= LogLevel.Trace, true, false);
program_logger.AddProvider(console_logger);
DebugLoggerProvider debug_logger = new DebugLoggerProvider();
program_logger.AddProvider(debug_logger);
optionsBuilder.UseLoggerFactory(program_logger).EnableSensitiveDataLogging();
}
public IWebHostBuilder GetWebHostBuilder <TStartup>(object?sslCertSelectorParam = null) where TStartup : class
{
IWebHostBuilder?baseWebHost = null;
if (this.UseKestrelWithIPACoreStack)
{
baseWebHost = new WebHostBuilder().UseKestrelWithStack(opt => ConfigureKestrelServerOptions(opt, sslCertSelectorParam));
}
else
{
baseWebHost = new WebHostBuilder().UseKestrel(opt => ConfigureKestrelServerOptions(opt, sslCertSelectorParam));
}
return(baseWebHost
.UseWebRoot(WwwRoot)
.UseContentRoot(ContentsRoot)
.ConfigureAppConfiguration((hostingContext, config) =>
{
})
.ConfigureLogging((hostingContext, logging) =>
{
if (this.DebugKestrelToConsole)
{
ConsoleLoggerOptions opt = new ConsoleLoggerOptions {
DisableColors = false, IncludeScopes = true
};
logging.AddProvider(new ConsoleLoggerProvider(new StaticOptionsMonitor <ConsoleLoggerOptions>(opt)));
}
if (this.DebugKestrelToLog)
{
logging.AddProvider(new MsLoggerProvider());
}
})
.UseStartup <TStartup>());
}
public void Test1()
{
ConsoleLoggerOptions consoleLoggerOptions = new ConsoleLoggerOptions();
MyOptionsMonitor <ConsoleLoggerOptions> optionsMonitor = new MyOptionsMonitor <ConsoleLoggerOptions>(consoleLoggerOptions);
ConsoleLoggerProvider loggerProvider = new ConsoleLoggerProvider(optionsMonitor);
var f = new LoggerFactory();
f.AddProvider(loggerProvider);
string brokerList = "192.168.1.112:9092,192.168.1.112:9093";
KfkManagement kfkManagement = new KfkManagement(brokerList, f);
List <string> topics = new List <string>()
{
"test000", "zjmtest0"
};
topics.Clear();
string topicName = "zjmtestw";
for (int i = 0; i < 50; i++)
{
topics.Add(topicName + i.ToString());
}
int p = 0;
int num = 100000;
foreach (var topic in topics)
{
for (int j = 0; j < num; j++)
{
kfkManagement.Produce(topic, p.ToString());
}
}
kfkManagement.Flush();
}
private static (ConsoleLogger Logger, ConsoleSink Sink, ConsoleSink ErrorSink) SetUp(ConsoleLoggerOptions options = null)
{
// Arrange
var sink = new ConsoleSink();
var errorSink = new ConsoleSink();
var console = new TestConsole(sink);
var errorConsole = new TestConsole(errorSink);
var consoleLoggerProcessor = new TestLoggerProcessor();
consoleLoggerProcessor.Console = console;
consoleLoggerProcessor.ErrorConsole = errorConsole;
var logger = new ConsoleLogger(_loggerName, consoleLoggerProcessor);
logger.ScopeProvider = new LoggerExternalScopeProvider();
logger.Options = options ?? new ConsoleLoggerOptions();
return(logger, sink, errorSink);
}
private static void ConfigureConsole(ConsoleLoggerOptions console)
{
console.IncludeScopes = true;
console.TimestampFormat = "yyyy-MM-dd HH:mm:ss ";
}
private static void ConfigureConsoleLogger(ConsoleLoggerOptions options)
{
options.IncludeScopes = false;
}
private static (ConsoleLogger Logger, ConsoleSink Sink, ConsoleSink ErrorSink, Func <LogLevel, string> GetLevelPrefix, int WritesPerMsg) SetUp(ConsoleLoggerOptions options = null)
{
// Arrange
var sink = new ConsoleSink();
var errorSink = new ConsoleSink();
var console = new TestConsole(sink);
var errorConsole = new TestConsole(errorSink);
var consoleLoggerProcessor = new TestLoggerProcessor();
consoleLoggerProcessor.Console = console;
consoleLoggerProcessor.ErrorConsole = errorConsole;
var logger = new ConsoleLogger(_loggerName, consoleLoggerProcessor);
logger.ScopeProvider = new LoggerExternalScopeProvider();
logger.Options = options ?? new ConsoleLoggerOptions();
Func <LogLevel, string> levelAsString;
int writesPerMsg;
switch (logger.Options.Format)
{
case ConsoleLoggerFormat.Default:
levelAsString = LogLevelAsStringDefault;
writesPerMsg = 2;
break;
case ConsoleLoggerFormat.Systemd:
levelAsString = GetSyslogSeverityString;
writesPerMsg = 1;
break;
default:
throw new ArgumentOutOfRangeException(nameof(logger.Options.Format));
}
return(logger, sink, errorSink, levelAsString, writesPerMsg);
}
static void Main(string[] args)
{
CancellationTokenSource tokenSource = new CancellationTokenSource();
var token = tokenSource.Token;
Console.WriteLine("Hello World!");
ConsoleLoggerOptions consoleLoggerOptions = new ConsoleLoggerOptions();
MyOptionsMonitor <ConsoleLoggerOptions> optionsMonitor = new MyOptionsMonitor <ConsoleLoggerOptions>(consoleLoggerOptions);
ConsoleLoggerProvider loggerProvider = new ConsoleLoggerProvider(optionsMonitor);
var f = new LoggerFactory();
f.AddProvider(loggerProvider);
var logger = f.CreateLogger <Program>();
string brokerList = "192.168.1.112:9092,192.168.1.112:9093";
KfkManagement kfkManagement = new KfkManagement(brokerList, f);
List <string> topics = new List <string>();
string topicName = "zjmtestw";
for (int i = 0; i < 50; i++)
{
topics.Add(topicName + i.ToString());
}
var consumer = kfkManagement.CreateConsumer("clientw", topics);
ConcurrentDictionary <string, int> kv = new ConcurrentDictionary <string, int>();
var t = Task.Run(() =>
{
while (!token.IsCancellationRequested)
{
lock (consumer)
{
var consumeResult = consumer.Consume(TimeSpan.FromMilliseconds(10));
if (consumeResult == null)
{
continue;
}
kv.AddOrUpdate(consumeResult.Topic, 1, (k, v) => Interlocked.Increment(ref v));
//logger.LogInformation($"topic:{consumeResult.Topic}, offset;:{consumeResult.Offset.ToString()}, {consumeResult.Message.Value}");
}
}
}).ContinueWith((t) => {
foreach (var item in kv)
{
Console.WriteLine($"{item.Key}:{item.Value}");
}
});
while (true)
{
string m = Console.ReadLine();
if (string.IsNullOrWhiteSpace(m))
{
continue;
}
string op = m.Split(" ")[0];
string topic = m.Split(" ")[1];
switch (op)
{
case "add":
lock (consumer)
{
var mtopics = consumer.Subscription.ToList();
mtopics.Add(topic);
consumer.Subscribe(mtopics);
}
break;
case "pause":
lock (consumer)
{
var array = consumer.Assignment.Where(x => x.Topic.Equals(topic)).ToList();
consumer.Pause(array);
Console.WriteLine($"pause:{string.Join(",", array)}");
}
break;
case "resume":
lock (consumer)
{
var array = consumer.Assignment.Where(x => x.Topic.Equals(topic)).ToList();
consumer.Resume(array);
Console.WriteLine($"pause:{string.Join(",", array)}");
}
break;
case "exit":
tokenSource.Cancel();
break;
default:
break;
}
}
}
