// 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();
}
}
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)
{
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();
}
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)
{
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 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 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();
}
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 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();
}
}