public void TestExporter() { var listener = new ObservableEventListener(); listener.EnableEvents(TflEventSource.Log, EventLevel.Verbose); var subscription = listener.LogToConsole(new LegacyLogFormatter()); var file = Path.GetTempFileName(); File.WriteAllText(file, @"t1,t2,t3,t4 Monday,10,1.1,1/1/2014 Tuesday,11,2.2,2/1/2014 Wednesday,12,3.3,3/1/2014 Wednesday,12,3.3,3/1/2014 Thursday,13,4.4,4/1/2014 Friday,14,5.5,5/1/2014 Saturday,15,6.6,6/1/2014"); File.Delete(OUTPUT); var profile = new Profiler().Profile(file); new ProfileExporter().Export(profile, OUTPUT); subscription.Dispose(); listener.DisableEvents(TflEventSource.Log); listener.Dispose(); Assert.IsTrue(File.Exists(OUTPUT)); }
/// <summary> /// Initializes a new instance of the <see cref="TestBase" /> class. /// </summary> protected TestBase() { var observableEventListener = new ObservableEventListener(); observableEventListener.EnableEvents(ExceptionLoggingEventSource.Log, EventLevel.LogAlways); observableEventListener.LogToConsole(); }
protected override void Given() { ColorMapper = new MockDefaultConsoleColorMapper(); MockConsole = new MockConsoleOutput(); Formatter = new EventTextFormatter(EventTextFormatter.DashSeparator) { VerbosityThreshold = EventLevel.Informational }; Listener = new ObservableEventListener(); Listener.LogToConsole(Formatter, ColorMapper); Listener.EnableEvents(TestEventSource.Log, EventLevel.LogAlways); }
static void Main(string[] args) { // optimizing IOCP performance int minWorkerThreads; int minCompletionPortThreads; ThreadPool.GetMinThreads(out minWorkerThreads, out minCompletionPortThreads); ThreadPool.SetMinThreads(minWorkerThreads, Math.Max(16, minCompletionPortThreads)); int threadCount = Environment.ProcessorCount; if (args.Length > 0) { threadCount = int.Parse(args[0]); } var eventListener = new ObservableEventListener(); eventListener.LogToConsole(); eventListener.EnableEvents(BootstrapperEventSource.Log, EventLevel.Verbose); eventListener.EnableEvents(MqttIotHubAdapterEventSource.Log, EventLevel.Verbose); eventListener.EnableEvents(ChannelEventSource.Log, EventLevel.Verbose); eventListener.EnableEvents(BootstrapEventSource.Log, EventLevel.Verbose); eventListener.EnableEvents(ExecutorEventSource.Log, EventLevel.Verbose); eventListener.EnableEvents(MqttEventSource.Log, EventLevel.Verbose); try { var cts = new CancellationTokenSource(); var certificate = new X509Certificate2("protocol-gateway.contoso.com.pfx", "password"); var settingsProvider = new AppConfigSettingsProvider(); BlobSessionStatePersistenceProvider blobSessionStateProvider = BlobSessionStatePersistenceProvider.CreateAsync( settingsProvider.GetSetting("BlobSessionStatePersistenceProvider.StorageConnectionString"), settingsProvider.GetSetting("BlobSessionStatePersistenceProvider.StorageContainerName")).Result; TableQos2StatePersistenceProvider tableQos2StateProvider = TableQos2StatePersistenceProvider.CreateAsync( settingsProvider.GetSetting("TableQos2StatePersistenceProvider.StorageConnectionString"), settingsProvider.GetSetting("TableQos2StatePersistenceProvider.StorageTableName")).Result; var bootstrapper = new Bootstrapper(settingsProvider, blobSessionStateProvider, tableQos2StateProvider); Task.Run(() => bootstrapper.RunAsync(certificate, threadCount, cts.Token), cts.Token); while (true) { string input = Console.ReadLine(); if (input != null && input.ToLowerInvariant() == "exit") { break; } } cts.Cancel(); bootstrapper.CloseCompletion.Wait(TimeSpan.FromSeconds(20)); } finally { eventListener.Dispose(); } }
private static void RegisterLogger() { var listener = new ObservableEventListener(); listener.EnableEvents(WebApiTracing.Log, EventLevel.LogAlways, Keywords.All); listener.LogToConsole(); listener.LogToFlatFile("test.log"); listener.LogToWindowsAzureTable(instanceName: "Protiviti", connectionString: "UseDevelopmentStorage=true"); }
static void Main(string[] args) { if (args.Length < 5) { Console.WriteLine("Mamemaki.Slab.BigQuery.PlayGround.exe <projectId> <datasetId> <tableId> <serviceAccountEmail> <privateKeyFile>"); return; } var projectId = args[0]; var datasetId = args[1]; var tableId = args[2]; var serviceAccountEmail = args[3]; var privateKeyFile = args[4]; var tableSchemaFile = args[5]; using (var listenerConsole = new ObservableEventListener()) using (var listener = new ObservableEventListener()) { var formatterConsole = new EventTextFormatter( "+=========================================+"); // Setup listener for debug listenerConsole.EnableEvents(SemanticLoggingEventSource.Log, EventLevel.LogAlways); listenerConsole.EnableEvents(BigQuerySinkEventSource.Log, EventLevel.LogAlways); listenerConsole.LogToConsole(formatterConsole); // Setup listener for playgrond listener.EnableEvents(PlayGroundEventSource.Log, EventLevel.LogAlways); listener.LogToConsole(formatterConsole); listener.LogToBigQuery( projectId: projectId, datasetId: datasetId, tableId: tableId, authMethod: "private_key", serviceAccountEmail: serviceAccountEmail, privateKeyFile: privateKeyFile, privateKeyPassphrase: "notasecret", autoCreateTable: true, tableSchemaFile: tableSchemaFile, insertIdFieldName: "%uuid%", bufferingInterval: TimeSpan.FromSeconds(1), bufferingCount: 3, bufferingFlushAllTimeout: Constants.DefaultBufferingFlushAllTimeout, maxBufferSize: 30000); PlayGroundEventSource.Log.Trace("start"); InsertRows(3); Thread.Sleep(1); InsertRows(3); PlayGroundEventSource.Log.Trace("end"); } Console.WriteLine("Press any key to exit"); Console.ReadLine(); }
public static void Start() { if (_listener != null) { throw new InvalidOperationException("Logging infrastucture already running"); } _listener = new ObservableEventListener(); _listener.EnableEvents(EtwSampleServerEventSource.Log, EventLevel.LogAlways); _listener.LogToConsole(new SampleFormatter()); }
static void Main(string[] args) { Options options = new Options(); CommandLine.Parser.Default.ParseArguments(args, options); if (!options.ShowingHelp) { ObservableEventListener Listener = new ObservableEventListener(); Listener.EnableEvents((EventSource)Harmonize.Instrumentation.Error, EventLevel.LogAlways, Keywords.All); Listener.EnableEvents((EventSource)Harmonize.Instrumentation.Harmonization, EventLevel.LogAlways, Keywords.All); //ObservableEventListener harmonyEventListener = new ObservableEventListener(); //harmonyEventListener.EnableEvents((EventSource)With.Harmony.Instrumentation.State, EventLevel.LogAlways, Keywords.All); //ObservableEventListener owlCommandEventListener = new ObservableEventListener(); //owlCommandEventListener.EnableEvents((EventSource)With.Owl.Intuition.Instrumentation.Command.Endpoint, EventLevel.LogAlways, Keywords.All); //ObservableEventListener owlPacketEventListener = new ObservableEventListener(); //owlPacketEventListener.EnableEvents((EventSource)With.Owl.Intuition.Instrumentation.Packet.Endpoint, EventLevel.LogAlways, Keywords.All); //ObservableEventListener owlStateEventListener = new ObservableEventListener(); //owlStateEventListener.EnableEvents((EventSource)With.Owl.Intuition.Instrumentation.State.Machine, EventLevel.LogAlways, Keywords.All); //ObservableEventListener xmppEventListener = new ObservableEventListener(); //xmppEventListener.EnableEvents((EventSource)With.Harmony.Instrumentation.Xmpp, EventLevel.LogAlways, Keywords.All); //ObservableEventListener alljoynEventListener = new ObservableEventListener(); //alljoynEventListener.EnableEvents(With.Alljoyn.Instrumentation.Coordinator, EventLevel.LogAlways, Keywords.All); //ObservableEventListener storeEventListener = new ObservableEventListener(); //storeEventListener.EnableEvents((EventSource)State.Instrumentation.Store, EventLevel.LogAlways, Keywords.All); //ObservableEventListener messagingEventListener = new ObservableEventListener(); //messagingEventListener.EnableEvents((EventSource)With.Messaging.Instrumentation.Messages, EventLevel.LogAlways, Keywords.All); options.TraceEvents.Split(',').Select(name => Listener.EnableEvents(name, EventLevel.LogAlways, Keywords.All)).ForEach(Cons.WriteLine); using (new CompositeDisposable(Listener.LogToConsole())) { Client client = new Client(options); client.Start(); System.Console.WriteLine("Started"); System.Console.WriteLine("Hit Return to stop"); System.Console.ReadLine(); client.Stop(); } } }
public void SetupTest() { var listener = new ObservableEventListener(); listener.EnableEvents(WebApiTracing.Log, EventLevel.LogAlways, Keywords.All); listener.LogToConsole(); listener.LogToTestInMemorySink(_testResults); _cts = new CancellationTokenSource(); _config.Routes.MapHttpRoute("DefaultApi", "{controller}/{id}", new { id = RouteParameter.Optional }); _config.Services.Replace(typeof(ITraceWriter), new SlabTraceWriter()); var server = new HttpServer(_config); _client = new HttpMessageInvoker(server); }
static void Main(string[] args) { var listener = new ObservableEventListener(); listener.EnableEvents(TflEventSource.Log, EventLevel.Informational); var subscription = listener.LogToConsole(new LegacyLogFormatter()); ValidateArguments(args); new ProfileExporter().Export(new Profiler().Profile(_input, _sample), _output); subscription.Dispose(); listener.DisableEvents(TflEventSource.Log); listener.Dispose(); }
private static async Task MainAsync(string[] args) { var observableEventListener = new ObservableEventListener(); observableEventListener.EnableEvents( WarmStorageEventSource.Log, EventLevel.Informational); observableEventListener.LogToConsole(); await CommonConsoleHost.RunWithOptionsAsync(new Dictionary<string, Func<CancellationToken, Task>> { { "Provision Resources", ProvisionResourcesAsync }, { "Run Warm Storage Consumer", RunAsync } }); }
static void Main() { using (var listener = new ObservableEventListener()) { listener.EnableEvents(SampleEventSource.Log, EventLevel.LogAlways, SampleEventSource.Keywords.SampleApp); listener.LogToConsole(); listener.LogToSeq("http://my-seq"); SampleEventSource.Log.Greeting(Environment.UserName); } Console.WriteLine("Done"); Console.ReadKey(true); }
static void Main(string[] args) { ObservableEventListener listener = new ObservableEventListener(); listener.EnableEvents(MyCompanyEventSource.Log, EventLevel.LogAlways, Keywords.All); listener.LogToConsole(); // Modify these settings to match your SMTP service requirements. listener.LogToEmail("smtp.live.com", 587, "*****@*****.**", "In Proc Sample", "etw"); MyCompanyEventSource.Log.Failure("No response from servers, general network failure!!"); listener.DisableEvents(MyCompanyEventSource.Log); listener.Dispose(); }
static async Task RunClientAsync() { var eventListener = new ObservableEventListener(); eventListener.LogToConsole(); eventListener.EnableEvents(DefaultEventSource.Log, EventLevel.Verbose); var group = new MultithreadEventLoopGroup(); X509Certificate2 cert = null; string targetHost = null; if (EchoClientSettings.IsSsl) { cert = new X509Certificate2("dotnetty.com.pfx", "password"); targetHost = cert.GetNameInfo(X509NameType.DnsName, false); } try { var bootstrap = new Bootstrap(); bootstrap .Group(group) .Channel<TcpSocketChannel>() .Option(ChannelOption.TcpNodelay, true) .Handler(new ActionChannelInitializer<ISocketChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; if (cert != null) { pipeline.AddLast(new TlsHandler(stream => new SslStream(stream, true, (sender, certificate, chain, errors) => true), new ClientTlsSettings(targetHost))); } pipeline.AddLast(new LengthFieldPrepender(2)); pipeline.AddLast(new LengthFieldBasedFrameDecoder(ushort.MaxValue, 0, 2, 0, 2)); pipeline.AddLast(new EchoClientHandler()); })); IChannel bootstrapChannel = await bootstrap.ConnectAsync(new IPEndPoint(EchoClientSettings.Host, EchoClientSettings.Port)); Console.ReadLine(); await bootstrapChannel.CloseAsync(); } finally { group.ShutdownGracefullyAsync().Wait(1000); eventListener.Dispose(); } }
private static void Main(string[] args) { var observableEventListener = new ObservableEventListener(); var configuration = SimulatorConfiguration.GetCurrentConfiguration(); observableEventListener.EnableEvents(ScenarioSimulatorEventSource.Log, configuration.GetLogLevel()); observableEventListener.LogToConsole(); var hostName = ConfigurationHelper.SourceName; _deviceSimulator = new SimulationProfile(hostName, configuration); // check for scenario specified on the command line if (args.Length > 0) { var scenario = args.Contains("/default", StringComparer.OrdinalIgnoreCase) ? SimulationScenarios.DefaultScenario() : args.First(x => !x.StartsWith("/",StringComparison.Ordinal)); var ct = args.Contains("/webjob", StringComparer.OrdinalIgnoreCase) ? GetWebJobCancellationToken() : CancellationToken.None; ProvisionDevicesAsync(ct).Wait(); _deviceSimulator.RunSimulationAsync(scenario, ct).Wait(); return; } var options = new Dictionary<string, Func<CancellationToken, Task>>(); options.Add("Provision Devices", ProvisionDevicesAsync); // no command line arguments, so prompt with a menu. foreach (var scenario in SimulationScenarios.AllScenarios) { options.Add("Run " + scenario, (Func<CancellationToken, Task>)(token => _deviceSimulator.RunSimulationAsync(scenario, token))); } //options.Add("Deprovision Devices", DeprovisionDevicesAsync); Tests.Common.ConsoleHost.RunWithOptionsAsync(options).Wait(); }
static async Task RunServerAsync() { var eventListener = new ObservableEventListener(); eventListener.LogToConsole(); eventListener.EnableEvents(DefaultEventSource.Log, EventLevel.Verbose); var bossGroup = new MultithreadEventLoopGroup(1); var workerGroup = new MultithreadEventLoopGroup(); X509Certificate2 tlsCertificate = null; if (EchoServerSettings.IsSsl) { tlsCertificate = new X509Certificate2("dotnetty.com.pfx", "password"); } try { var bootstrap = new ServerBootstrap(); bootstrap .Group(bossGroup, workerGroup) .Channel<TcpServerSocketChannel>() .Option(ChannelOption.SoBacklog, 100) .Handler(new LoggingHandler(LogLevel.INFO)) .ChildHandler(new ActionChannelInitializer<ISocketChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; if (tlsCertificate != null) { pipeline.AddLast(TlsHandler.Server(tlsCertificate)); } pipeline.AddLast(new LengthFieldPrepender(2)); pipeline.AddLast(new LengthFieldBasedFrameDecoder(ushort.MaxValue, 0, 2, 0, 2)); pipeline.AddLast(new EchoServerHandler()); })); IChannel bootstrapChannel = await bootstrap.BindAsync(EchoServerSettings.Port); Console.ReadLine(); await bootstrapChannel.CloseAsync(); } finally { Task.WaitAll(bossGroup.ShutdownGracefullyAsync(), workerGroup.ShutdownGracefullyAsync()); eventListener.Dispose(); } }
static void SimpleEventSource() { // Set up and enable the event listener - typically done when the application starts var listener = new ObservableEventListener(); listener.LogToConsole(); listener.EnableEvents(MyCompanyEventSource.Log, EventLevel.LogAlways, Keywords.All); // Log some messages MyCompanyEventSource.Log.Startup(); MyCompanyEventSource.Log.Failure("Couldn't connect to server."); Console.WriteLine("Written two log messages.\nUsing a basic console listener to capture them."); Console.WriteLine("The color is determined by the severity level.\n"); // Disable the event listener - typically done when the application terminates listener.DisableEvents(MyCompanyEventSource.Log); listener.Dispose(); }
protected void Application_Start() { AreaRegistration.RegisterAllAreas(); FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); var listener = new ObservableEventListener(); listener.EnableEvents(TestEvents.Log, EventLevel.LogAlways, Keywords.All); listener.LogToConsole(); listener.LogToElasticsearch("SLABEL", "http://localhost:9200", "myindex", "mytype", bufferingCount: 1); TestEvents.Log.Critical("Hello world In-Process Critical"); TestEvents.Log.Error("Hello world In-Process Error"); TestEvents.Log.Informational("Hello world In-Process Informational"); }
static void Main() { Application.ThreadException += new System.Threading.ThreadExceptionEventHandler(Application_ThreadException); //create formatter var formatter = new JsonEventTextFormatter(EventTextFormatting.Indented); using (var listener = new ObservableEventListener()) { listener.LogToConsole(formatter); listener.LogToWindowsAzureTable("Calculator", "UseDevelopmentStorage=true;"); listener.EnableEvents(CalculatorEventSource.Log, EventLevel.LogAlways, Keywords.All); Form entryForm = new MainForm(); Application.EnableVisualStyles(); Application.Run(entryForm); } }
private static async Task MainAsync(string[] args) { var observableEventListener = new ObservableEventListener(); var configuration = SimulatorConfiguration.GetCurrentConfiguration(); observableEventListener.EnableEvents(ScenarioSimulatorEventSource.Log, configuration.EventLevel); observableEventListener.LogToConsole(); _deviceSimulator = new SimulationProfile("Console", configuration); // check for scenario specified on the command line if (args.Length > 0) { var scenario = args.Contains("/default", StringComparer.OrdinalIgnoreCase) ? SimulationScenarios.DefaultScenario() : args.First(x => !x.StartsWith("/")); var ct = args.Contains("/webjob", StringComparer.OrdinalIgnoreCase) ? GetWebJobCancellationToken() : CancellationToken.None; await _deviceSimulator.RunSimulationAsync(scenario, ct).ConfigureAwait(false); return; } var options = new Dictionary <string, Func <CancellationToken, Task> >(); options.Add("Provision Devices", ProvisionDevicesAsync); // no command line arguments, so prompt with a menu. foreach (var scenario in SimulationScenarios.AllScenarios) { options.Add("Run " + scenario, (Func <CancellationToken, Task>)(token => _deviceSimulator.RunSimulationAsync(scenario, token))); } //options.Add("Deprovision Devices", DeprovisionDevicesAsync); await Tests.Common.ConsoleHost.RunWithOptionsAsync(options).ConfigureAwait(false); }
static async Task RunServer() { var eventListener = new ObservableEventListener(); eventListener.LogToConsole(); eventListener.EnableEvents(DefaultEventSource.Log, EventLevel.Verbose); var bossGroup = new MultithreadEventLoopGroup(1); var workerGroup = new MultithreadEventLoopGroup(); try { var bootstrap = new ServerBootstrap(); bootstrap .Group(bossGroup, workerGroup) .Channel <TcpServerSocketChannel>() .Option(ChannelOption.SoBacklog, 100) .Handler(new LoggingHandler(LogLevel.INFO)) .ChildHandler(new ActionChannelInitializer <ISocketChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; if (EchoServerSettings.IsSsl) { pipeline.AddLast(TlsHandler.Server(new X509Certificate2("dotnetty.com.pfx", "password"))); } pipeline.AddLast(new EchoServerHandler()); })); IChannel bootstrapChannel = await bootstrap.BindAsync(EchoServerSettings.Port); Console.ReadLine(); await bootstrapChannel.CloseAsync(); } finally { Task.WaitAll(bossGroup.ShutdownGracefullyAsync(), workerGroup.ShutdownGracefullyAsync()); eventListener.Dispose(); } }
static async Task RunClient() { var eventListener = new ObservableEventListener(); eventListener.LogToConsole(); eventListener.EnableEvents(DefaultEventSource.Log, EventLevel.Verbose); var group = new MultithreadEventLoopGroup(); try { var bootstrap = new Bootstrap(); bootstrap .Group(group) .Channel <TcpSocketChannel>() .Option(ChannelOption.TcpNodelay, true) .Handler(new ActionChannelInitializer <ISocketChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; if (EchoClientSettings.IsSsl) { var cert = new X509Certificate2("dotnetty.com.pfx", "password"); string targetHost = cert.GetNameInfo(X509NameType.DnsName, false); pipeline.AddLast(TlsHandler.Client(targetHost, null, (sender, certificate, chain, errors) => true)); } pipeline.AddLast(new EchoClientHandler()); })); IChannel bootstrapChannel = await bootstrap.ConnectAsync(new IPEndPoint(EchoClientSettings.Host, EchoClientSettings.Port)); Console.ReadLine(); await bootstrapChannel.CloseAsync(); } finally { group.ShutdownGracefullyAsync().Wait(1000); eventListener.Dispose(); } }
public void WhenPayloadHasDifferentTypesAndNull() { var consoleOutputInterceptor = new MockConsoleOutputInterceptor(); var formatter = new EventTextFormatter(EventTextFormatter.DashSeparator); var logger = MockEventSourceNoTask.Logger; using (var eventListener = new ObservableEventListener()) { eventListener.LogToConsole(); eventListener.EnableEvents(logger, EventLevel.LogAlways); logger.DifferentTypes(null, 500000); } var entry = Regex.Split(consoleOutputInterceptor.Ouput, formatter.Header).Where(c => !string.IsNullOrWhiteSpace(c)).SingleOrDefault(); Assert.IsNotNull(entry); Assert.IsTrue(entry.Count() > 0); StringAssert.Contains(entry, @"strArg : "); StringAssert.Contains(entry, @"longArg : 500000"); }
public void WhenCriticalVerbosityForFormatter() { var consoleOutputInterceptor = new MockConsoleOutputInterceptor(); var formatter = new EventTextFormatter(EventTextFormatter.DashSeparator); using (var eventListener = new ObservableEventListener()) { eventListener.LogToConsole(formatter); formatter.VerbosityThreshold = EventLevel.Critical; eventListener.EnableEvents(MockConsoleListenerEventSource.Logger, EventLevel.Critical); MockConsoleListenerEventSource.Logger.Critical("This is to log critical in Console"); } var entry = Regex.Split(consoleOutputInterceptor.Ouput, formatter.Header).Where(c => !string.IsNullOrWhiteSpace(c)).SingleOrDefault(); Assert.IsNotNull(entry); StringAssert.Contains(entry, "200"); StringAssert.Contains(entry, "Keywords : None"); Assert.AreEqual(DefaultConsoleColorMapper.Critical, consoleOutputInterceptor.OutputForegroundColor); }
static TestHelpers() { ServiceBusConnectionString = GetTestSetting("ServiceBusConnectionString"); if (string.IsNullOrWhiteSpace(ServiceBusConnectionString)) { throw new ArgumentException("A ServiceBus connection string must be defined in either an environment variable or in configuration."); } StorageConnectionString = GetTestSetting("StorageConnectionString"); if (string.IsNullOrWhiteSpace(StorageConnectionString)) { throw new ArgumentException("A Storage connection string must be defined in either an environment variable or in configuration."); } TaskHubName = ConfigurationManager.AppSettings.Get("TaskHubName"); eventListener = new ObservableEventListener(); eventListener.LogToConsole(); eventListener.EnableEvents(DefaultEventSource.Log, EventLevel.LogAlways); }
public void OpenAndStartServiceHostTest() { eventListener = new ObservableEventListener(); eventListener.LogToConsole(); eventListener.EnableEvents(DefaultEventSource.Log, EventLevel.LogAlways); TraceSource source = new TraceSource("DurableTask"); source.Listeners.AddRange(Trace.Listeners); IOrchestrationServiceInstanceStore instanceStore = new AzureTableInstanceStore(TaskHubName, StorageConnectionString); ServiceBusOrchestrationService orchestrationServiceAndClient = new ServiceBusOrchestrationService(ServiceBusConnectionString, TaskHubName, instanceStore, null, null); orchestrationServiceAndClient.CreateIfNotExistsAsync().Wait(); TaskHubClient taskHubClient = new TaskHubClient(orchestrationServiceAndClient); TaskHubWorker taskHub = new TaskHubWorker(orchestrationServiceAndClient); taskHub.AddTaskOrchestrations(typeof(CounterOrchestration)); taskHub.AddTaskActivities(typeof(Task1), typeof(Task2)); var rnts = ((AzureTableInstanceStore)instanceStore).GetJumpStartEntitiesAsync(1000).Result; var byNameQuery = new OrchestrationStateQuery(); byNameQuery.AddStatusFilter(OrchestrationStatus.Pending); byNameQuery.AddNameVersionFilter(typeof(CounterOrchestration).FullName); var results = ((AzureTableInstanceStore)instanceStore).QueryOrchestrationStatesAsync(byNameQuery).Result; var instance = taskHubClient.CreateOrchestrationInstanceAsync(typeof(CounterOrchestration), Guid.NewGuid().ToString(), new TestOrchestrationInput()).Result; taskHub.StartAsync().Wait(); var state = instanceStore.GetOrchestrationStateAsync(instance.InstanceId, true).Result; var res = taskHubClient.GetOrchestrationHistoryAsync(instance).Result; taskHubClient.WaitForOrchestrationAsync(instance, TimeSpan.MaxValue).Wait(); }
public void WhenSingleLineTextFormatter() { var consoleOutputInterceptor = new MockConsoleOutputInterceptor(); var formatter = new EventTextFormatter(EventTextFormatter.DashSeparator); using (var eventListener = new ObservableEventListener()) { eventListener.LogToConsole(formatter); eventListener.EnableEvents(MockConsoleListenerEventSource.Logger, EventLevel.Error); MockConsoleListenerEventSource.Logger.Critical("This is to log critical in Console"); MockConsoleListenerEventSource.Logger.Verbose("This is should not be logged in Console"); } var entry = Regex.Split(consoleOutputInterceptor.Ouput, formatter.Header).Where(c => !string.IsNullOrWhiteSpace(c)).SingleOrDefault(); Assert.IsNotNull(entry); Assert.IsFalse(entry.Contains("This is should not be logged in Console")); Assert.IsTrue(entry.Contains("This is to log critical in Console")); Assert.IsTrue(entry.Contains("\r\nProviderId : ")); Assert.IsTrue(entry.Contains("\r\nEventId : 200\r\nKeywords : None\r\nLevel : Critical\r\nMessage : Functional Test\r\nOpcode : Info\r\nTask : 65334\r\nVersion : 0\r\nPayload : [message : This is to log critical in Console] \r\nEventName : CriticalInfo\r\nTimestamp :")); }
static void Main(string[] args) { using (var listener = new ObservableEventListener()) { listener.LogToConsole(new ConsoleFormatter()); listener.EnableEvents(EngineEventSource.Log, EventLevel.Verbose, Keywords.All); listener.EnableEvents(TableStorageEventSource.Log, EventLevel.Verbose, Keywords.All); var eventContext = new TableStorageJobEventContext( CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageAccount"))); var host = new JobHost(eventContext); host.Add(new LogCleanupJob()); host.Add(new SendNewsletterJob()); host.Add(new LongRunningJob()); host.Start(); Console.WriteLine("Waiting..."); Console.ReadLine(); } }
public void WhenEventWithMessageInAttribute() { var consoleOutputInterceptor = new MockConsoleOutputInterceptor(); var formatter = new EventTextFormatter(EventTextFormatter.DashSeparator); var eventformatter = new EventTextFormatter("----", "-----", EventLevel.Informational); eventformatter.DateTimeFormat = "dd/MM/yyyy"; var logger = TestEventSourceNoAttributes.Logger; using (var eventListener = new ObservableEventListener()) { eventListener.LogToConsole(eventformatter); eventListener.EnableEvents(logger, EventLevel.LogAlways); logger.ObjectArrayEvent4(1000, "stringstringarg10", 2000, "stringstringarg20", 3000); } var entry = Regex.Split(consoleOutputInterceptor.Ouput, formatter.Header).Where(c => !string.IsNullOrWhiteSpace(c)).SingleOrDefault(); Assert.IsNotNull(entry); StringAssert.Contains(entry, "[arg0 : 1000] [arg1 : stringstringarg10] [arg2 : 2000] [arg3 : stringstringarg20] [arg4 : 3000]"); StringAssert.Contains(entry, "Message : Check if it is logged"); }
public void WhenMultipleEvents() { var consoleOutputInterceptor = new MockConsoleOutputInterceptor(); var formatter = new EventTextFormatter(EventTextFormatter.DashSeparator); var logger = MockConsoleListenerEventSource.Logger; using (var eventListener = new ObservableEventListener()) { eventListener.EnableEvents(logger, EventLevel.LogAlways); eventListener.LogToConsole(); for (int n = 0; n < 300; n++) { logger.Informational("Some message to console " + n); } } var output = Regex.Split(consoleOutputInterceptor.Ouput, formatter.Header).Where(c => !string.IsNullOrWhiteSpace(c)); Assert.IsNotNull(output); StringAssert.Contains(output.First(), "Some message to console 0"); StringAssert.Contains(output.First(), "Some message to console 299"); }
public void WhenEventWithMessageInAttributeUsingXml() { var consoleOutputInterceptor = new MockConsoleOutputInterceptor(); var formatter = new EventTextFormatter(EventTextFormatter.DashSeparator); var xmlFormatter = new XmlEventTextFormatter(); xmlFormatter.DateTimeFormat = "dd/MM/yyyy"; var logger = TestEventSourceNoAttributes.Logger; using (var eventListener = new ObservableEventListener()) { eventListener.LogToConsole(xmlFormatter); eventListener.EnableEvents(logger, EventLevel.LogAlways); logger.ObjectArrayEvent4(1000, "stringstringarg10", 2000, "stringstringarg20", 3000); } var entry = Regex.Split(consoleOutputInterceptor.Ouput, formatter.Header).Where(c => !string.IsNullOrWhiteSpace(c)).SingleOrDefault(); Assert.IsNotNull(entry); StringAssert.Contains(entry, "<Data Name=\"arg0\">1000</Data><Data Name=\"arg1\">stringstringarg10</Data><Data Name=\"arg2\">2000</Data><Data Name=\"arg3\">stringstringarg20</Data><Data Name=\"arg4\">3000</Data>"); StringAssert.Contains(entry, "<Message>Check if it is logged</Message>"); }
public void WhenOneSourceTwoListeners() { var consoleOutputInterceptor = new MockConsoleOutputInterceptor(); var formatter = new EventTextFormatter(EventTextFormatter.DashSeparator); using (var eventListener = new ObservableEventListener()) using (var eventListener2 = new ObservableEventListener()) { eventListener.LogToConsole(new EventTextFormatter(), null); eventListener2.LogToConsole(); string errorMessage = string.Concat("Error ", Guid.NewGuid()); string infoMessage = string.Concat("Message", Guid.NewGuid()); eventListener2.EnableEvents(MockConsoleListenerEventSource.Logger, EventLevel.Error); eventListener.EnableEvents(MockConsoleListenerEventSource.Logger, EventLevel.Informational); MockConsoleListenerEventSource.Logger.Informational(infoMessage); MockConsoleListenerEventSource.Logger.Error(errorMessage); var entry = Regex.Split(consoleOutputInterceptor.Ouput, formatter.Header).Where(c => !string.IsNullOrWhiteSpace(c)).SingleOrDefault(); Assert.IsNotNull(entry); StringAssert.Contains(entry, "100"); StringAssert.Contains(entry, "300"); } }
private static async Task MainAsync(string[] args) { var observableEventListener = new ObservableEventListener(); var configuration = SimulatorConfiguration.GetCurrentConfiguration(); observableEventListener.EnableEvents(ScenarioSimulatorEventSource.Log, configuration.EventLevel); observableEventListener.LogToConsole(); var deviceSimulator = new SimulationProfile("Console", 1, configuration); // check for scenario specified on the command line if (args.Length > 0) { var scenario = args.Contains("/default", StringComparer.OrdinalIgnoreCase) ? SimulationScenarios.DefaultScenario() : args.First(x => !x.StartsWith("/")); var ct = args.Contains("/webjob", StringComparer.OrdinalIgnoreCase) ? GetWebJobCancellationToken() : CancellationToken.None; await deviceSimulator.RunSimulationAsync(scenario, ct); return; } // no command line arguments, so prompt with a menu var options = SimulationScenarios .AllScenarios .ToDictionary( scenario => "Run " + scenario, scenario => (Func<CancellationToken, Task>)(token => deviceSimulator.RunSimulationAsync(scenario, token))); await Tests.Common.ConsoleHost.RunWithOptionsAsync(options); }
static void Main(string[] args) { #region SLAB var ObservableEventListener = new ObservableEventListener(); ObservableEventListener.EnableEvents(ControllerEvents.Log, EventLevel.LogAlways, Keywords.All); ObservableEventListener.EnableEvents(GlobalEvents.Log, EventLevel.LogAlways, Keywords.All); ObservableEventListener.EnableEvents(HubClientEvents.Log, EventLevel.LogAlways, Keywords.All); var formatter = new PrefixEventTextFormatter("-----------", null, "# ", @"yyyy-MM-dd hh\:mm\:ss\.fff"); ObservableEventListener.LogToConsole(formatter); #endregion string name = "AA"; var myHubClient = new MyHubClient(); while (true) { string key = Console.ReadLine(); if (key.ToUpper() == "A") { if (myHubClient.State == ConnectionState.Connected) { myHubClient.SendAllClient(name, "hello all"); } else { HubClientEvents.Log.Warning("Can't send message, connectionState= " + myHubClient.State); } } if (key.ToUpper() == "B") { if (myHubClient.State == ConnectionState.Connected) { myHubClient.SendToSingle(Console.ReadLine(), name, "hello world"); } else { HubClientEvents.Log.Warning("Can't send message, connectionState= " + myHubClient.State); } } if (key.ToUpper() == "H") { if (myHubClient.State == ConnectionState.Connected) { myHubClient.Heartbeat(); } else { HubClientEvents.Log.Warning("Can't send message, connectionState= " + myHubClient.State); } } if (key.ToUpper() == "S") { name = Console.ReadLine(); if (myHubClient.State == ConnectionState.Connected) { myHubClient.Subscribe(name); } else { HubClientEvents.Log.Warning("Can't send message, connectionState= " + myHubClient.State); } } if (key.ToUpper() == "Q") { if (myHubClient.State == ConnectionState.Connected) { myHubClient.Unsubscribe(name); } else { HubClientEvents.Log.Warning("Can't send message, connectionState= " + myHubClient.State); } } if (key.ToUpper() == "C") { myHubClient.CloseHub(); HubClientEvents.Log.Informational("Closed Hub"); } } }
private void EnableNonTransientErrorsHandling() { var observable = new ObservableEventListener(); this.slabNonTransientErrors = observable; if (this.consoleMode) { observable.LogToConsole(); } else { observable.Subscribe(new ServiceEventLogSink(this.EventLog)); } EventLevel level; if (!Enum.TryParse(ConfigurationManager.AppSettings[NonTransientErrorsEventLevelKey], out level)) { level = EventLevel.LogAlways; } this.slabNonTransientErrors.EnableEvents(SemanticLoggingEventSource.Log, level, Keywords.All); // Capture any unhandled error in worker threads AppDomain.CurrentDomain.UnhandledException += this.OnAppDomainUnhandledException; // Handle unobserved task exceptions TaskScheduler.UnobservedTaskException += this.OnUnobservedTaskException; }
static void Main(string[] args) { var listener = new ObservableEventListener(); listener.EnableEvents(RxFloodQuickStartEventSource.Log, EventLevel.LogAlways, Keywords.All); // ThrottleEventsWithEventId is a custom extension method that shows how you can leverage the power of Reactive Extensions (Rx) // to perform filtering (or transformation) of the event stream before it is sent to the underlying sink. // In this case, ThrottleEventsWithEventId will throttle entries with EventID=4 and mute additional occurrences for 15 seconds. // This prevents a particular event from flooding the log sink, making it difficult to diagnose other issues. // This can be useful in the case that a high-throughput event does not have a keyword or verbosity setting that makes it easy // to exclude it in the call to listener.EnableEvents(EventSource, EventLevel, EventKeywords). // Note: For basic scenarios without this extra filtering, you DO NOT need to use Rx, and SLAB does not depend on it. var subscription = listener .ThrottleEventsWithEventId(TimeSpan.FromSeconds(15), ThrottledEventId) .LogToConsole(SingleLineFormatter); // The previous custom extension method (ThrottleEventsWithEventId) is all that is needed to call to throttle // an event that is flooding the log. // The rest of the code in this QuickStart is here to show an interactive demo of how it looks if this filter is turned on or off. bool currentlyThrottling = true; var cts = new CancellationTokenSource(); Console.WriteLine("This program simulates the scenario of a particular event being logged multiple times in succession when a certain condition occurs,"); Console.WriteLine("such as when there is a transient or expected connectivity error during system upgrades."); Console.WriteLine(); Console.WriteLine("While the application is logging messages, use the following commands:"); Console.WriteLine(" [ESC] Exists the application."); Console.WriteLine(" [Spacebar] Toggles the throttling filter."); Console.WriteLine(); Console.WriteLine(); Console.WriteLine("Press any key to start doing background work."); var key = Console.ReadKey(false); if (key.Key == ConsoleKey.Escape) { return; } DoBackgroundWork(cts.Token); while (!cts.IsCancellationRequested) { key = Console.ReadKey(false); switch (key.Key) { case ConsoleKey.Spacebar: subscription.Dispose(); if (currentlyThrottling) { Console.WriteLine("Filter toggled: event entries will not be throttled. In this scenario, if there is no post-filtering of events, important messages could go unnoticed."); Thread.Sleep(TimeSpan.FromSeconds(3)); currentlyThrottling = false; // Note that the events are sent directly to the console, without using Reactive Extensions. subscription = listener .LogToConsole(SingleLineFormatter); } else { Console.WriteLine("Filter toggled: event entries with ID {0} will be throttled for 15 seconds to prevent that type of entry to flood the log.", ThrottledEventId); Thread.Sleep(TimeSpan.FromSeconds(3)); currentlyThrottling = true; // Note that the events are filtered first and then sent to the console, using Reactive Extensions. subscription = listener .ThrottleEventsWithEventId(TimeSpan.FromSeconds(15), ThrottledEventId) .LogToConsole(SingleLineFormatter); } break; case ConsoleKey.Escape: cts.Cancel(); break; } } listener.Dispose(); }
static void Main(string[] args) { eventListener = new ObservableEventListener(); eventListener.LogToConsole(); eventListener.EnableEvents(DefaultEventSource.Log, EventLevel.LogAlways); if (CommandLine.Parser.Default.ParseArgumentsStrict(args, ArgumentOptions)) { string serviceBusConnectionString = GetSetting("ServiceBusConnectionString"); string storageConnectionString = GetSetting("StorageConnectionString"); string taskHubName = ConfigurationManager.AppSettings["taskHubName"]; //IOrchestrationServiceInstanceStore instanceStore = new AzureTableInstanceStore(taskHubName, storageConnectionString); //var orchestrationServiceAndClient = // new ServiceBusOrchestrationService(serviceBusConnectionString, taskHubName, instanceStore, null, null); var orchestrationServiceAndClient = new DurableTask.Emulator.LocalOrchestrationService(); var taskHubClient = new TaskHubClient(orchestrationServiceAndClient); var taskHub = new TaskHubWorker(orchestrationServiceAndClient); if (ArgumentOptions.CreateHub) { orchestrationServiceAndClient.CreateIfNotExistsAsync().Wait(); } OrchestrationInstance instance = null; if (!string.IsNullOrWhiteSpace(ArgumentOptions.StartInstance)) { string instanceId = ArgumentOptions.InstanceId ?? Guid.NewGuid().ToString(); Console.WriteLine($"Start Orchestration: {ArgumentOptions.StartInstance}"); switch (ArgumentOptions.StartInstance) { case "Greetings": instance = taskHubClient.CreateOrchestrationInstanceAsync(typeof(GreetingsOrchestration), instanceId, null).Result; break; case "Greetings2": if (ArgumentOptions.Parameters == null || ArgumentOptions.Parameters.Length != 1) { throw new ArgumentException("parameters"); } instance = taskHubClient.CreateOrchestrationInstanceAsync(typeof(GreetingsOrchestration2), instanceId, int.Parse(ArgumentOptions.Parameters[0])).Result; break; case "Cron": // Sample Input: "0 12 * */2 Mon" instance = taskHubClient.CreateOrchestrationInstanceAsync(typeof(CronOrchestration), instanceId, (ArgumentOptions.Parameters != null && ArgumentOptions.Parameters.Length > 0) ? ArgumentOptions.Parameters[0] : null).Result; break; case "Average": // Sample Input: "1 50 10" if (ArgumentOptions.Parameters == null || ArgumentOptions.Parameters.Length != 3) { throw new ArgumentException("parameters"); } int[] input = ArgumentOptions.Parameters.Select(p => int.Parse(p)).ToArray(); instance = taskHubClient.CreateOrchestrationInstanceAsync(typeof(AverageCalculatorOrchestration), instanceId, input).Result; break; case "ErrorHandling": instance = taskHubClient.CreateOrchestrationInstanceAsync(typeof(ErrorHandlingOrchestration), instanceId, null).Result; break; case "SumOfSquares": instance = taskHubClient.CreateOrchestrationInstanceAsync( "SumOfSquaresOrchestration", "V1", instanceId, File.ReadAllText("SumofSquares\\BagOfNumbers.json"), new Dictionary <string, string>(1) { { "Category", "testing" } }).Result; break; case "Signal": instance = taskHubClient.CreateOrchestrationInstanceAsync(typeof(SignalOrchestration), instanceId, null).Result; break; case "SignalAndRaise": if (ArgumentOptions.Parameters == null || ArgumentOptions.Parameters.Length != 1) { throw new ArgumentException("parameters"); } instance = taskHubClient.CreateOrchestrationInstanceWithRaisedEventAsync(typeof(SignalOrchestration), instanceId, null, ArgumentOptions.Signal, ArgumentOptions.Parameters[0]).Result; break; case "Replat": instance = taskHubClient.CreateOrchestrationInstanceAsync(typeof(MigrateOrchestration), instanceId, new MigrateOrchestrationData { SubscriptionId = "03a1cd39-47ac-4a57-9ff5-a2c2a2a76088", IsDisabled = false }).Result; break; default: throw new Exception("Unsupported Orchestration Name: " + ArgumentOptions.StartInstance); } Console.WriteLine("Workflow Instance Started: " + instance); } else if (!string.IsNullOrWhiteSpace(ArgumentOptions.Signal)) { Console.WriteLine("Run RaiseEvent"); if (string.IsNullOrWhiteSpace(ArgumentOptions.InstanceId)) { throw new ArgumentException("instanceId"); } if (ArgumentOptions.Parameters == null || ArgumentOptions.Parameters.Length != 1) { throw new ArgumentException("parameters"); } string instanceId = ArgumentOptions.InstanceId; instance = new OrchestrationInstance { InstanceId = instanceId }; taskHubClient.RaiseEventAsync(instance, ArgumentOptions.Signal, ArgumentOptions.Parameters[0]).Wait(); Console.WriteLine("Press any key to quit."); Console.ReadLine(); } if (!ArgumentOptions.SkipWorker) { try { taskHub.AddTaskOrchestrations( typeof(GreetingsOrchestration), typeof(GreetingsOrchestration2), typeof(CronOrchestration), typeof(AverageCalculatorOrchestration), typeof(ErrorHandlingOrchestration), typeof(SignalOrchestration), typeof(MigrateOrchestration), typeof(SumOfSquaresOrchestration) ); taskHub.AddTaskOrchestrations( new NameValueObjectCreator <TaskOrchestration>("SumOfSquaresOrchestration", "V1", typeof(SumOfSquaresOrchestration))); taskHub.AddTaskActivities( new GetUserTask(), new SendGreetingTask(), new CronTask(), new ComputeSumTask(), new GoodTask(), new BadTask(), new CleanupTask(), new EmailTask(), new SumOfSquaresTask() ); taskHub.AddTaskActivitiesFromInterface <IManagementSqlOrchestrationTasks>(new ManagementSqlOrchestrationTasks()); taskHub.AddTaskActivitiesFromInterface <IMigrationTasks>(new MigrationTasks()); taskHub.StartAsync().Wait(); Console.WriteLine("Waiting up to 60 seconds for completion."); OrchestrationState taskResult = taskHubClient.WaitForOrchestrationAsync(instance, TimeSpan.FromSeconds(60), CancellationToken.None).Result; Console.WriteLine($"Task done: {taskResult?.OrchestrationStatus}"); Console.WriteLine("Press any key to quit."); Console.ReadLine(); taskHub.StopAsync(true).Wait(); } catch (Exception e) { // silently eat any unhandled exceptions. Console.WriteLine($"worker exception: {e}"); } } else { Console.WriteLine("Skip Worker"); } } }
/// <summary> /// Creates an event listener that logs using a <see cref="ConsoleSink"/>. /// </summary> /// <param name="formatter">The formatter.</param> /// <param name="colorMapper">The color mapper instance.</param> /// <returns>An event listener that uses <see cref="ConsoleSink"/> to display events.</returns> public static EventListener CreateListener(IEventTextFormatter formatter = null, IConsoleColorMapper colorMapper = null) { var listener = new ObservableEventListener(); listener.LogToConsole(formatter, colorMapper); return listener; }
/// <summary> /// Initializes a new instance of the <see cref="RedisCacheManagerTests"/> class. /// </summary> public RedisCacheManagerTests() { activityEventListener = new ObservableEventListener(); activityEventListener.EnableEvents(ActivityLoggingEventSource.Log, EventLevel.LogAlways); activityEventListener.LogToConsole(); }
//[Ignore("Depends on NorthWind database on local SQL Server.")] public void TestProfileAndExportDatabaseTable() { var listener = new ObservableEventListener(); listener.EnableEvents(TflEventSource.Log, EventLevel.Verbose); var subscription = listener.LogToConsole(new LegacyLogFormatter()); var result = new Profiler().Profile("localhost.NorthWind.dbo.Customers"); new ProfileExporter().Export(result); subscription.Dispose(); listener.DisableEvents(TflEventSource.Log); listener.Dispose(); Assert.NotNull(result); }
static void SimpleEventSourceWithXMLFormatter() { // Set up and enable the event listener - typically done when the application starts var listener = new ObservableEventListener(); listener.LogToConsole(new XmlEventTextFormatter(EventTextFormatting.Indented)); listener.EnableEvents(MyCompanyEventSource.Log, EventLevel.LogAlways, Keywords.All); // Log some messages MyCompanyEventSource.Log.Startup(); MyCompanyEventSource.Log.Failure("Couldn't connect to server."); Console.WriteLine("Written two log messages.\nUsing a console listener with an XML formatter to capture them."); // Disable the event listener - typically done when the application terminates listener.DisableEvents(MyCompanyEventSource.Log); listener.Dispose(); }
static void SimpleEventSourceWithColorMapper() { // Set up and enable the event listener - typically done when the application starts var listener = new ObservableEventListener(); listener.LogToConsole(new JsonEventTextFormatter(EventTextFormatting.Indented), new MyCustomColorMapper()); listener.EnableEvents(MyCompanyEventSource.Log, EventLevel.LogAlways, Keywords.All); // Log some messages MyCompanyEventSource.Log.Startup(); MyCompanyEventSource.Log.PageStop(99); Console.WriteLine("Written two log messages.\nUsing a console listener with a JSON formatter to capture them."); // Disable the event listener - typically done when the application terminates listener.DisableEvents(MyCompanyEventSource.Log); listener.Dispose(); }
static void MultipleEventListenersLevel() { // Set up and enable the event listeners - typically done when the application starts var listener1 = new ObservableEventListener(); var listener2 = new ObservableEventListener(); listener1.EnableEvents(MyCompanyEventSource.Log, EventLevel.Error, Keywords.All); listener2.EnableEvents(MyCompanyEventSource.Log, EventLevel.LogAlways, Keywords.All); listener1.LogToConsole(); var subscription = listener2.LogToFlatFile(@"C:\Temp\DemoSemanticLogging.log", new EventTextFormatter("===================", "===================")); // Log some messages MyCompanyEventSource.Log.Startup(); MyCompanyEventSource.Log.Failure("Couldn't connect to server."); Console.WriteLine("Written two log messages.\nUsing a basic console listener and a Flat File listener to capture them."); Console.WriteLine("Only the critical message appears in the console, both appear in: \nC:\\Temp\\DemoSemanticLogging.log.\n"); // Flush the sink subscription.Sink.FlushAsync().Wait(); // Disable the event listener - typically done when the application terminates listener1.DisableEvents(MyCompanyEventSource.Log); listener2.DisableEvents(MyCompanyEventSource.Log); listener1.Dispose(); listener2.Dispose(); }
static void MultipleEventListenersKeywords() { var listener1 = new ObservableEventListener(); var listener2 = new ObservableEventListener(); listener1.EnableEvents(MyCompanyEventSource.Log, EventLevel.LogAlways, MyCompanyEventSource.Keywords.Perf | MyCompanyEventSource.Keywords.Diagnostic); listener2.EnableEvents(MyCompanyEventSource.Log, EventLevel.LogAlways, Keywords.All); // Set up and enable the event listeners - typically done when the application starts listener1.LogToConsole(); // The SinkSubscription is used later to flush the buffer var subscription = listener2.LogToSqlDatabase("Demo Semantic Logging Instance", connectionString); // Log some messages MyCompanyEventSource.Log.PageStart(23, "http://mysite/demopage"); MyCompanyEventSource.Log.Startup(); MyCompanyEventSource.Log.Failure("Couldn't connect to server."); Console.WriteLine("Written three log messages.\nUsing a basic console listener and a SQL listener to capture them."); Console.WriteLine("Only the messages with the Perf or Diagnostic keywords appears in the console, \nall three appear in the SQL Database:\n"); // Disable the event listener - typically done when the application terminates listener1.DisableEvents(MyCompanyEventSource.Log); listener2.DisableEvents(MyCompanyEventSource.Log); // Manually flush the buffer so you can see what's in the database subscription.Sink.FlushAsync().Wait(); ShowContentsOfSqlDatabaseTable(); listener1.Dispose(); listener2.Dispose(); }