// 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) { //loggerFactory // .AddConsole(Configuration.GetSection("Logging")) // .AddDebug(); Log.Logger = new LoggerConfiguration() .MinimumLevel.Verbose() .WriteTo.ColoredConsole(LogEventLevel.Verbose, "{Timestamp:yyyy-MM-dd HH:mm:ss} [{Level}] {Message}{NewLine}{OzzyEvent}") .CreateLogger(); var listener = new ObservableEventListener(); listener.EnableEvents(OzzyLogger <ICommonEvents> .LogEventSource, EventLevel.LogAlways); listener.EnableEvents(OzzyLogger <IDomainModelTracing> .LogEventSource, EventLevel.Informational); listener.EnableEvents(OzzyLogger <IDistibutedLockEvents> .LogEventSource, EventLevel.LogAlways); var log = loggerFactory.CreateLogger <OzzyLoggerValue>(); var parser = new MessageTemplateParser(); listener.Subscribe(new SimpleEventObserver(e => { var logEntry = new LogEvent(DateTime.UtcNow, GetSerilogLevel(e.Level), null, new MessageTemplate(new MessageTemplateToken[] { new TextToken(string.Format(e.Message, e.Payload.ToArray()), 0) }), e.Payload.Select((p, i) => new LogEventProperty(e.PayloadNames[i], new ScalarValue(p))).Append(new LogEventProperty("OzzyEvent", new OzzyDictionaryValue(e))) ); Log.Logger.Write(logEntry); //log.Log(LogLevel.Information, new EventId(e.EventId), e, null, (s, ex) => string.Format(s.Message, s.Payload.ToArray())); })); //if (env.IsDevelopment()) //{ // app.UseDeveloperExceptionPage(); // app.UseBrowserLink(); //} //else //{ // app.UseExceptionHandler("/Home/Error"); //} //app.UseStaticFiles(); app.UseCors(builder => builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader()); app.UseMvc(routes => { routes.MapRoute( name: "default", template: "{controller=Home}/{action=Index}/{id?}"); }); app.UseOzzy().Start(); }
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(DefaultEventSource.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 void ConfigureLogging() { eventListener = new ObservableEventListener(); eventListener.EnableEvents(SparkEngineEventSource.Log, EventLevel.LogAlways, Keywords.All); eventListener.EnableEvents(SparkMongoEventSource.Log, EventLevel.LogAlways, Keywords.All); eventListener.EnableEvents(SemanticLoggingEventSource.Log, EventLevel.LogAlways, Keywords.All); var formatter = new JsonEventTextFormatter(EventTextFormatting.Indented); eventListener.LogToFlatFile(@"C:\projects\fhir\log\spark.log", formatter); }
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(bool console, string logPath, string traceNames) { Listener.EnableEvents((EventSource)Harmonize.Instrumentation.Error, EventLevel.Warning, Keywords.All); Listener.EnableEvents((EventSource)Harmonize.Instrumentation.Harmonization, EventLevel.LogAlways, Keywords.All); traceNames.Split(',').Select(name => name.Trim()).ForEach(name => Listener.EnableEvents(name, EventLevel.LogAlways, Keywords.All)); Subscription = console ? (IDisposable)Listener.LogToConsole() : (IDisposable)Listener.LogToRollingFlatFile(logPath, 1048576, "yyyymmddhhMMss", RollFileExistsBehavior.Increment, RollInterval.Midnight, new EventTextFormatter(null, null, EventLevel.LogAlways)); }
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(); } } }
async Task RunAsync(CancellationToken cancellationToken) { var settingsProvider = new RoleEnvironmentSettingsProvider(); var eventListener = new ObservableEventListener(); eventListener.LogToWindowsAzureTable(RoleEnvironment.CurrentRoleInstance.Id, settingsProvider.GetSetting("BlobSessionStatePersistenceProvider.StorageConnectionString"), bufferingInterval: TimeSpan.FromMinutes(2)); eventListener.EnableEvents(BootstrapperEventSource.Log, EventLevel.Informational); eventListener.EnableEvents(MqttIotHubAdapterEventSource.Log, EventLevel.Informational); eventListener.EnableEvents(DefaultEventSource.Log, EventLevel.Informational); int minWorkerThreads; int minCompletionPortThreads; ThreadPool.GetMinThreads(out minWorkerThreads, out minCompletionPortThreads); ThreadPool.SetMinThreads(minWorkerThreads, Math.Max(16, minCompletionPortThreads)); int threadCount = Environment.ProcessorCount; BlobSessionStatePersistenceProvider blobSessionStateProvider = await BlobSessionStatePersistenceProvider.CreateAsync( settingsProvider.GetSetting("BlobSessionStatePersistenceProvider.StorageConnectionString"), settingsProvider.GetSetting("BlobSessionStatePersistenceProvider.StorageContainerName")); TableQos2StatePersistenceProvider tableQos2StateProvider = await TableQos2StatePersistenceProvider.CreateAsync( settingsProvider.GetSetting("TableQos2StatePersistenceProvider.StorageConnectionString"), settingsProvider.GetSetting("TableQos2StatePersistenceProvider.StorageTableName")); var bootstrapper = new Bootstrapper( settingsProvider, blobSessionStateProvider, tableQos2StateProvider); X509Certificate2 tlsCertificate = GetTlsCertificate(settingsProvider.GetSetting("TlsCertificateThumbprint"), StoreName.My, StoreLocation.LocalMachine); try { await bootstrapper.RunAsync(tlsCertificate, threadCount, cancellationToken); } catch (Exception ex) { Trace.TraceError(ex.ToString()); throw; } await bootstrapper.CloseCompletion; }
public void WhenEventWithEnumsInPayloadIsRaised() { this.tableName = "WhenEventWithEnumsInPayloadIsRaised"; var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"]; AzureTableHelper.DeleteTable(connectionString, this.tableName); var logger = MockEventSourceInProcEnum.Logger; using (var listener = new ObservableEventListener()) { try { listener.LogToWindowsAzureTable("mytestinstance1", connectionString, this.tableName, bufferingInterval: TimeSpan.Zero); listener.EnableEvents(logger, EventLevel.LogAlways); logger.SendEnumsEvent17(MockEventSourceInProcEnum.MyColor.Green, MockEventSourceInProcEnum.MyFlags.Flag2); } finally { listener.DisableEvents(logger); } } var events = AzureTableHelper.PollForEvents(connectionString, this.tableName, 1); Assert.AreEqual(1, events.Count()); Assert.AreEqual((int)EventTask.None, events.ElementAt(0).Task); Assert.AreEqual((int)EventOpcode.Resume, events.ElementAt(0).Opcode); Assert.AreEqual("{\n \"a\": 2,\n \"b\": 2\n}", events.ElementAt(0).Payload.ToString()); }
public void WhenEventWithTaskNameInAttributeIsRaised() { this.tableName = "WhenEventWithTaskNameInAttributeIsRaised"; var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"]; AzureTableHelper.DeleteTable(connectionString, this.tableName); var logger = TestEventSource.Logger; using (var listener = new ObservableEventListener()) { try { listener.LogToWindowsAzureTable("mytestinstance", connectionString, this.tableName, bufferingInterval: TimeSpan.FromSeconds(10)); listener.EnableEvents(logger, EventLevel.LogAlways, Keywords.All); logger.CriticalWithTaskName("Critical with task name"); logger.CriticalWithKeywordPage("Critical with no task name"); } finally { listener.DisableEvents(logger); } } var events = AzureTableHelper.PollForEvents(connectionString, this.tableName, 2); Assert.AreEqual(2, events.Count()); Assert.AreEqual("64513", events.First().Task.ToString()); Assert.AreEqual("1", events.ElementAt(1).Task.ToString()); }
public void WhenLoggingMultipleMessages() { this.tableName = "WhenLoggingMultipleMessages"; var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"]; AzureTableHelper.DeleteTable(connectionString, this.tableName); var logger = TestEventSource.Logger; using (var listener = new ObservableEventListener()) { try { listener.LogToWindowsAzureTable("mytestinstance", connectionString, this.tableName); listener.EnableEvents(logger, EventLevel.LogAlways); for (int n = 0; n < 300; n++) { logger.Informational("logging multiple messages " + n.ToString()); } } finally { listener.DisableEvents(logger); } } var events = AzureTableHelper.PollForEvents(connectionString, this.tableName, 300); Assert.AreEqual(300, events.Count()); }
public void WhenNotEnabledWithKeywordsAndEventWithSpecificKeywordIsRaised() { this.tableName = "WhenNotEnabledWithKeywordsAndEventWithSpecificKeywordIsRaised"; var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"]; AzureTableHelper.DeleteTable(connectionString, this.tableName); var logger = TestEventSource.Logger; using (var listener = new ObservableEventListener()) { try { listener.LogToWindowsAzureTable("mytestinstance", connectionString, this.tableName, bufferingInterval: TimeSpan.FromSeconds(10)); listener.EnableEvents(logger, EventLevel.LogAlways); logger.ErrorWithKeywordDiagnostic("Error with keyword EventlogClassic"); } finally { listener.DisableEvents(logger); } } var eventsCount = AzureTableHelper.GetEventsCount(connectionString, this.tableName); Assert.AreEqual(0, eventsCount); }
public void WhenBufferIntervalExceedsAndLessEntriesThanBufferCount() { this.tableName = "WhenBufferIntervalExceedsAndLessEntriesThanBufferCount"; var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"]; AzureTableHelper.DeleteTable(connectionString, this.tableName); var logger = TestEventSource.Logger; using (var listener = new ObservableEventListener()) { try { var bufferingInterval = TimeSpan.FromSeconds(2); listener.LogToWindowsAzureTable("mytestinstance", connectionString, this.tableName, bufferingInterval: bufferingInterval); listener.EnableEvents(logger, EventLevel.Informational); // 100 events or more will be flushed by count before the buffering interval elapses for (int i = 0; i < 90; i++) { logger.Informational("Message1"); } // Wait for buffer interval to elapse and allow time for events to be written Task.Delay(bufferingInterval.Add(TimeSpan.FromSeconds(2))).Wait(); var events = AzureTableHelper.GetEventsCount(connectionString, this.tableName); Assert.AreEqual(90, events); } finally { listener.DisableEvents(logger); } } }
public void WhenEventsWithDifferentLevels() { this.tableName = "WhenEventsWithDifferentLevels"; var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"]; AzureTableHelper.DeleteTable(connectionString, this.tableName); var logger = TestEventSource.Logger; using (var listener = new ObservableEventListener()) { try { listener.LogToWindowsAzureTable("mytestinstance", connectionString, this.tableName, bufferingInterval: TimeSpan.FromSeconds(1)); listener.EnableEvents(logger, EventLevel.LogAlways); logger.Critical("This is a critical message"); logger.Error("This is an error message"); logger.Informational("This is informational"); } finally { listener.DisableEvents(logger); } } var events = AzureTableHelper.PollForEvents(connectionString, this.tableName, 3); Assert.AreEqual(3, events.Count()); Assert.AreEqual(TestEventSource.InformationalEventId, events.ElementAt(0).EventId); Assert.AreEqual(TestEventSource.ErrorEventId, events.ElementAt(1).EventId); Assert.AreEqual(TestEventSource.CriticalEventId, events.ElementAt(2).EventId); }
public void UnderReleaseBufferLeak() { ResourceLeakDetector.DetectionLevel preservedLevel = ResourceLeakDetector.Level; try { ResourceLeakDetector.Level = ResourceLeakDetector.DetectionLevel.Paranoid; var eventListener = new ObservableEventListener(); Mock <IObserver <EventEntry> > logListener = this.mockRepo.Create <IObserver <EventEntry> >(); var eventTextFormatter = new EventTextFormatter(); Func <EventEntry, bool> leakPredicate = y => y.TryFormatAsString(eventTextFormatter).Contains("LEAK"); logListener.Setup(x => x.OnNext(It.Is <EventEntry>(y => leakPredicate(y)))).Verifiable(); logListener.Setup(x => x.OnNext(It.Is <EventEntry>(y => !leakPredicate(y)))); eventListener.Subscribe(logListener.Object); eventListener.EnableEvents(DefaultEventSource.Log, EventLevel.Verbose); this.CreateAndForgetBuffer(); GC.Collect(); GC.WaitForPendingFinalizers(); this.mockRepo.Verify(); } finally { ResourceLeakDetector.Level = preservedLevel; } }
public void UnderReleaseBufferLeak() { ResourceLeakDetector.DetectionLevel preservedLevel = ResourceLeakDetector.Level; try { ResourceLeakDetector.Level = ResourceLeakDetector.DetectionLevel.Paranoid; var eventListener = new ObservableEventListener(); Mock<IObserver<EventEntry>> logListener = this.mockRepo.Create<IObserver<EventEntry>>(); var eventTextFormatter = new EventTextFormatter(); Func<EventEntry, bool> leakPredicate = y => y.TryFormatAsString(eventTextFormatter).Contains("LEAK"); logListener.Setup(x => x.OnNext(It.Is<EventEntry>(y => leakPredicate(y)))).Verifiable(); logListener.Setup(x => x.OnNext(It.Is<EventEntry>(y => !leakPredicate(y)))); eventListener.Subscribe(logListener.Object); eventListener.EnableEvents(DefaultEventSource.Log, EventLevel.Verbose); this.CreateAndForgetBuffer(); GC.Collect(); GC.WaitForPendingFinalizers(); this.mockRepo.Verify(); } finally { ResourceLeakDetector.Level = preservedLevel; } }
public async Task TestEventSink() { var listener = new TcpListener(IPAddress.Loopback, 0); listener.Start(); int port = ((IPEndPoint)listener.Server.LocalEndPoint).Port; var slabListener = new ObservableEventListener(); slabListener.Subscribe(new TcpEventSink(IPAddress.Loopback, port, new ExponentialBackoffTcpReconnectionPolicy(), new TestEventFormatter())); var source = TestEventSource.GetInstance(); slabListener.EnableEvents(source, EventLevel.LogAlways, Keywords.All); var listenerClient = await listener.AcceptTcpClientAsync(); source.Message("Boris", "Meep"); var receiverReader = new StreamReader(listenerClient.GetStream()); var line = await receiverReader.ReadLineAsync(); Assert.Equal( "EventId=1 EventName=MessageInfo Level=Error \"FormattedMessage=Meep - Boris\" \"message=Boris\" \"caller=Meep\"", line); listenerClient.Close(); listener.Stop(); slabListener.Dispose(); }
public static SinkSubscription <FlatFileSink> CreateSink(EventSource eventSource, string path) { ObservableEventListener _listener = new ObservableEventListener(); _listener.EnableEvents(eventSource, EventLevel.LogAlways, Keywords.All); return(_listener.LogToFlatFile(path)); }
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)); }
public async Task TestUdpEventSink() { int port = 11001; var udpclient = new UdpClient(port); var slabListener = new ObservableEventListener(); slabListener.Subscribe(new UdpEventSink(IPAddress.Loopback, port, new TestEventFormatter())); var source = TestEventSource.GetInstance(); slabListener.EnableEvents(source, EventLevel.LogAlways, Keywords.All); var t = udpclient.ReceiveAsync(); source.Message("Boris", "Meep"); var receivedText = Encoding.UTF8.GetString((await t).Buffer); Assert.Equal( "EventId=1 EventName=MessageInfo Level=Error \"FormattedMessage=Meep - Boris\" \"message=Boris\" \"caller=Meep\"\r\n", receivedText); udpclient.Close(); slabListener.Dispose(); }
public void WhenUsingCustomSinkAndMultipleEvents() { string fileName = "ProvidedCustomSink.log"; File.Delete(fileName); var logger = MockEventSource.Logger; IEnumerable <string> entries = null; using (var eventListener = new ObservableEventListener()) { try { eventListener.LogToMockFlatFile(fileName, "==-=="); eventListener.EnableEvents(logger, System.Diagnostics.Tracing.EventLevel.LogAlways, Keywords.All); logger.LogSomeMessage("some message"); logger.LogSomeMessage("some message2"); logger.LogSomeMessage("some message3"); entries = FlatFileHelper.PollUntilTextEventsAreWritten(fileName, 3, "==-=="); } finally { eventListener.DisableEvents(logger); } } Assert.IsTrue(File.Exists(fileName)); Assert.AreEqual <int>(3, entries.Count()); Assert.IsNotNull(entries.SingleOrDefault(e => e.Contains("Payload : [message : some message]"))); Assert.IsNotNull(entries.SingleOrDefault(e => e.Contains("Payload : [message : some message2]"))); Assert.IsNotNull(entries.SingleOrDefault(e => e.Contains("Payload : [message : some message3]"))); }
private void EnableLoggingListener() { listener = new ObservableEventListener(); listener.LogToWindowsAzureTable("CustomEvents", "DefaultEndpointsProtocol=https;AccountName=musiccloudstorage;AccountKey=..."); //listener.EnableEvents(AuditEvent.Log, EventLevel.LogAlways, Keywords.All); listener.EnableEvents(ErrorEvent.Log, EventLevel.LogAlways, Keywords.All); }
/// <summary> /// This program hosts a Web API that has a controller decorated with a PerfIt filter and then /// sends an HTTP request to instrument. /// Since it is net452, it will raise ETW that can be captured by Enterprise Library. Note listener.LogToConsole(); /// </summary> /// <param name="args"></param> static void Main(string[] args) { string baseAddress = "http://localhost:34543/"; var configuration = new HttpSelfHostConfiguration(baseAddress); configuration.Routes.Add("def", new HttpRoute("api/{controller}")); var server = new HttpSelfHostServer(configuration); server.OpenAsync().Wait(); var listener = new ObservableEventListener(); listener.EnableEvents(InstrumentationEventSource.Instance, EventLevel.LogAlways, Keywords.All); listener.LogToConsole(); var client = new HttpClient(); var result = client.GetAsync(baseAddress + "api/test").Result; Console.WriteLine(result.Content.ReadAsStringAsync().Result); result.EnsureSuccessStatusCode(); server.CloseAsync().Wait(); Console.Read(); }
public void WhenUsingCustomFormatter() { string fileName = "FlatFileInProcCustomFormatter.log"; File.Delete(fileName); string header = "----------"; var logger = TestEventSourceNonTransient.Logger; var formatter = new CustomFormatterWithWait(header); formatter.Detailed = System.Diagnostics.Tracing.EventLevel.LogAlways; IEnumerable <string> entries = null; using (var listener = new ObservableEventListener()) { try { listener.LogToFlatFile(fileName, formatter); listener.EnableEvents(logger, System.Diagnostics.Tracing.EventLevel.LogAlways); logger.EventWithPayload("payload1", 100); entries = FlatFileHelper.PollUntilTextEventsAreWritten(fileName, 1, header); } finally { listener.DisableEvents(logger); } } StringAssert.Contains(entries.First(), "Mock SourceId"); StringAssert.Contains(entries.First(), "Mock EventId"); StringAssert.Contains(entries.First(), "Payload : [payload1 : payload1] [payload2 : 100]"); }
public void WhenExceptinOccursInCustomFormater1() { string filename = "customFormatterException.log"; File.Delete(filename); var logger = MockEventSource.Logger; var formatter = new CustomFormatter(true); using (var listener = new ObservableEventListener()) using (var collectErrorsListener = new InMemoryEventListener(true)) { try { collectErrorsListener.EnableEvents(SemanticLoggingEventSource.Log, System.Diagnostics.Tracing.EventLevel.LogAlways, Keywords.All); listener.LogToFlatFile(filename, formatter); listener.EnableEvents(logger, System.Diagnostics.Tracing.EventLevel.LogAlways, Keywords.All); logger.LogSomeMessage("testing"); collectErrorsListener.WaitEvents.Wait(3000); StringAssert.Contains(collectErrorsListener.ToString(), "unhandled exception from formatter"); } finally { listener.DisableEvents(logger); collectErrorsListener.DisableEvents(SemanticLoggingEventSource.Log); } } }
private SinkTrace TraceSource( RequestHandler handler, HttpEventCollectorEventInfo.Metadata metadata = null, HttpEventCollectorSender.SendMode sendMode = HttpEventCollectorSender.SendMode.Parallel, int batchInterval = 0, int batchSizeBytes = 0, int batchSizeCount = 0, HttpEventCollectorSender.HttpEventCollectorMiddleware middleware = null) { var listener = new ObservableEventListener(); var sink = new HttpEventCollectorSink( uri: uri, token: token, formatter: new TestEventFormatter(), metadata: metadata, sendMode: sendMode, batchInterval: batchInterval, batchSizeBytes: batchSizeBytes, batchSizeCount: batchSizeCount, middleware: MiddlewareInterceptor(handler, middleware)); listener.Subscribe(sink); var eventSource = TestEventSource.GetInstance(); listener.EnableEvents(eventSource, EventLevel.LogAlways, Keywords.All); return(new SinkTrace() { Source = eventSource, Sink = sink, Listener = listener }); }
static void Main(string[] args) { 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 instance = taskHubClient.CreateOrchestrationInstanceAsync(typeof(CounterOrchestration), Guid.NewGuid().ToString(), new TestOrchestrationInput()).Result; taskHub.StartAsync().Wait(); //taskHubClient.WaitForOrchestrationAsync(instance, TimeSpan.MaxValue).Wait(); Thread.Sleep(int.MaxValue); }
public void EventWithPayloadAndEnumsInXml() { string fileName = "LogUsingPayloadWithEnumsInProc"; File.Delete(fileName); var formatter = new XmlEventTextFormatter(EventTextFormatting.Indented, "d"); var logger = MockEventSourceInProcEnum.Logger; using (var listener = new ObservableEventListener()) { listener.EnableEvents(logger, EventLevel.LogAlways, Keywords.All); listener.LogToFlatFile(fileName, formatter); try { logger.SendEnumsEvent16(MockEventSourceInProcEnum.MyColor.Green, MockEventSourceInProcEnum.MyFlags.Flag1); } finally { listener.DisableEvents(logger); } } var rawOutput = FlatFileHelper.GetAllText(fileName); var entries = XDocument.Parse("<Events>" + rawOutput + "</Events>").Root.Elements(); Assert.AreEqual(1, entries.Count()); XmlFormattedEntry.Fill(entries.First()); Assert.AreEqual("a", XmlFormattedEntry.Payload.Elements().First().Attribute("Name").Value); Assert.AreEqual("2", XmlFormattedEntry.Payload.Elements().First().Value); Assert.AreEqual("b", XmlFormattedEntry.Payload.Elements().Last().Attribute("Name").Value); Assert.AreEqual("1", XmlFormattedEntry.Payload.Elements().Last().Value); }
public void LogFailure2LogToFlatFileTest() { string _filePath = $"{nameof(LogFailure2LogToFlatFileTest)}.log"; FileInfo _logFile = new FileInfo(_filePath); if (_logFile.Exists) { _logFile.Delete(); } MessageHandlerFactory _factory = new MessageHandlerFactory(); ObservableEventListener _listener = new ObservableEventListener(); UDPMessageHandlerSemanticEventSource _log = UDPMessageHandlerSemanticEventSource.Log; _listener.EnableEvents(_log, EventLevel.LogAlways, Keywords.All); SinkSubscription <FlatFileSink> _FlatFileSink = _listener.LogToFlatFile(_filePath); _logFile.Refresh(); Assert.IsTrue(_logFile.Exists); Assert.AreEqual <long>(0, _logFile.Length); _log.Failure(nameof(UDPMessageHandlerSemanticEventSourceUnitTest), nameof(LogFailure2LogToFlatFileTest), "LogFailure"); _FlatFileSink.Sink.FlushAsync(); _logFile.Refresh(); Assert.IsTrue(_logFile.Length > 100); _FlatFileSink.Dispose(); }
public void EnablingNullEventSourceNameThrows() { using (var listener = new ObservableEventListener()) { listener.EnableEvents((string)null, EventLevel.LogAlways); } }
public void EnablingEmptyEventSourceNameThrows() { using (var listener = new ObservableEventListener()) { listener.EnableEvents(string.Empty, EventLevel.LogAlways); } }
public void SelfHostServiceClientTest() { eventListener.LogToConsole(); eventListener.EnableEvents(DefaultEventSource.Log, EventLevel.Verbose); //eventListener.EnableEvents(null, EventLevel.Verbose) //eventListener.Subscribe((a)=> a var loggerFact = DurableTaskMicroservices.Common.Test.UnitTestLogging.GetDebugLoggerFactory(); List <OrchestrationState> runningInstances; ServiceHost host = HostHelpersExtensions.CreateMicroserviceHost(ServiceBusConnectionString, StorageConnectionString, nameof(SelfHostServiceClientTest), true, out runningInstances, loggerFact); var microservices = host.StartServiceHostAsync(Path.Combine(), runningInstances: runningInstances, context: new Dictionary <string, object>() { { "company", "daenet" } }).Result; // var r = new Daenet.Microservice() { }; //xmlSerializeService(typeof(Daenet.DurableTaskMicroservices.UnitTests.CounterOrchestration), "aaa.xml"); ServiceClient client = ClientHelperExtensions.CreateMicroserviceClient(ServiceBusConnectionString, StorageConnectionString, nameof(SelfHostServiceClientTest)); var svc = client.StartServiceAsync(cHelloWorlSvcName, new HelloWorldOrchestrationInput { HelloText = "SelfHostServiceClientTestInputArg" }).Result; microservices.Add(svc); host.WaitOnInstances(host, microservices); }
public void WhenExceptionOccursInCustomFormatter() { string fileName = "FlatFileInProcCustomFormatterHandleException.log"; File.Delete(fileName); var logger = TestEventSourceNonTransient.Logger; using (var listener = new ObservableEventListener()) using (var collectErrorsListener = new InMemoryEventListener(true)) { try { collectErrorsListener.EnableEvents(SemanticLoggingEventSource.Log, System.Diagnostics.Tracing.EventLevel.Error, Keywords.All); listener.LogToFlatFile(fileName, new MockFormatter(true)); listener.EnableEvents(logger, System.Diagnostics.Tracing.EventLevel.LogAlways); logger.EventWithPayload("payload1", 100); StringAssert.Contains(collectErrorsListener.ToString(), "Payload : [message : System.InvalidOperationException: Operation is not valid due to the current state of the object."); } finally { listener.DisableEvents(logger); collectErrorsListener.DisableEvents(SemanticLoggingEventSource.Log); } } }
public void WhenUsingCustomSink() { var validConnectionString = System.Configuration.ConfigurationManager.ConnectionStrings["valid"].ConnectionString; DatabaseHelper.CleanLoggingDB(validConnectionString); var logger = MockEventSource.Logger; string message = string.Concat("Message ", Guid.NewGuid()); using (var eventListener = new ObservableEventListener()) { try { eventListener.LogToCustomSqlDatabase("TestInstanceName", validConnectionString); eventListener.EnableEvents(logger, System.Diagnostics.Tracing.EventLevel.LogAlways, Keywords.All); logger.LogSomeMessage(message); } finally { eventListener.DisableEvents(logger); } } var dt = DatabaseHelper.GetLoggedTable(validConnectionString); Assert.AreEqual(1, dt.Rows.Count); var dr = dt.Rows[0]; Assert.AreEqual(4, (int)dr["Level"]); Assert.AreEqual(8, (int)dr["EventID"]); Assert.AreEqual("TestInstanceName", dr["InstanceName"].ToString()); StringAssert.Contains((string)dr["Payload"], message); }
public override void Initialize() { var eventListener = new ObservableEventListener(); eventListener.EnableEvents( VirtoCommerceEventSource.Log, EventLevel.LogAlways, Keywords.All); var assetsConnection = ConfigurationManager.ConnectionStrings["AssetsConnectionString"]; if (assetsConnection != null) { var properties = assetsConnection.ConnectionString.ToDictionary(";", "="); var provider = properties["provider"]; var assetsConnectionString = properties.ToString(";", "=", "provider"); if (string.Equals(provider, FileSystemBlobProvider.ProviderName, StringComparison.OrdinalIgnoreCase)) { eventListener.LogToRollingFlatFile("AvaTax.log", 10000, "hh", RollFileExistsBehavior.Increment, RollInterval.Day); } else if (string.Equals(provider, AzureBlobProvider.ProviderName, StringComparison.OrdinalIgnoreCase)) { eventListener.LogToWindowsAzureTable( "VirtoCommerce2", assetsConnectionString); } } var settingsManager = _container.Resolve<ISettingsManager>(); var avalaraTax = new AvaTaxSettings(_usernamePropertyName, _passwordPropertyName, _serviceUrlPropertyName, _companyCodePropertyName, _isEnabledPropertyName, _isValidateAddressPropertyName, settingsManager); _container.RegisterType<AvaTaxController> (new InjectionConstructor( avalaraTax)); _container.RegisterInstance<ITaxSettings>(avalaraTax); //Subscribe to cart changes. Calculate taxes _container.RegisterType<IObserver<CartChangeEvent>, CalculateCartTaxesObserver>("CalculateCartTaxesObserver"); //Subscribe to order changes. Calculate taxes _container.RegisterType<IObserver<OrderChangeEvent>, CalculateOrderTaxesObserver>("CalculateOrderTaxesObserver"); //Subscribe to order changes. Calculate taxes _container.RegisterType<IObserver<OrderChangeEvent>, CancelOrderTaxesObserver>("CancelOrderTaxesObserver"); //Subscribe to order changes. Adjust taxes _container.RegisterType<IObserver<OrderChangeEvent>, CalculateTaxAdjustmentObserver>("CalculateTaxAdjustmentObserver"); }
private static void RegisterEFLogger() { var listener = new ObservableEventListener(); listener.EnableEvents(EFLogging.Logger, EventLevel.LogAlways, Keywords.All); listener.LogToFlatFile("EFSqls.log"); listener.LogToWindowsAzureTable(instanceName: "Protiviti", connectionString: "UseDevelopmentStorage=true",tableAddress:"EFSqls"); }
/// <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(); }
public LogViewModel() { LoggedItems = new ObservableCollection<string>(); EventListener = new ObservableEventListener(); EventListener.EnableEvents(Logger.Write, EventLevel.Verbose); _syncContext = SynchronizationContext.Current; EventListener.LogToCollection(PublishLogItem); // Can only be called on the dispatcher's thread. }
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); }
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"); }
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()); }
protected void Application_Start() { var listener = new ObservableEventListener(); listener.EnableEvents(WebApiTracing.Log, EventLevel.LogAlways, Keywords.All); listener.LogToFlatFile("test.log"); AreaRegistration.RegisterAllAreas(); GlobalConfiguration.Configure(WebApiConfig.Register); FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); }
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 static void Configure() { List<EventSource> eventSources = new List<EventSource>(new[] { DomainEventSource.Log }); ObservableEventListener logListner = new ObservableEventListener(); foreach (var eventSource in eventSources) { logListner.EnableEvents(eventSource, EventLevel.Error , Keywords.All); } logListner.LogToFlatFile("log.txt"); }
public static void Configure() { List<EventSource> eventSources = new List<EventSource>() { DomainEventSource.Log, SiteEventSource.Log }; ObservableEventListener logListener = new ObservableEventListener(); foreach (var eventSource in eventSources) { logListener.EnableEvents(eventSource, EventLevel.LogAlways, Keywords.All); } logListener.LogToFlatFile("./Log.txt"); }
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); }
public static void RegisterLoggingSources(IEnumerable<EventSource> logSources, ISiteSettings settings) { var logListener = new ObservableEventListener(); foreach (var logSource in logSources) { logListener.EnableEvents( logSource, EventLevel.LogAlways, Keywords.All); } logListener.LogToFlatFile( fileName: settings.LogFilePath, formatter: new EventTextFormatter()); }
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(); }
public void TestInitialize() { obsListener = new ObservableEventListener(); obsListener.EnableEvents(AExpenseEvents.Log, EventLevel.LogAlways, Keywords.All); DatabaseHelper.CleanLoggingDB(TracingDatabaseConnectionString); this.container = new UnityContainer(); ContainerBootstrapper.Configure(container); this.ldapStore = container.Resolve<IProfileStore>(); this.exceptionMgr = container.Resolve<ExceptionManager>(); }
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); }
public Form1() { InitializeComponent(); var listener1 = new ObservableEventListener(); var listener2 = new ObservableEventListener(); listener1.EnableEvents(ApplicationInsightsEventSource.Log, EventLevel.LogAlways, Keywords.All); cont = 0; listener2.EnableEvents(ApplicationInsightsEventSource.Log, EventLevel.LogAlways, Keywords.All); MyTimer.Start(); OsVersionContextInitializer os = new OsVersionContextInitializer("Windows 8.1"); ApplicationVersionContextInitializer version = new ApplicationVersionContextInitializer("2.1"); listener1.LogToApplicationInsights("c9ce96c4-8be1-4368-87d4-1dedd72aaa71",os,version); listener2.LogToWindowsForm(this); ApplicationInsightsEventSource.Log.Startup(); }
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(); }
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 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(); } }
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(); } }