public void WhenDefaultTableNameIsUsed() { var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"]; AzureTableHelper.DeleteTable(connectionString, WindowsAzureTableLog.DefaultTableName); var logger = TestEventSource.Logger; using (var listener = new ObservableEventListener()) { try { listener.LogToWindowsAzureTable("mytestinstance", connectionString, bufferingInterval: TimeSpan.FromSeconds(1)); listener.EnableEvents(logger, EventLevel.LogAlways); logger.Error("This is an error message"); } finally { listener.DisableEvents(logger); } } var events = AzureTableHelper.PollForEvents(connectionString, WindowsAzureTableLog.DefaultTableName, 1); Assert.AreEqual(1, events.Count()); }
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 WhenEventHasAllValuesForAttribute() { this.tableName = "WhenEventHasAllValuesForAttribute"; 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, Keywords.All); logger.AllParametersWithCustomValues(); } finally { listener.DisableEvents(logger); } } var events = AzureTableHelper.PollForEvents(connectionString, this.tableName, 1); Assert.AreEqual(1, events.Count()); Assert.AreEqual(10001, events.ElementAt(0).EventId); }
public void WhenEventHasMultiplePayloads() { this.tableName = "WhenEventHasMultiplePayloads"; 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(20)); listener.EnableEvents(logger, EventLevel.LogAlways); logger.EventWithMultiplePayloads("TestPayload 1", "TestPayload 2", "TestPayload 3"); } finally { listener.DisableEvents(logger); } } var events = AzureTableHelper.PollForEvents(connectionString, this.tableName, 1); Assert.AreEqual(1, events.Count()); StringAssert.Contains(events.First().Payload, @"""payload1"": ""TestPayload 1"""); StringAssert.Contains(events.First().Payload, @"""payload2"": ""TestPayload 2"""); StringAssert.Contains(events.First().Payload, @"""payload3"": ""TestPayload 3"""); }
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 WhenNoPayload() { this.tableName = "WhenNoPayload"; 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.EventWithoutPayloadNorMessage(); } finally { listener.DisableEvents(logger); } } var events = AzureTableHelper.PollForEvents(connectionString, this.tableName, 1); Assert.AreEqual(1, events.Count()); Assert.AreEqual(TestEventSource.EventWithoutPayloadNorMessageId, events.ElementAt(0).EventId); }
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()); }
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); }
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 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 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"); }
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 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"); }
protected override void InitializeCloudLogging() { if (Config.Storage.Primary != null) { _subscriptions.Add(_platformEventStream.LogToWindowsAzureTable( instanceName: Description.InstanceName.ToString() + "/" + Description.MachineName, connectionString: Config.Storage.Primary.GetConnectionString(), tableAddress: "NGPlatformTrace")); } }
public void WhenConnectionStringIsEmpty() { var ex = ExceptionAssertHelper.Throws <ArgumentException>(() => { using (var listener = new ObservableEventListener()) { listener.LogToWindowsAzureTable("mytestinstance", string.Empty); } }); StringAssert.Contains(ex.Message, "Argument is empty"); StringAssert.Contains(ex.Message, "Parameter name: connectionString"); }
public void WhenConnectionStringIsNull() { var ex = ExceptionAssertHelper.Throws <ArgumentNullException>(() => { using (var listener = new ObservableEventListener()) { listener.LogToWindowsAzureTable("mytestinstance", null); } }); StringAssert.Contains(ex.Message, "Value cannot be null"); StringAssert.Contains(ex.Message, "Parameter name: connectionString"); }
public void WhenBatchSizeIsExceeded() { this.tableName = "WhenBatchSizeIsExceeded"; var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"]; AzureTableHelper.DeleteTable(connectionString, this.tableName); var logger = TestEventSource.Logger; IEnumerable <WindowsAzureTableEventEntry> events = null; using (var listener1 = new ObservableEventListener()) using (var listener2 = new ObservableEventListener()) { try { listener1.LogToWindowsAzureTable("mytestinstance1", connectionString, this.tableName, bufferingInterval: TimeSpan.FromSeconds(20)); listener2.LogToWindowsAzureTable("mytestinstance2", connectionString, this.tableName, bufferingInterval: TimeSpan.FromSeconds(20)); listener1.EnableEvents(logger, EventLevel.LogAlways); listener2.EnableEvents(logger, EventLevel.LogAlways); // 100 events or more will be flushed by count before the buffering interval elapses var logTaskList = new List <Task>(); for (int i = 0; i < 120; i++) { var messageNumber = i; logTaskList.Add(Task.Run(() => logger.Critical(messageNumber + "Critical message"))); } Task.WaitAll(logTaskList.ToArray(), TimeSpan.FromSeconds(10)); // Wait less than the buffering interval for the events to be written and assert // Only the first batch of 100 is written for each listener events = AzureTableHelper.PollForEvents(connectionString, this.tableName, 200, waitFor: TimeSpan.FromSeconds(10)); Assert.AreEqual(200, events.Count()); Assert.AreEqual(100, events.Where(e => e.InstanceName == "mytestinstance1").Count()); Assert.AreEqual(100, events.Where(e => e.InstanceName == "mytestinstance2").Count()); } finally { listener1.DisableEvents(logger); listener2.DisableEvents(logger); } } // The rest of the events are written during the Dispose flush events = AzureTableHelper.PollForEvents(connectionString, this.tableName, 240, waitFor: TimeSpan.FromSeconds(2)); Assert.AreEqual(240, events.Count()); Assert.AreEqual(120, events.Where(e => e.InstanceName == "mytestinstance1").Count()); Assert.AreEqual(120, events.Where(e => e.InstanceName == "mytestinstance2").Count()); }
public void WhenInstanceIsNull() { var ex = ExceptionAssertHelper.Throws <ArgumentNullException>(() => { var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"]; using (var listener = new ObservableEventListener()) { listener.LogToWindowsAzureTable(null, connectionString); } }); StringAssert.Contains(ex.Message, "Value cannot be null"); StringAssert.Contains(ex.Message, "Parameter name: instanceName"); }
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 WhenTableNameIsEmpty() { var ex = ExceptionAssertHelper.Throws <ArgumentException>(() => { this.tableName = string.Empty; var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"]; using (var listener = new ObservableEventListener()) { listener.LogToWindowsAzureTable("mytestinstance", connectionString, this.tableName, bufferingInterval: TimeSpan.FromSeconds(1)); } }); StringAssert.Contains(ex.Message, "Argument is empty"); StringAssert.Contains(ex.Message, "Parameter name: tableAddress"); }
public void WhenTableNameIsInvalid() { var ex = ExceptionAssertHelper.Throws <ArgumentException>(() => { this.tableName = "$$$$"; var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"]; using (var listener = new ObservableEventListener()) { listener.LogToWindowsAzureTable("mytestinstance", connectionString, this.tableName, bufferingInterval: TimeSpan.FromSeconds(1)); } }); StringAssert.Contains(ex.Message, "Table names may contain only alphanumeric characters, cannot begin with a numeric character and must be from 3 to 63 characters long."); StringAssert.Contains(ex.Message, "Parameter name: tableAddress"); }
public void WhenListenerIsDisposed() { this.tableName = "WhenListenerIsDisposed"; var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"]; AzureTableHelper.DeleteTable(connectionString, this.tableName); var logger = TestEventSource.Logger; var listener1 = new ObservableEventListener(); var listener2 = new ObservableEventListener(); try { listener1.LogToWindowsAzureTable("mytestinstance1", connectionString, this.tableName, bufferingInterval: TimeSpan.FromSeconds(20)); listener2.LogToWindowsAzureTable("mytestinstance2", connectionString, this.tableName, bufferingInterval: TimeSpan.FromSeconds(20)); listener1.EnableEvents(logger, EventLevel.LogAlways); listener2.EnableEvents(logger, EventLevel.LogAlways); var logTaskList = new List <Task>(); for (int i = 0; i < 105; i++) { var messageNumber = i; logTaskList.Add(Task.Run(() => logger.Critical(messageNumber + "Critical message"))); } Task.WaitAll(logTaskList.ToArray(), TimeSpan.FromSeconds(10)); listener1.Dispose(); listener2.Dispose(); var events = AzureTableHelper.PollForEvents(connectionString, this.tableName, 600); Assert.AreEqual(210, events.Count()); } finally { try { listener1.DisableEvents(logger); } catch { } try { listener2.DisableEvents(logger); } catch { } } }
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); } }
public void WhenUsingNonDefaultBufferInterval() { this.tableName = "WhenUsingNonDefaultBufferInterval"; 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(5); listener.LogToWindowsAzureTable("mytestinstance", connectionString, this.tableName, bufferingInterval: bufferingInterval); listener.EnableEvents(logger, EventLevel.LogAlways); // Pre-condition: Wait for the events to be written and assert Task.Delay(TimeSpan.FromSeconds(2)).Wait(); Assert.AreEqual(0, AzureTableHelper.GetEventsCount(connectionString, this.tableName)); for (int i = 0; i < 10; i++) { logger.Critical("Critical Message"); } // Event must not be written before the interval has elapsed Task.Delay(TimeSpan.FromSeconds(2)).Wait(); Assert.AreEqual(0, AzureTableHelper.GetEventsCount(connectionString, this.tableName)); // Wait for the buffer to flush at end of interval Task.Delay(bufferingInterval).Wait(); // 1st interval: Wait for the events to be written and assert Task.Delay(TimeSpan.FromSeconds(2)).Wait(); Assert.AreEqual(10, AzureTableHelper.GetEventsCount(connectionString, this.tableName)); } finally { listener.DisableEvents(logger); } } }
public void WhenInternalBufferCountIsExceededAndIntervalExceeded() { this.tableName = "WhenInternalBufferCountIsExceededAndIntervalExceeded"; 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(5); listener.LogToWindowsAzureTable("mytestinstance", connectionString, this.tableName, bufferingInterval: bufferingInterval); listener.EnableEvents(logger, EventLevel.Informational); // When reachiing 100 events buffer will be flushed for (int i = 0; i < 110; i++) { logger.Informational("Message1"); } // Wait for buffer interval to elapse Task.Delay(bufferingInterval).Wait(); var events = AzureTableHelper.GetEventsCount(connectionString, this.tableName); Assert.AreEqual(100, events); } finally { listener.DisableEvents(logger); } } // Last events should be written during the Dispose flush var eventsCountFinal = AzureTableHelper.GetEventsCount(connectionString, this.tableName); Assert.AreEqual(110, eventsCountFinal); }
public void WhenBufferingWithMinimumNonDefaultInterval() { this.tableName = "WhenBufferingWithMinimalNonDefaultInterval"; var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"]; AzureTableHelper.DeleteTable(connectionString, this.tableName); var logger = TestEventSource.Logger; using (var listener = new ObservableEventListener()) { try { // Minimum buffering interval is 500 ms var minimumBufferingInterval = TimeSpan.FromMilliseconds(500); listener.LogToWindowsAzureTable("mytestinstance1", connectionString, this.tableName, bufferingInterval: minimumBufferingInterval); listener.EnableEvents(logger, EventLevel.LogAlways); var logTaskList = new List <Task>(); for (int i = 0; i < 10; i++) { logger.Critical("Critical message"); } // Wait for the events to be written and assert Task.Delay(TimeSpan.FromSeconds(2)).Wait(); var eventsCount = AzureTableHelper.GetEventsCount(connectionString, this.tableName); Assert.AreEqual(10, eventsCount); } finally { listener.DisableEvents(logger); } } // No more events should be written during the Dispose flush var eventsCountFinal = AzureTableHelper.GetEventsCount(connectionString, this.tableName); Assert.AreEqual(10, eventsCountFinal); }
static void Main(string[] args) { ObservableEventListener listener1; try { listener1 = new ObservableEventListener(); var conString = $"DefaultEndpointsProtocol={CloudStorageAccount.DevelopmentStorageAccount.TableEndpoint.Scheme};" + $"AccountName={CloudStorageAccount.DevelopmentStorageAccount.Credentials.AccountName};" + $"AccountKey={Convert.ToBase64String(CloudStorageAccount.DevelopmentStorageAccount.Credentials.ExportKey())}"; listener1.LogToWindowsAzureTable( // <---- EXCEPTION HERE instanceName: "instName", connectionString: conString); listener1.EnableEvents(MyCompanyEventSource.Log, EventLevel.LogAlways, MyCompanyEventSource.Keywords.Perf | MyCompanyEventSource.Keywords.Diagnostic | MyCompanyEventSource.Keywords.Page | MyCompanyEventSource.Keywords.DataBase); } catch(Exception ex) { Console.WriteLine(ex.Message); } }
public void WhenEventsInThreeConsecutiveIntervals() { this.tableName = "WhenEventsInThreeConsecutiveIntervals"; var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"]; AzureTableHelper.DeleteTable(connectionString, this.tableName); var logger = TestEventSource.Logger; var bufferingInterval = TimeSpan.FromSeconds(5); var insertionInterval = TimeSpan.FromSeconds(1); using (var listener = new ObservableEventListener()) using (var errorsListener = new InMemoryEventListener()) { try { errorsListener.EnableEvents(SemanticLoggingEventSource.Log, EventLevel.Verbose); listener.LogToWindowsAzureTable("mytestinstance", connectionString, this.tableName, bufferingInterval: bufferingInterval); listener.EnableEvents(logger, EventLevel.Informational); // 1st interval: Log 10 events for (int i = 0; i < 10; i++) { logger.Informational("Message1"); } // 1st interval: Wait for the buffer to flush at end of interval Task.Delay(bufferingInterval).Wait(); // 2nd interval: start // 1st interval: Wait for the events to be written and assert Task.Delay(insertionInterval).Wait(); Assert.AreEqual(10, AzureTableHelper.GetEventsCount(connectionString, this.tableName)); // 2nd interval: Log 10 events for (int i = 0; i < 10; i++) { logger.Informational("Message1"); } // 2nd interval: Wait for the buffer to flush at end of interval Task.Delay(bufferingInterval).Wait(); // 3rd interval: start // 2nd interval: Wait for the events to be written and assert Task.Delay(insertionInterval).Wait(); Assert.AreEqual(20, AzureTableHelper.GetEventsCount(connectionString, this.tableName)); // 3rd interval: Log 10 events for (int i = 0; i < 10; i++) { logger.Informational("Message1"); } // 3rd interval: Wait for the buffer to flush at end of interval Task.Delay(bufferingInterval).Wait(); // 4th interval: start // 3rd interval: Wait for the events to be written and assert Task.Delay(insertionInterval).Wait(); Assert.AreEqual(30, AzureTableHelper.GetEventsCount(connectionString, this.tableName)); // No errors should have been reported Assert.AreEqual(string.Empty, errorsListener.ToString()); } finally { listener.DisableEvents(logger); errorsListener.DisableEvents(SemanticLoggingEventSource.Log); } } // No more events should have been written during the last flush in the Dispose Assert.AreEqual(30, AzureTableHelper.GetEventsCount(connectionString, this.tableName)); }
public void WhenTableNameIsInvalid() { var ex = ExceptionAssertHelper.Throws<ArgumentException>(() => { this.tableName = "$$$$"; var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"]; using (var listener = new ObservableEventListener()) { listener.LogToWindowsAzureTable("mytestinstance", connectionString, this.tableName, bufferingInterval: TimeSpan.FromSeconds(1)); } }); StringAssert.Contains(ex.Message, "Table names may contain only alphanumeric characters, cannot begin with a numeric character and must be from 3 to 63 characters long."); StringAssert.Contains(ex.Message, "Parameter name: tableAddress"); }
private async Task RunAsync(CancellationToken cancellationToken) { var eventListener = new ObservableEventListener(); eventListener.LogToWindowsAzureTable( _configuration.Identifier, _configuration.StorageConnectionString); eventListener.EnableEvents(DefaultEventSource.Log, EventLevel.Informational); eventListener.EnableEvents(ByteBlasterEventSource.Log, EventLevel.Informational); var eventHubClient = EventHubClient.CreateFromConnectionString( _configuration.EventHubConnectionString, _configuration.EventHubName); var byteBlasterClient = new ByteBlasterClient(_configuration.Email); // Subscribe and send Quick Block Transfer Segments to the Event Hub byteBlasterClient .Subscribe(async e => await Publish(eventHubClient, e)); _log.InfoFormat("Starting EMWIN ByteBlaster Client"); await byteBlasterClient.StartAsync(cancellationToken); eventHubClient.Close(); }
public void WhenInstanceIsNull() { var ex = ExceptionAssertHelper.Throws<ArgumentNullException>(() => { var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"]; using (var listener = new ObservableEventListener()) { listener.LogToWindowsAzureTable(null, connectionString); } }); StringAssert.Contains(ex.Message, "Value cannot be null"); StringAssert.Contains(ex.Message, "Parameter name: instanceName"); }
public void WhenConnectionStringIsEmpty() { var ex = ExceptionAssertHelper.Throws<ArgumentException>(() => { using (var listener = new ObservableEventListener()) { listener.LogToWindowsAzureTable("mytestinstance", string.Empty); } }); StringAssert.Contains(ex.Message, "Argument is empty"); StringAssert.Contains(ex.Message, "Parameter name: connectionString"); }
public void WhenConnectionStringIsNull() { var ex = ExceptionAssertHelper.Throws<ArgumentNullException>(() => { using (var listener = new ObservableEventListener()) { listener.LogToWindowsAzureTable("mytestinstance", null); } }); StringAssert.Contains(ex.Message, "Value cannot be null"); StringAssert.Contains(ex.Message, "Parameter name: connectionString"); }
public void WhenTableNameIsEmpty() { var ex = ExceptionAssertHelper.Throws<ArgumentException>(() => { this.tableName = string.Empty; var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"]; using (var listener = new ObservableEventListener()) { listener.LogToWindowsAzureTable("mytestinstance", connectionString, this.tableName, bufferingInterval: TimeSpan.FromSeconds(1)); } }); StringAssert.Contains(ex.Message, "Argument is empty"); StringAssert.Contains(ex.Message, "Parameter name: tableAddress"); }
/// <summary> /// Creates an event listener that logs using a <see cref="WindowsAzureTableSink" />. /// </summary> /// <param name="instanceName">The name of the instance originating the entries.</param> /// <param name="connectionString">The connection string for the storage account.</param> /// <param name="tableAddress">Either the name of the table, or the absolute URI to the table.</param> /// <param name="bufferingInterval">The buffering interval between each batch publishing.</param> /// <param name="sortKeysAscending">The value indicating whether to sort the row keys in ascending order.</param> /// <param name="listenerDisposeTimeout">Defines a timeout interval for the flush operation when the listener is disposed.</param> /// <param name="maxBufferSize">The maximum number of entries that can be buffered while it's sending to Windows Azure Storage before the sink starts dropping entries. /// This means that if the timeout period elapses, some event entries will be dropped and not sent to the store. Calling <see cref="IDisposable.Dispose" /> on /// the <see cref="EventListener" /> will block until all the entries are flushed or the interval elapses. /// If <see langword="null" /> is specified, then the call will block indefinitely until the flush operation finishes.</param> /// <returns> /// An event listener that uses <see cref="WindowsAzureTableSink" /> to log events. /// </returns> public static EventListener CreateListener(string instanceName, string connectionString, string tableAddress = DefaultTableName, TimeSpan? bufferingInterval = null, bool sortKeysAscending = false, TimeSpan? listenerDisposeTimeout = null, int maxBufferSize = Buffering.DefaultMaxBufferSize) { var listener = new ObservableEventListener(); listener.LogToWindowsAzureTable(instanceName, connectionString, tableAddress, bufferingInterval, sortKeysAscending, listenerDisposeTimeout, maxBufferSize); return listener; }