public void WhenUsingJsonFormatterWithCustomDateTimeFormat()
{
string fileName = "FlatFileJsonFormatterDateTimeFormat.log";
File.Delete(fileName);
var logger = MockEventSourceOutProc.Logger;
IEnumerable <TestEventEntryCustomTimeStamp> entries;
using (var svcConfiguration = TraceEventServiceConfiguration.Load("Configurations\\WithFormatter\\FlatFileJsonFormatterDateTimeFormat.xml"))
using (var evtService = new TraceEventService(svcConfiguration))
{
evtService.Start();
try
{
logger.LogSomeMessage("logging using custom DateTime format");
entries = FlatFileHelper.PollUntilJsonEventsAreWritten <TestEventEntryCustomTimeStamp>(fileName, 1);
}
finally
{
evtService.Stop();
}
}
var dt = DateTime.UtcNow;
string expectedTimestamp = dt.Day.ToString() + dt.Month.ToString() + dt.Year.ToString();
Assert.AreEqual(expectedTimestamp, entries.First().Timestamp);
}
public void WhenUsingCustomSinkAndMultipleEvents()
{
string fileName = "ProvidedCustomSink.log";
File.Delete(fileName);
var logger = MockEventSource.Logger;
IEnumerable <string> entries = null;
TestScenario.With1Listener(
logger,
listener =>
{
listener.LogToMockFlatFile(fileName, "==-==");
listener.EnableEvents(logger, EventLevel.LogAlways, Keywords.All);
logger.LogSomeMessage("some message");
logger.LogSomeMessage("some message2");
logger.LogSomeMessage("some message3");
entries = FlatFileHelper.PollUntilTextEventsAreWritten(fileName, 3, "==-==");
});
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]")));
}
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 WhenUsingFlatFile()
{
string fileName = "FlatFileOutProcCfgWS.log";
File.Delete(fileName);
string configFile = "Configurations\\WinService\\FlatFileWinService.xml";
IEnumerable <string> entries = null;
try
{
StartServiceWithConfig(configFile);
var logger = MockEventSourceOutProc.Logger;
logger.LogSomeMessage("logging to the windows service");
logger.LogSomeMessage("logging to the windows service 2");
entries = FlatFileHelper.PollUntilTextEventsAreWritten(fileName, 2, "----------");
}
finally
{
StopService();
}
Assert.AreEqual(2, entries.Count());
StringAssert.Contains(entries.First(), "Payload : [message : logging to the windows service]");
StringAssert.Contains(entries.Last(), "Payload : [message : logging to the windows service 2]");
}
public void ReconfigListenerAdded()
{
var fileName = "flatFileReconfig.log";
File.Delete(fileName);
var logger = MockEventSourceOutProc.Logger;
var configFile = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "\\Configurations\\Reconfiguration\\temp\\configFile.xml";
UpdateServiceConfigurationFile("Configurations\\Reconfiguration\\NoListener.xml", configFile);
IEnumerable <string> entries = null;
using (TraceEventServiceConfiguration svcConfiguration = TraceEventServiceConfiguration.Load(configFile, true))
using (TraceEventService collector = new TraceEventService(svcConfiguration))
{
collector.Start();
try
{
TraceSessionHelper.WaitAndAssertCountOfSessions("ServiceReconfig", 1);
UpdateServiceConfigurationFile("Configurations\\Reconfiguration\\FlatFileListener.xml", configFile);
TraceSessionHelper.WaitAndAssertCountOfSessions("ServiceReconfig-flatFileListener", 1);
MockEventSourceOutProc.Logger.LogSomeMessage("some message to new added flat file");
entries = FlatFileHelper.PollUntilTextEventsAreWritten(fileName, 1, "======");
}
finally
{
collector.Stop();
File.Delete(configFile);
}
}
Assert.AreEqual(1, entries.Count());
StringAssert.Contains(entries.First(), "some message to new added flat file");
}
public void WhenEventWithGuidPramLoggedInXml()
{
string fileName = "FlatFileXmlFormatterAndGuids.log";
File.Delete(fileName);
var logger = MockEventSourceOutProcEnum.Logger;
var testGuid = Guid.NewGuid();
IEnumerable <XElement> entries;
using (var svcConfiguration = TraceEventServiceConfiguration.Load("Configurations\\WithFormatter\\FlatFileXmlFormatterAndGuids.xml"))
using (var evtService = new TraceEventService(svcConfiguration))
{
evtService.Start();
try
{
logger.SaveExpenseStarted(testGuid);
entries = FlatFileHelper.PollUntilXmlEventsAreWritten(fileName, 1);
}
finally
{
evtService.Stop();
}
}
Assert.AreEqual(1, entries.Count());
XmlFormattedEntry.Fill(entries.Single());
Assert.AreEqual <Guid>(MockEventSourceOutProcEnum.Logger.Guid, Guid.Parse(XmlFormattedEntry.Provider.Attribute("Guid").Value));
Assert.AreEqual <int>(4, Convert.ToInt32(XmlFormattedEntry.EventId.Value));
StringAssert.Contains(XmlFormattedEntry.Payload.ToString(), testGuid.ToString());
}
public void WhenSinkIsRemoved()
{
var fileName = "flatFileReconfig.log";
File.Delete(fileName);
var logger = MockEventSourceOutProc.Logger;
var configFile = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "\\Configurations\\Reconfiguration\\temp\\configFile.xml";
UpdateServiceConfigurationFile("Configurations\\Reconfiguration\\FlatFileListener.xml", configFile);
TraceEventServiceConfiguration svcConfiguration = TraceEventServiceConfiguration.Load(configFile, true);
TestScenario.WithConfiguration(
svcConfiguration,
() =>
{
TraceSessionHelper.WaitAndAssertCountOfSessions("ServiceReconfig-flatFileListener", 1);
MockEventSourceOutProc.Logger.LogSomeMessage("some message to new added flat file");
var entries = FlatFileHelper.PollUntilTextEventsAreWritten(fileName, 1, "======");
Assert.AreEqual(1, entries.Count());
StringAssert.Contains(entries.First(), "some message to new added flat file");
UpdateServiceConfigurationFile("Configurations\\Reconfiguration\\NoListener.xml", configFile);
TraceSessionHelper.WaitAndAssertCountOfSessions("ServiceReconfig-dummyListener", 1);
TraceSessionHelper.WaitAndAssertCountOfSessions("ServiceReconfig-flatFileListener", 0);
MockEventSourceOutProc.Logger.LogSomeMessage("this message should not be logged");
var entries2 = FlatFileHelper.PollUntilTextEventsAreWritten(fileName, 1, "======");
Assert.AreEqual(1, entries2.Count());
});
File.Delete(configFile);
}
public void WhenEnablingSamplingAndTPLEvents()
{
var serviceConfigFile = "Configurations\\Sampling\\WhenEnablingSamplingForAPRocessAndTPLEvents.xml";
string fileName = "WhenEnablingSamplingForAPRocessAndTPLEvents.log";
IEnumerable <TestEventEntry> entries = null;
Guid activityId;
Guid oldActivityId;
TraceEventServiceConfiguration svcConfiguration;
InitializeTest(serviceConfigFile, fileName, out svcConfiguration, out activityId, out oldActivityId);
try
{
TestScenario.WithConfiguration(svcConfiguration, () =>
{
var triggerLogger = TriggerEventSource.Logger;
triggerLogger.TriggerEvent("triggermessage");
SamplingEventSource.Logger.BeforeEventToSample("mainmessage");
Task.Run(async() => { await LogEventsAsync(); });
SamplingEventSource.Logger.AfterEventToSample("mainmessage");
waitObject.WaitOne();
entries = FlatFileHelper.PollUntilJsonEventsAreWritten <TestEventEntry>(fileName, 50);
});
}
finally
{
EventSource.SetCurrentThreadActivityId(oldActivityId);
}
Assert.IsTrue(entries.Count() > 40 && entries.Count() < 50);
}
public void WhenEnablingSamplingForAProcessAndProcessIsNotRunning()
{
var serviceConfigFile = "Configurations\\Sampling\\WhenEnablingSamplingForAProcessAndProcessIsNotRunning.xml";
string fileName = "WhenEnablingSamplingForAProcessAndProcessIsNotRunning.log";
IEnumerable <TestEventEntry> entries = null;
Guid activityId;
Guid oldActivityId;
TraceEventServiceConfiguration svcConfiguration;
InitializeTest(serviceConfigFile, fileName, out svcConfiguration, out activityId, out oldActivityId);
try
{
TestScenario.WithConfiguration(svcConfiguration, () =>
{
var triggerLogger = TriggerEventSource.Logger;
triggerLogger.TriggerEvent("triggermessage");
SamplingEventSource.Logger.EventToSample("mainmessage");
entries = FlatFileHelper.PollUntilJsonEventsAreWritten <TestEventEntry>(fileName, 2);
});
}
finally
{
EventSource.SetCurrentThreadActivityId(oldActivityId);
}
Assert.AreEqual(0, entries.Count());
}
public void WhenInvalidKeys()
{
var serviceConfigFile = "Configurations\\Sampling\\WhenInvalidKeysInConfiguration.xml";
string fileName = "WhenInvalidKeysInConfiguration.log";
IEnumerable <TestEventEntry> entries = null;
Guid activityId;
Guid oldActivityId;
TraceEventServiceConfiguration svcConfiguration;
InitializeTest(serviceConfigFile, fileName, out svcConfiguration, out activityId, out oldActivityId);
try
{
TestScenario.WithConfiguration(svcConfiguration, () =>
{
TriggerEventSource.Logger.TriggerEvent("triggermessage1");
SamplingEventSource.Logger.EventToSample("mainmessage1");
WriteMessagesWithNewActivityId();
entries = FlatFileHelper.PollUntilJsonEventsAreWritten <TestEventEntry>(fileName, 4);
});
}
finally
{
EventSource.SetCurrentThreadActivityId(oldActivityId);
}
Assert.AreEqual(4, entries.Count());
}
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]")));
}
public void WhenEnumsInPayloadInXml()
{
string fileName = "FlatFileXmlFormatterAndEnums.log";
File.Delete(fileName);
var logger = MockEventSourceOutProcEnum.Logger;
IEnumerable <XElement> entries = null;
var svcConfiguration = TraceEventServiceConfiguration.Load("Configurations\\WithFormatter\\FlatFileXmlFormatterAndEnums.xml");
TestScenario.WithConfiguration(
svcConfiguration,
() =>
{
logger.SendEnumsEvent16(MockEventSourceOutProcEnum.MyColor.Red, MockEventSourceOutProcEnum.MyFlags.Flag3);
entries = FlatFileHelper.PollUntilXmlEventsAreWritten(fileName, 1);
});
Assert.AreEqual(1, entries.Count());
XmlFormattedEntry.Fill(entries.Single());
Assert.AreEqual <Guid>(MockEventSourceOutProcEnum.Logger.Guid, Guid.Parse(XmlFormattedEntry.Provider.Attribute("Guid").Value));
Assert.AreEqual <int>(3, Convert.ToInt32(XmlFormattedEntry.EventId.Value));
Assert.AreEqual <byte>(0, Convert.ToByte(XmlFormattedEntry.Version.Value));
Assert.AreEqual <int>((int)EventLevel.Informational, Int32.Parse(XmlFormattedEntry.Level.Value));
Assert.AreEqual <int>((int)MockEventSourceOutProcEnum.Tasks.Opcode, Int32.Parse(XmlFormattedEntry.Task.Value));
Assert.AreEqual <long>(0, Int64.Parse(XmlFormattedEntry.Keywords.Value.Replace("0x", string.Empty)));
Assert.AreEqual <int>((int)EventOpcode.Resume, Int32.Parse(XmlFormattedEntry.Opcode.Value));
Assert.AreEqual <int>(System.Diagnostics.Process.GetCurrentProcess().Id, Int32.Parse(XmlFormattedEntry.ProcessId.Value));
Assert.AreEqual <int>(ThreadHelper.GetCurrentUnManagedThreadId(), Int32.Parse(XmlFormattedEntry.ThreadId.Value));
Assert.AreEqual(2, XmlFormattedEntry.Payload.Elements().Count());
StringAssert.Contains(XmlFormattedEntry.Payload.ToString(), @"<Data Name=""a"">" + ((int)MockEventSourceOutProcEnum.MyColor.Red).ToString() + "</Data>");
StringAssert.Contains(XmlFormattedEntry.Payload.ToString(), @"<Data Name=""b"">" + ((int)MockEventSourceOutProcEnum.MyFlags.Flag3).ToString() + "</Data>");
}
public void WhenUsingXmlFormatterInIndented()
{
string fileName = "FlatFileXmlFormatterIndentedOutProc.log";
File.Delete(fileName);
var logger = MockEventSourceOutProc.Logger;
IEnumerable <XElement> entries = null;
var svcConfiguration = TraceEventServiceConfiguration.Load("Configurations\\WithFormatter\\FlatFileXmlFormatterIndentedOutProc.xml");
TestScenario.WithConfiguration(
svcConfiguration,
() =>
{
logger.LogSomeMessage("logging using xml Formatter indented");
entries = FlatFileHelper.PollUntilXmlEventsAreWritten(fileName, 1);
});
XmlFormattedEntry.Fill(entries.Single());
Assert.AreEqual <Guid>(MockEventSourceOutProc.Logger.Guid, Guid.Parse(XmlFormattedEntry.Provider.Attribute("Guid").Value));
Assert.AreEqual <int>(8, Convert.ToInt32(XmlFormattedEntry.EventId.Value));
Assert.AreEqual <byte>(0, Convert.ToByte(XmlFormattedEntry.Version.Value));
Assert.AreEqual <int>((int)EventLevel.Informational, Int32.Parse(XmlFormattedEntry.Level.Value));
Assert.AreEqual <int>(65526, Int32.Parse(XmlFormattedEntry.Task.Value));
Assert.AreEqual <long>(0, Int64.Parse(XmlFormattedEntry.Keywords.Value.Replace("0x", string.Empty)));
Assert.AreEqual <int>(0, Int32.Parse(XmlFormattedEntry.Opcode.Value));
Assert.AreEqual <int>(System.Diagnostics.Process.GetCurrentProcess().Id, Int32.Parse(XmlFormattedEntry.ProcessId.Value));
Assert.AreEqual <int>(ThreadHelper.GetCurrentUnManagedThreadId(), Int32.Parse(XmlFormattedEntry.ThreadId.Value));
Assert.AreEqual(1, XmlFormattedEntry.Payload.Elements().Count());
Assert.AreEqual("message", XmlFormattedEntry.Payload.Elements().First().Attribute("Name").Value);
Assert.AreEqual("logging using xml Formatter indented", XmlFormattedEntry.Payload.Elements().First().Value);
}
public void WhenCustomDateTimeFormatInXml()
{
string fileName = "FlatFileXmlFormatterDateTimeFormat.log";
File.Delete(fileName);
var logger = MockEventSourceOutProc.Logger;
IEnumerable <XElement> entries;
using (var svcConfiguration = TraceEventServiceConfiguration.Load("Configurations\\WithFormatter\\FlatFileXmlFormatterDateTimeFormat.xml"))
using (var evtService = new TraceEventService(svcConfiguration))
{
evtService.Start();
try
{
logger.LogSomeMessage("logging using xml Formatter not indented");
entries = FlatFileHelper.PollUntilXmlEventsAreWritten(fileName, 1);
}
finally
{
evtService.Stop();
}
}
Assert.AreEqual(1, entries.Count());
XmlFormattedEntry.Fill(entries.Single());
var dt = DateTime.UtcNow;
string expectedTimestamp = dt.Day.ToString() + dt.Month.ToString() + dt.Year.ToString();
StringAssert.Contains(XmlFormattedEntry.TimeCreated.ToString(), @"SystemTime=""" + expectedTimestamp + @"""");
}
public void WhenUsingJsonFormatterNotIndented()
{
string fileName = "FlatFileJsonFormatterOutProc.log";
File.Delete(fileName);
var logger = MockEventSourceOutProc.Logger;
IEnumerable <TestEventEntry> entries = null;
var svcConfiguration = TraceEventServiceConfiguration.Load("Configurations\\WithFormatter\\FlatFileJsonFormatterOutProc.xml");
TestScenario.WithConfiguration(
svcConfiguration,
() =>
{
logger.LogSomeMessage("logging using Json Formatter not indented");
entries = FlatFileHelper.PollUntilJsonEventsAreWritten <TestEventEntry>(fileName, 1);
});
Assert.AreEqual(1, entries.Count());
var entry = entries.First();
Assert.AreEqual(MockEventSourceOutProc.Logger.Guid, entry.ProviderId);
Assert.AreEqual(8, entry.EventId);
Assert.AreEqual(EventLevel.Informational, entry.Level);
Assert.AreEqual(EventKeywords.None, entry.EventKeywords);
Assert.AreEqual(EventOpcode.Info, entry.Opcode);
Assert.AreEqual(System.Diagnostics.Process.GetCurrentProcess().Id, entry.ProcessId);
Assert.AreEqual(ThreadHelper.GetCurrentUnManagedThreadId(), entry.ThreadId);
Assert.AreEqual(0, entry.Version);
Assert.AreEqual(1, entry.Payload.Count);
Assert.AreEqual("logging using Json Formatter not indented", (string)entry.Payload["message"]);
}
public void WhenUsingCustomSinkWithoutSchema()
{
string fileName = "ProvidedCustomSink.log";
File.Delete(fileName);
var logger = MockEventSourceOutProc.Logger;
IEnumerable <string> entries = null;
var svcConfiguration = TraceEventServiceConfiguration.Load("Configurations\\CustomSink\\MockFlatFileSink.xml");
TestScenario.WithConfiguration(
svcConfiguration,
() =>
{
logger.LogSomeMessage("some message");
logger.LogSomeMessage("some message2");
logger.LogSomeMessage("some message3");
entries = FlatFileHelper.PollUntilTextEventsAreWritten(fileName, 3, "==-==");
});
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]")));
}
public void OutProcKeywordsFiltering()
{
var fileName = "keywordFiltering.log";
File.Delete(fileName);
var logger = MockEventSourceOutProcKeywords.Logger;
IEnumerable <string> entries = null;
using (TraceEventServiceConfiguration svcConfiguration = TraceEventServiceConfiguration.Load("Configurations\\KeywordFiltering\\keywordFiltering.xml"))
using (TraceEventService collector = new TraceEventService(svcConfiguration))
{
collector.Start();
try
{
logger.InformationalPage("some informational message filtered by Page keyword");
logger.InformationalDatabase("some informational message filtered by Database keyword");
logger.InformationalDiagnostic("some informational message filtered by Diagnostic keyword");
entries = FlatFileHelper.PollUntilTextEventsAreWritten(fileName, 2, "======");
}
finally
{
collector.Stop();
}
}
Assert.AreEqual(2, entries.Count());
StringAssert.Contains(entries.First().ToString(), "some informational message filtered by Page keyword");
StringAssert.Contains(entries.First().ToString(), "Keywords : 1");
StringAssert.Contains(entries.Last().ToString(), "some informational message filtered by Database keyword");
StringAssert.Contains(entries.Last().ToString(), "Keywords : 2");
}
public void WhenEnumsInPayloadInJson()
{
string fileName = @".\Logs\FlatFileJsonAndEnums.log";
FlatFileHelper.DeleteDirectory(@".\Logs");
var logger = MockEventSourceOutProcEnum.Logger;
IEnumerable <TestEventEntryCustomTimeStamp> entries = null;
var svcConfiguration = TraceEventServiceConfiguration.Load("Configurations\\WithFormatter\\FlatFileJsonAndEnums.xml");
TestScenario.WithConfiguration(
svcConfiguration,
() =>
{
logger.SendEnumsEvent15(MockEventSourceOutProcEnum.MyColor.Blue, MockEventSourceOutProcEnum.MyFlags.Flag2);
entries = FlatFileHelper.PollUntilJsonEventsAreWritten <TestEventEntryCustomTimeStamp>(fileName, 1);
});
Assert.AreEqual(1, entries.Count());
var entry = entries.First();
Assert.AreEqual(2, entry.Payload.Count);
Assert.AreEqual((long)MockEventSourceOutProcEnum.MyColor.Blue, (long)entry.Payload["a"]);
Assert.AreEqual((long)MockEventSourceOutProcEnum.MyFlags.Flag2, (long)entry.Payload["b"]);
}
public void OutProcWhenFormatterWithValuesForProperties()
{
string fileName = "FlatFileFormatterOutProc.log";
File.Delete(fileName);
IEnumerable <string> entries = null;
using (var svcConfiguration = TraceEventServiceConfiguration.Load("Configurations\\FlatFile\\FlatFileFormatterOutProc.xml"))
using (var eventCollectorService = new TraceEventService(svcConfiguration))
{
eventCollectorService.Start();
try
{
MockEventSourceOutProc.Logger.LogSomeMessage("some message");
MockEventSourceOutProc.Logger.LogSomeMessage("some message2");
entries = FlatFileHelper.PollUntilTextEventsAreWritten(fileName, 2, "=======");
}
finally
{
eventCollectorService.Stop();
}
}
Assert.AreEqual(2, entries.Count());
StringAssert.Contains(entries.First(), "some message");
StringAssert.Contains(entries.Last(), "some message2");
}
public void WhenUsingCustomFormatter()
{
string fileName = "FlatFileOutProcConfigCF2.log";
File.Delete(fileName);
var logger = MockEventSourceOutProc.Logger;
IEnumerable <string> entries = null;
var svcConfiguration = TraceEventServiceConfiguration.Load("Configurations\\CustomSink\\FlatFileCustomFormatter2.xml");
using (TraceEventService collector = new TraceEventService(svcConfiguration))
{
try
{
collector.Start();
logger.LogSomeMessage("some message using formatter");
entries = FlatFileHelper.PollUntilTextEventsAreWritten(fileName, 1, "----------");
}
finally
{
collector.Stop();
}
}
StringAssert.Contains(entries.First(), "Mock SourceId");
StringAssert.Contains(entries.First(), "Mock EventId");
StringAssert.Contains(entries.First(), "Payload : [message : some message using formatter]");
}
public void WhenSomeKeywordsAreFiltered()
{
var fileName = "keywordFiltering.log";
File.Delete(fileName);
var logger = MockEventSourceOutProcKeywords.Logger;
IEnumerable <string> entries = null;
TraceEventServiceConfiguration svcConfiguration = TraceEventServiceConfiguration.Load("Configurations\\KeywordFiltering\\keywordFiltering.xml");
TestScenario.WithConfiguration(
svcConfiguration,
() =>
{
logger.InformationalPage("some informational message filtered by Page keyword");
logger.InformationalDatabase("some informational message filtered by Database keyword");
logger.InformationalDiagnostic("some informational message filtered by Diagnostic keyword");
entries = FlatFileHelper.PollUntilTextEventsAreWritten(fileName, 2, "======");
});
Assert.AreEqual(2, entries.Count());
StringAssert.Contains(entries.First().ToString(), "some informational message filtered by Page keyword");
StringAssert.Contains(entries.First().ToString(), "Keywords : 1");
StringAssert.Contains(entries.Last().ToString(), "some informational message filtered by Database keyword");
StringAssert.Contains(entries.Last().ToString(), "Keywords : 2");
}
public void WhenUsingCustomFormatter()
{
string fileName = "FlatFileInProcCustomFormatter.log";
File.Delete(fileName);
string header = "----------";
var logger = TestEventSourceNonTransient.Logger;
var formatter = new CustomFormatterWithWait(header);
formatter.Detailed = EventLevel.LogAlways;
IEnumerable <string> entries = null;
TestScenario.With1Listener(
logger,
listener =>
{
listener.LogToFlatFile(fileName, formatter);
listener.EnableEvents(logger, EventLevel.LogAlways);
logger.EventWithPayload("payload1", 100);
entries = FlatFileHelper.PollUntilTextEventsAreWritten(fileName, 1, header);
});
StringAssert.Contains(entries.First(), "Mock SourceId");
StringAssert.Contains(entries.First(), "Mock EventId");
StringAssert.Contains(entries.First(), "Payload : [payload1 : payload1] [payload2 : 100]");
}
public static FlatFileHelper GetContext()
{
if (_context == null)
{
_context = new FlatFileHelper();
}
return(_context);
}
public void WhenUsingFlatFile()
{
IEnumerable <string> entries = null;
entries = FlatFileHelper.PollUntilTextEventsAreWritten(FlatFileName, 2, "----------");
Assert.AreEqual(2, entries.Count());
StringAssert.Contains(entries.First(), "Payload : [message : logging to the windows service]");
StringAssert.Contains(entries.Last(), "Payload : [message : logging to the windows service 2]");
}
//by monica and hang 11/11/2017
public List <PackageEntity> DetailsPackage(String Name, int PackageId, String Description, int Price, DateTime startDate, DateTime endDate)
{
var data = FlatFileHelper.ListAllPackages();
return(data.Select(x => x).ToList());
//Getting the DBContext through a singleton design pattern
//SingletonDBContext.GetContext().Packages.ToList();
}
public void ReconfigTwoSourcesListenerAddedThenRemoved()
{
var fileName = "flatFileReconfig.log";
File.Delete(fileName);
var logger = MockEventSourceOutProc.Logger;
var configFile = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "\\Configurations\\Reconfiguration\\temp\\configFile.xml";
UpdateServiceConfigurationFile("Configurations\\Reconfiguration\\FlatFileListenerTwoSources.xml", configFile);
TraceEventServiceConfiguration svcConfiguration = TraceEventServiceConfiguration.Load(configFile, true);
using (TraceEventService collector = new TraceEventService(svcConfiguration))
{
collector.Start();
try
{
TraceSessionHelper.WaitAndAssertCountOfSessions("ServiceReconfig-flatFileListener", 1);
MockEventSourceOutProc.Logger.LogSomeMessage("some message to new added flat file");
var entries = FlatFileHelper.PollUntilTextEventsAreWritten(fileName, 1, "======");
Assert.AreEqual(1, entries.Count());
StringAssert.Contains(entries.First(), "some message to new added flat file");
UpdateServiceConfigurationFile("Configurations\\Reconfiguration\\FlatFileListenerTwoSourcesSameListener.xml", configFile);
TraceSessionHelper.WaitAndAssertCountOfSessions("ServiceReconfig-flatFileListener", 1);
MockEventSourceOutProc.Logger.LogSomeMessage("some message to new added flat file2");
MockEventSourceOutProc2.Logger.LogSomeMessage("some message to new added flat file3");
var entries2 = FlatFileHelper.PollUntilTextEventsAreWritten(fileName, 3, "======");
Assert.AreEqual(3, entries2.Count());
StringAssert.Contains(entries2.First(), "some message to new added flat file");
StringAssert.Contains(entries2.ElementAt(1), "some message to new added flat file2");
StringAssert.Contains(entries2.Last(), "some message to new added flat file3");
UpdateServiceConfigurationFile("Configurations\\Reconfiguration\\FlatFileListenerTwoSources.xml", configFile);
TraceSessionHelper.WaitAndAssertCountOfSessions("ServiceReconfig-flatFileListener", 1);
MockEventSourceOutProc.Logger.LogSomeMessage("last message to new added flat file");
var entries3 = FlatFileHelper.PollUntilTextEventsAreWritten(fileName, 4, "======");
Assert.AreEqual(4, entries3.Count());
StringAssert.Contains(entries3.Last(), "last message to new added flat file");
UpdateServiceConfigurationFile("Configurations\\Reconfiguration\\FlatFileListenerTwoSourcesNoListener.xml", configFile);
TraceSessionHelper.WaitAndAssertCountOfSessions("ServiceReconfig-flatFileListener", 0);
}
finally
{
collector.Stop();
File.Delete(configFile);
}
}
}
public void WhenMultipleCustomSinksSubscribing()
{
string fileName1 = "mockFlatFileMutiple.log";
File.Delete(fileName1);
string fileName2 = "flatFileMultiple.log";
File.Delete(fileName2);
var validConnectionString = System.Configuration.ConfigurationManager.ConnectionStrings["valid"].ConnectionString;
DatabaseHelper.CleanLoggingDB(validConnectionString);
var logger = MockEventSource.Logger;
string message = string.Concat("Message ", Guid.NewGuid());
string message2 = string.Concat("Message2 ", Guid.NewGuid());
IEnumerable <string> entries = null;
IEnumerable <string> entries2 = null;
using (var eventListener = new ObservableEventListener())
{
try
{
eventListener.LogToMockFlatFile(fileName1, "==-==");
eventListener.LogToFlatFile(fileName2, new EventTextFormatter("--==--"));
eventListener.LogToSqlDatabase("testInstance", validConnectionString, "Traces", TimeSpan.Zero, 1);
eventListener.LogToCustomSqlDatabase("testCustom", validConnectionString);
eventListener.EnableEvents(logger, System.Diagnostics.Tracing.EventLevel.LogAlways, Keywords.All);
logger.LogSomeMessage(message);
logger.LogSomeMessage(message2);
entries = FlatFileHelper.PollUntilTextEventsAreWritten(fileName1, 2, "==-==");
entries2 = FlatFileHelper.PollUntilTextEventsAreWritten(fileName2, 2, "--==--");
}
finally
{
eventListener.DisableEvents(logger);
}
}
Assert.IsTrue(File.Exists(fileName1));
Assert.AreEqual <int>(2, entries.Count());
StringAssert.Contains(entries.First().ToString(), message);
StringAssert.Contains(entries.Last().ToString(), message2);
Assert.IsTrue(File.Exists(fileName2));
Assert.AreEqual <int>(2, entries.Count());
StringAssert.Contains(entries.First().ToString(), message);
StringAssert.Contains(entries.Last().ToString(), message2);
var dt = DatabaseHelper.GetLoggedTable(validConnectionString);
Assert.AreEqual(4, dt.Rows.Count);
}
public void TestingDynamicManifestUpdate()
{
var fileName = "twoflatFileListeners.log";
File.Delete(fileName);
var fileName2 = "twoflatFileListeners2.log";
File.Delete(fileName2);
var svcConfiguration = TraceEventServiceConfiguration.Load("Configurations\\Reconfiguration\\TwoFlatFileListeners.xml");
using (TraceEventService collector = new TraceEventService(svcConfiguration))
{
collector.Start();
try
{
var newDomain = AppDomain.CreateDomain("TestintDynamicManifest", AppDomain.CurrentDomain.Evidence, AppDomain.CurrentDomain.SetupInformation);
try
{
var instance = (IsolatedExecutingClass)newDomain.CreateInstanceAndUnwrap(Assembly.GetExecutingAssembly().FullName, typeof(IsolatedExecutingClass).FullName);
instance.TestWithSource1();
}
finally
{
AppDomain.Unload(newDomain);
}
newDomain = AppDomain.CreateDomain("TestintDynamicManifest", AppDomain.CurrentDomain.Evidence, AppDomain.CurrentDomain.SetupInformation);
try
{
var instance = (IsolatedExecutingClass)newDomain.CreateInstanceAndUnwrap(Assembly.GetExecutingAssembly().FullName, typeof(IsolatedExecutingClass).FullName);
instance.TestWithSource2();
}
finally
{
AppDomain.Unload(newDomain);
}
var entries = FlatFileHelper.PollUntilTextEventsAreWritten(fileName, 2, "======");
Assert.AreEqual(2, entries.Count());
entries = FlatFileHelper.PollUntilTextEventsAreWritten(fileName2, 2, "======");
Assert.AreEqual(2, entries.Count());
}
finally
{
collector.Stop();
}
}
}
public void FlatFileSomeFilteredSomeNot()
{
var logger = MockEventSourceOutProc.Logger;
EventTextFormatter formatter = new EventTextFormatter(EventTextFormatter.DashSeparator);
var fileName = "FlatFileAllFiltered.log";
File.Delete(fileName);
EventSourceSettings settings = new EventSourceSettings("MockEventSourceOutProc", null, EventLevel.Error);
var subject = new EventEntrySubject();
subject.LogToFlatFile(fileName, formatter);
SinkSettings sinkSettings = new SinkSettings("flatFileSink", subject, new List <EventSourceSettings>()
{
{ settings }
});
List <SinkSettings> sinks = new List <SinkSettings>()
{
{ sinkSettings }
};
TraceEventServiceConfiguration svcConfiguration = new TraceEventServiceConfiguration(sinks);
IEnumerable <string> entries = null;
using (TraceEventService collector = new TraceEventService(svcConfiguration))
{
collector.Start();
try
{
for (int n = 0; n < 200; n++)
{
logger.LogSomeMessage("some message " + n.ToString());
logger.Critical("some error " + n.ToString());
}
entries = FlatFileHelper.PollUntilTextEventsAreWritten(fileName, 200, EventTextFormatter.DashSeparator);
}
finally
{
collector.Stop();
}
}
Assert.AreEqual(200, entries.Count());
StringAssert.Contains(entries.First(), "some error 0");
StringAssert.Contains(entries.Last(), "some error 199");
}
public void OutProcFiltering()
{
var fileName = "levelFiltering.log";
File.Delete(fileName);
var fileName2 = "levelFiltering2.log";
File.Delete(fileName2);
var fileName3 = "levelFiltering3.log";
File.Delete(fileName3);
var logger = MockEventSourceOutProcFiltering.Logger;
IEnumerable <string> entries = null;
IEnumerable <string> entries2 = null;
IEnumerable <string> entries3 = null;
using (TraceEventServiceConfiguration svcConfiguration = TraceEventServiceConfiguration.Load("Configurations\\LevelFiltering\\LevelFiltering.xml"))
using (TraceEventService collector = new TraceEventService(svcConfiguration))
{
collector.Start();
try
{
logger.Informational("some informational message");
logger.Verbose("some verbose");
logger.Critical("some critical");
logger.Error("some error");
logger.Warning("some warning");
entries = FlatFileHelper.PollUntilTextEventsAreWritten(fileName, 1, "======");
entries2 = FlatFileHelper.PollUntilTextEventsAreWritten(fileName2, 2, "======");
entries3 = FlatFileHelper.PollUntilTextEventsAreWritten(fileName3, 3, "======");
}
finally
{
collector.Stop();
}
}
StringAssert.Contains(entries.First().ToString(), "some critical");
StringAssert.Contains(entries2.First().ToString(), "some critical");
StringAssert.Contains(entries2.Last().ToString(), "some error");
Assert.AreEqual(1, entries3.Where(e => e.Contains("some error")).Count());
Assert.AreEqual(1, entries3.Where(e => e.Contains("some critical")).Count());
Assert.AreEqual(1, entries3.Where(e => e.Contains("some warning")).Count());
}