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");
}
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 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;
}