public void Test_EventSource_EtwManifestGeneration()
{
RemoteExecutor.Invoke(() =>
{
using (RemoteInvokeHandle handle = RemoteExecutor.Invoke(() =>
{
var es = new SimpleEventSource();
for (var i = 0; i < 100; i++)
{
es.WriteSimpleInt(i);
Thread.Sleep(100);
}
}))
{
var etlFileName = @"file.etl";
var tracesession = new TraceEventSession("testname", etlFileName);
tracesession.EnableProvider("SimpleEventSource");
Thread.Sleep(TimeSpan.FromSeconds(5));
tracesession.Flush();
// Sleep after requesting flush to ensure that the manifest payload generated
// is fully written to the etl file.
Thread.Sleep(TimeSpan.FromSeconds(5));
tracesession.DisableProvider("SimpleEventSource");
tracesession.Dispose();
Assert.True(VerifyManifestAndRemoveFile(etlFileName));
}
}).Dispose();
}
public void Test_EventSource_EtwManifestGenerationRollover()
{
RemoteExecutor.Invoke(() =>
{
using (RemoteInvokeHandle handle = RemoteExecutor.Invoke(() =>
{
var es = new SimpleEventSource();
for (var i = 0; i < 100; i++)
{
es.WriteSimpleInt(i);
Thread.Sleep(100);
}
}))
{
var initialFileName = @"initialFile.etl";
var rolloverFileName = @"rolloverFile.etl";
var tracesession = new TraceEventSession("testname", initialFileName);
var max_retries = 50;
tracesession.EnableProvider("SimpleEventSource");
Thread.Sleep(TimeSpan.FromSeconds(5));
tracesession.Flush();
tracesession.SetFileName(rolloverFileName);
Thread.Sleep(TimeSpan.FromSeconds(5));
tracesession.Flush();
tracesession.DisableProvider("SimpleEventSource");
tracesession.Dispose();
bool initialFileHasManifest = false;
bool rollOverFileHasManifest = false;
for (int i = 0; i < max_retries; i++)
{
if (VerifyManifestAndRemoveFile(initialFileName))
{
initialFileHasManifest = true;
break;
}
Thread.Sleep(1000);
}
for (int i = 0; i < max_retries; i++)
{
if (VerifyManifestAndRemoveFile(rolloverFileName))
{
rollOverFileHasManifest = true;
break;
}
Thread.Sleep(1000);
}
Assert.True(initialFileHasManifest);
Assert.True(rollOverFileHasManifest);
}
}).Dispose();
}
public void Test_EventSource_EtwManifestGeneration()
{
RemoteInvokeOptions options = new RemoteInvokeOptions {
TimeOut = 300_000 /* ms */
};
RemoteExecutor.Invoke(() =>
{
RemoteInvokeOptions localOptions = new RemoteInvokeOptions {
TimeOut = 300_000 /* ms */
};
using (RemoteInvokeHandle handle = RemoteExecutor.Invoke(() =>
{
var es = new SimpleEventSource();
for (var i = 0; i < 100; i++)
{
es.WriteSimpleInt(i);
Thread.Sleep(100);
}
}, localOptions))
{
var etlFileName = @"file.etl";
var tracesession = new TraceEventSession("testname", etlFileName);
tracesession.EnableProvider("SimpleEventSource");
Thread.Sleep(TimeSpan.FromSeconds(5));
tracesession.Flush();
tracesession.DisableProvider("SimpleEventSource");
tracesession.Dispose();
var manifestExists = false;
var max_retries = 50;
for (int i = 0; i < max_retries; i++)
{
if (VerifyManifestAndRemoveFile(etlFileName))
{
manifestExists = true;
break;
}
Thread.Sleep(1000);
}
Assert.True(manifestExists);
}
}, options).Dispose();
}
public void TraceProcessForDuration(int duration, string traceName)
{
var tracesession = new TraceEventSession("testname", _traceName);
foreach (var provider in _providers)
{
tracesession.EnableProvider(provider.Name, (TraceEventLevel)provider.EventLevel, (ulong)provider.Keywords);
}
tracesession.EnableProvider("My-Test-EventSource");
System.Threading.Thread.Sleep(duration * 1000);
tracesession.Flush();
tracesession.DisableProvider("My-Test-EventSource");
tracesession.Dispose();
}
public void UpdateProviderNames(string[] providerNames)
{
var removed = ProviderNames.Except(providerNames);
var added = providerNames.Except(ProviderNames);
foreach (var name in removed)
{
_etwSession.DisableProvider(name);
}
foreach (var name in added)
{
_etwSession.EnableProvider(name);
}
ProviderNames = providerNames;
Properties.Settings.Default.ProviderNames = JsonConvert.SerializeObject(ProviderNames);
Properties.Settings.Default.Save();
}
public void Writing_Message_To_Etw()
{
var resetEvent = new ManualResetEvent(false);
var fpath = Path.Combine(Path.GetTempPath(), "_etwnlogtest.etl");
using (var session = new TraceEventSession("SimpleMonitorSession", fpath))
{
Thread.Sleep(1000);
try
{
session.EnableProvider(providerId);
Thread.Sleep(1000);
}
catch
{
Thread.Sleep(1000);
session.EnableProvider(providerId);
}
Thread.Sleep(1000);
// send events to session
var logger = LogManager.GetLogger("A");
logger.Debug("test-debug");
logger.Info("test-info");
logger.Warn("test-warn");
logger.Error("test-error");
logger.Fatal("test-fatal");
try
{
Thread.Sleep(1000);
session.DisableProvider(providerId);
}
catch
{
Thread.Sleep(1000);
session.DisableProvider(providerId);
}
Thread.Sleep(1000);
logger.Fatal("don't log this one");
}
var collectedEvents = new List <NLogEtwEventData>(5);
using (var source = new ETWTraceEventSource(fpath))
{
source.UnhandledEvents += delegate(TraceEvent data)
{
if (data.Level == TraceEventLevel.Always)
{
return; // Not ours
}
collectedEvents.Add(new NLogEtwEventData(data)
{
Message = data.FormattedMessage,
});
if (collectedEvents.Count == 5)
{
resetEvent.Set();
}
};
source.Process();
}
File.Delete(fpath);
var providerName = $"Provider({providerId.ToString()})";
// assert collected events
var expectedEvents = new NLogEtwEventData[] {
new NLogEtwEventData {
ProviderName = providerName, TaskName = "EventWriteString", Level = TraceEventLevel.Verbose, Message = "DEBUG|A|test-debug"
},
new NLogEtwEventData {
ProviderName = providerName, TaskName = "EventWriteString", Level = TraceEventLevel.Informational, Message = "INFO|A|test-info"
},
new NLogEtwEventData {
ProviderName = providerName, TaskName = "EventWriteString", Level = TraceEventLevel.Warning, Message = "WARN|A|test-warn"
},
new NLogEtwEventData {
ProviderName = providerName, TaskName = "EventWriteString", Level = TraceEventLevel.Error, Message = "ERROR|A|test-error"
},
new NLogEtwEventData {
ProviderName = providerName, TaskName = "EventWriteString", Level = TraceEventLevel.Critical, Message = "FATAL|A|test-fatal"
}
};
resetEvent.WaitOne(20000);
Assert.Equal(expectedEvents.Length, collectedEvents.Count);
Assert.Equal(expectedEvents, collectedEvents);
}
public void Writing_Message_To_Etw()
{
var fpath = Path.Combine(Path.GetTempPath(), "_etwnlogtest.etl");
using (var session = new TraceEventSession("SimpleMonitorSession", fpath))
{
//var eventSourceGuid = TraceEventProviders.GetEventSourceGuidFromName("MyEventSource");
var eventSourceGuid = TraceEventProviders.GetEventSourceGuidFromName("LowLevelDesign-NLogEtwSource");
session.EnableProvider(eventSourceGuid);
// send events to session
var logger = LogManager.GetLogger("A");
logger.Debug("test-debug");
logger.Info("test-info");
logger.Warn("test-warn");
logger.Error("test-error");
logger.Fatal("test-fatal");
session.DisableProvider(eventSourceGuid);
logger.Fatal("don't log this one");
Thread.Sleep(5000);
}
var collectedEvents = new List <ExtendedEtwEvent>(5);
using (var source = new ETWTraceEventSource(fpath))
{
var parser = new DynamicTraceEventParser(source);
parser.All += delegate(TraceEvent data)
{
collectedEvents.Add(new ExtendedEtwEvent
{
EventId = (int)data.ID,
Level = data.Level,
LoggerName = (string)data.PayloadByName("LoggerName"),
Message = (string)data.PayloadByName("Message")
});
};
source.Process();
}
File.Delete(fpath);
// assert collected events
var expectedEvents = new ExtendedEtwEvent[] {
new ExtendedEtwEvent {
EventId = 1, LoggerName = "A", Level = TraceEventLevel.Verbose, Message = "DEBUG|A|test-debug"
},
new ExtendedEtwEvent {
EventId = 2, LoggerName = "A", Level = TraceEventLevel.Informational, Message = "INFO|A|test-info"
},
new ExtendedEtwEvent {
EventId = 3, LoggerName = "A", Level = TraceEventLevel.Warning, Message = "WARN|A|test-warn"
},
new ExtendedEtwEvent {
EventId = 4, LoggerName = "A", Level = TraceEventLevel.Error, Message = "ERROR|A|test-error"
},
new ExtendedEtwEvent {
EventId = 5, LoggerName = "A", Level = TraceEventLevel.Critical, Message = "FATAL|A|test-fatal"
}
};
Assert.Equal(collectedEvents, expectedEvents);
}
public void Writing_Message_To_Etw()
{
var resetEvent = new ManualResetEvent(false);
var collectedEvents = new List <NLogEtwEventData>(5);
var providerName = etwTarget.ProviderName.Render(LogEventInfo.CreateNullEvent());
using (var session = new TraceEventSession("SimpleMonitorSession"))
{
// Dynamic-Parser does not work with pure EventSource-objects
session.Source.Registered.All += delegate(TraceEvent data)
{
if (data.Level == TraceEventLevel.Always)
{
return; // Not ours
}
collectedEvents.Add(new NLogEtwEventData(data)
{
EventId = 0, // Raw EventSource gives "random" EventId
LoggerName = (string)data.PayloadByName("LoggerName"),
Message = (string)data.PayloadByName("Message"),
});
if (collectedEvents.Count == 5)
{
resetEvent.Set();
}
};
session.Source.UnhandledEvents += delegate(TraceEvent data)
{
if ((int)data.ID == 0xFFFE)
{
return; // The EventSource manifest events show up as unhanded, filter them out.
}
};
var task = System.Threading.Tasks.Task.Run(() => session.Source.Process());
Thread.Sleep(1000);
session.EnableProvider(providerName);
Thread.Sleep(1000);
// send events to session
var logger = LogManager.GetLogger("A");
logger.Debug("test-debug");
logger.Info("test-info");
logger.Warn("test-warn");
logger.Error("test-error");
logger.Fatal("test-fatal");
try
{
var eventSourceGuid = TraceEventProviders.GetEventSourceGuidFromName(providerName);
session.DisableProvider(eventSourceGuid);
}
catch
{
Thread.Sleep(1000);
var eventSourceGuid = TraceEventProviders.GetEventSourceGuidFromName(providerName);
session.DisableProvider(eventSourceGuid);
}
Thread.Sleep(1000);
logger.Fatal("don't log this one");
resetEvent.WaitOne(20000);
}
// assert collected events
var expectedEvents = new NLogEtwEventData[] {
new NLogEtwEventData {
EventId = 0, ProviderName = providerName, TaskName = "Debug", Level = TraceEventLevel.Verbose, LoggerName = "A", Message = "DEBUG|A|test-debug"
},
new NLogEtwEventData {
EventId = 0, ProviderName = providerName, TaskName = "Info", Level = TraceEventLevel.Informational, LoggerName = "A", Message = "INFO|A|test-info"
},
new NLogEtwEventData {
EventId = 0, ProviderName = providerName, TaskName = "Warn", Level = TraceEventLevel.Warning, LoggerName = "A", Message = "WARN|A|test-warn"
},
new NLogEtwEventData {
EventId = 0, ProviderName = providerName, TaskName = "Error", Level = TraceEventLevel.Error, LoggerName = "A", Message = "ERROR|A|test-error"
},
new NLogEtwEventData {
EventId = 0, ProviderName = providerName, TaskName = "Fatal", Level = TraceEventLevel.Critical, LoggerName = "A", Message = "FATAL|A|test-fatal"
}
};
Assert.Equal(collectedEvents, expectedEvents);
}
} // ETWTraceInBackground_Start()
private void Eventbgw_DoWork(object sender, DoWorkEventArgs e)
{
// This is the background thread
Provider etwp = e.Argument as Provider;
BackgroundWorker worker = sender as BackgroundWorker;
Thread.CurrentThread.Name = "ETWReader";
using (myTraceEventSession = new TraceEventSession(etwp.name, TraceEventSessionOptions.Create))
{
myTraceEventSession.StopOnDispose = true;
myTraceEventSession.Source.Dynamic.All += delegate(TraceEvent data) // Set Source (stream of events) from session.
{ // Get dynamic parser (knows about EventSources)
// Subscribe to all EventSource events
string operation = "";
string inputs = "";
string result = "";
string outputs = "";
string caller = "";
Int64 start = 0;
Int64 end = 0;
try
{
operation = (string)data.PayloadByName("Operation");
}
catch
{
// expected possible condition
}
try
{
inputs = (string)data.PayloadByName("Inputs");
}
catch
{
// expected possible condition
}
try
{
result = (string)data.PayloadByName("Result");
}
catch
{
// expected possible condition
}
try
{
outputs = (string)data.PayloadByName("Outputs");
}
catch
{
// expected possible condition
}
try
{
caller = (string)data.PayloadByName("Caller");
}
catch
{
// expected possible condition
}
if (inputs == null && result == null && outputs == null)
{
try
{
outputs = (string)data.PayloadByName("Message");
}
catch
{
// expected possible condition
}
}
try
{
start = (Int64)data.PayloadByName("Start");
}
catch
{
// expected possible condition
}
try
{
end = (Int64)data.PayloadByName("End");
}
catch
{
// expected possible condition
}
EventItem ei = new EventItem((int)data.EventIndex,
start,
end,
data.TimeStamp,
data.ProcessName,
data.ProcessID,
data.ThreadID,
data.ProviderName,
operation,
inputs,
result,
outputs,
caller
);
lock (_TEventListsLock)
{
_TEventListItems.Add(ei);
AddToProcIDsList(data.ProcessID);
}
worker.ReportProgress((int)data.EventIndex);
};
EventTraceProviderEnablementResultCode = myTraceEventSession.EnableProvider(etwp.guid);
if (!EventTraceProviderEnablementResultCode)
{
// Attempt resetting for second run...
myTraceEventSession.DisableProvider(etwp.guid);
EventTraceProviderEnablementResultCode = myTraceEventSession.EnableProvider(etwp.guid);
}
EventTraceProviderSourceResultCode = myTraceEventSession.Source.Process();
}
} // Eventbgw_DoWork()
public void Writing_Message_To_Etw()
{
var providerName = "LowLevelDesign-NLogEtwSource";
var resetEvent = new ManualResetEvent(false);
var fpath = Path.Combine(Path.GetTempPath(), "_etwnlogtest.etl");
using (var session = new TraceEventSession("SimpleMonitorSession", fpath))
{
Thread.Sleep(1000);
var eventSourceGuid = TraceEventProviders.GetEventSourceGuidFromName(providerName);
try
{
session.EnableProvider(eventSourceGuid);
Thread.Sleep(1000);
}
catch
{
Thread.Sleep(1000);
eventSourceGuid = TraceEventProviders.GetEventSourceGuidFromName(providerName);
session.EnableProvider(eventSourceGuid);
}
// send events to session
var logger = LogManager.GetLogger("A");
logger.Debug("test-debug");
logger.Info("test-info");
logger.Warn("test-warn");
logger.Error("test-error");
logger.Fatal("test-fatal");
try
{
Thread.Sleep(1000);
session.DisableProvider(eventSourceGuid);
}
catch
{
Thread.Sleep(1000);
session.DisableProvider(eventSourceGuid);
}
Thread.Sleep(1000);
logger.Fatal("don't log this one");
}
var collectedEvents = new List <NLogEtwEventData>(5);
using (var source = new ETWTraceEventSource(fpath))
{
var parser = new DynamicTraceEventParser(source);
parser.All += delegate(TraceEvent data)
{
if (data.Level == TraceEventLevel.Always)
{
return; // Not ours
}
collectedEvents.Add(new NLogEtwEventData(data)
{
LoggerName = (string)data.PayloadByName("LoggerName"),
Message = (string)data.PayloadByName("Message")
});
if (collectedEvents.Count == 5)
{
resetEvent.Set();
}
};
source.Process();
}
File.Delete(fpath);
// assert collected events
var expectedEvents = new NLogEtwEventData[] {
new NLogEtwEventData {
EventId = 1, ProviderName = providerName, TaskName = "Verbose", LoggerName = "A", Level = TraceEventLevel.Verbose, Message = "DEBUG|A|test-debug"
},
new NLogEtwEventData {
EventId = 2, ProviderName = providerName, TaskName = "Info", LoggerName = "A", Level = TraceEventLevel.Informational, Message = "INFO|A|test-info"
},
new NLogEtwEventData {
EventId = 3, ProviderName = providerName, TaskName = "Warn", LoggerName = "A", Level = TraceEventLevel.Warning, Message = "WARN|A|test-warn"
},
new NLogEtwEventData {
EventId = 4, ProviderName = providerName, TaskName = "Error", LoggerName = "A", Level = TraceEventLevel.Error, Message = "ERROR|A|test-error"
},
new NLogEtwEventData {
EventId = 5, ProviderName = providerName, TaskName = "Critical", LoggerName = "A", Level = TraceEventLevel.Critical, Message = "FATAL|A|test-fatal"
}
};
resetEvent.WaitOne(20000);
Assert.Equal(collectedEvents, expectedEvents);
}
public void Writing_Message_To_Etw()
{
var resetEvent = new ManualResetEvent(false);
var fpath = Path.Combine(Path.GetTempPath(), "_etwnlogtest.etl");
using (var session = new TraceEventSession("SimpleMonitorSession", fpath))
{
session.EnableProvider(providerId);
// send events to session
var logger = LogManager.GetLogger("A");
logger.Debug("test-debug");
logger.Info("test-info");
logger.Warn("test-warn");
logger.Error("test-error");
logger.Fatal("test-fatal");
session.DisableProvider(providerId);
logger.Fatal("don't log this one");
}
var collectedEvents = new List <SimpleEtwEvent>(5);
using (var source = new ETWTraceEventSource(fpath))
{
source.UnhandledEvents += delegate(TraceEvent data)
{
collectedEvents.Add(new SimpleEtwEvent {
Level = data.Level, Message = data.FormattedMessage
});
if (collectedEvents.Count == 5)
{
resetEvent.Set();
}
};
source.Process();
}
File.Delete(fpath);
// assert collected events
var expectedEvents = new SimpleEtwEvent[] {
new SimpleEtwEvent {
Level = TraceEventLevel.Verbose, Message = "DEBUG|A|test-debug"
},
new SimpleEtwEvent {
Level = TraceEventLevel.Informational, Message = "INFO|A|test-info"
},
new SimpleEtwEvent {
Level = TraceEventLevel.Warning, Message = "WARN|A|test-warn"
},
new SimpleEtwEvent {
Level = TraceEventLevel.Error, Message = "ERROR|A|test-error"
},
new SimpleEtwEvent {
Level = TraceEventLevel.Critical, Message = "FATAL|A|test-fatal"
}
};
resetEvent.WaitOne(20000);
Assert.Equal(expectedEvents.Length, collectedEvents.Count);
Assert.Equal(expectedEvents, collectedEvents);
}