public void WhenOneSourceTwoListenersConcurrently()
{
var consoleOutputInterceptor = new MockConsoleOutputInterceptor();
var formatter = new EventTextFormatter(EventTextFormatter.DashSeparator);
var logger = MockConsoleListenerEventSource.Logger;
TestScenario.With2Listeners(
logger,
(listener1, listener2) =>
{
listener1.LogToConsole();
listener2.LogToConsole();
int maxLoggedEntries = 9;
string criticalMessage = string.Concat("CriticalMessage");
string infoMessage = string.Concat("InfoMessage");
listener1.EnableEvents(logger, EventLevel.Critical);
listener2.EnableEvents(logger, EventLevel.Critical);
Parallel.Invoke(Enumerable.Range(0, maxLoggedEntries).Select(i =>
new Action(() =>
{
logger.Critical(i + criticalMessage);
})).ToArray());
});
var entry = Regex.Split(consoleOutputInterceptor.Ouput, formatter.Header).Where(c => !string.IsNullOrWhiteSpace(c)).SingleOrDefault();
Assert.IsNotNull(entry);
}
public void WhenOneListenerTwoSources()
{
var consoleOutputInterceptor = new MockConsoleOutputInterceptor();
var formatter = new EventTextFormatter(EventTextFormatter.DashSeparator);
var logger = MockConsoleListenerEventSource.Logger;
var logger2 = MockConsoleListenerEventSource2.Logger;
string message = string.Concat("Message ", Guid.NewGuid());
string errorMessage = string.Concat("Error ", Guid.NewGuid());
TestScenario.With1Listener(
new EventSource[] { logger, logger2 },
listener =>
{
listener.LogToConsole();
listener.EnableEvents(logger, EventLevel.LogAlways);
listener.EnableEvents(logger2, EventLevel.LogAlways);
logger.Informational(message);
logger2.Informational(message);
});
var entry = Regex.Split(consoleOutputInterceptor.Ouput, formatter.Header).Where(c => !string.IsNullOrWhiteSpace(c)).SingleOrDefault();
Assert.IsNotNull(entry);
StringAssert.Contains(entry, "100");
}
public void WhenActivityIdAndRelatedActivityId()
{
var consoleOutputInterceptor = new MockConsoleOutputInterceptor();
var formatter = new EventTextFormatter(EventTextFormatter.DashSeparator);
var logger = MockConsoleListenerEventSource.Logger;
var activityId = Guid.NewGuid();
var relatedActivityId = Guid.NewGuid();
var previousActivityId = Guid.Empty;
EventSource.SetCurrentThreadActivityId(activityId, out previousActivityId);
TestScenario.With1Listener(
logger,
listener =>
{
listener.LogToConsole();
listener.EnableEvents(logger, EventLevel.Critical);
logger.CriticalWithRelatedActivityId("This is to log critical in Console", relatedActivityId);
});
EventSource.SetCurrentThreadActivityId(previousActivityId);
var entry = Regex.Split(consoleOutputInterceptor.Ouput, formatter.Header).Where(c => !string.IsNullOrWhiteSpace(c)).SingleOrDefault();
Assert.IsNotNull(entry);
StringAssert.Contains(entry, "800");
StringAssert.Contains(entry, "Keywords : None");
Assert.AreEqual(DefaultConsoleColorMapper.Critical, consoleOutputInterceptor.OutputForegroundColor);
StringAssert.Contains(entry, "ActivityId : " + activityId.ToString());
StringAssert.Contains(entry, "RelatedActivityId : " + relatedActivityId.ToString());
}
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 WritesDetailedOnEventLevel()
{
var formatter = new EventTextFormatter(EventTextFormatter.DashSeparator)
{
VerbosityThreshold = EventLevel.Critical
};
using (var listener = new InMemoryEventListener(formatter))
{
listener.EnableEvents(Logger, EventLevel.LogAlways, EventKeywords.All);
Logger.Failure("Summary");
formatter.VerbosityThreshold = EventLevel.Error;
Logger.Failure("Detailed");
var entries = Regex.Split(listener.ToString(), formatter.Header + "\r\n").Where(c => !string.IsNullOrWhiteSpace(c)).ToList();
StringAssert.Contains(entries[0], "EventId : 1");
StringAssert.Contains(entries[0], "Level : Error");
StringAssert.Contains(entries[0], "Payload : [message : Summary]");
StringAssert.Contains(entries[1],
@"ProviderId : 659518be-d338-564b-2759-c63c10ef82e2
EventId : 1
Keywords : 4
Level : Error
Message : Application Failure: Detailed
Opcode : Info
Task : 65533
Version : 0
Payload : [message : Detailed]
EventName : FailureInfo");
}
}
public void SkipsEmptyActivityIdsOnSummary()
{
var formatter = new EventTextFormatter(verbosityThreshold: EventLevel.Critical);
using (var writer = new StringWriter())
{
formatter.WriteEvent(
new EventEntry(
Guid.NewGuid(),
0,
string.Empty,
new System.Collections.ObjectModel.ReadOnlyCollection <object>(new object[0]),
DateTimeOffset.MaxValue,
Guid.Empty,
Guid.Empty,
new EventSourceSchemaReader().GetSchema(Logger).Values.First()),
writer);
var message = writer.ToString();
var activityIdMatch = Regex.Match(message, "\\bActivityId : (?<id>[-A-Fa-f0-9]+)\\w?").Groups["id"].Value;
var relatedActivityIdMatch = Regex.Match(message, "\\bRelatedActivityId : (?<id>[-A-Fa-f0-9]+)\\w?").Groups["id"].Value;
Assert.AreEqual(string.Empty, relatedActivityIdMatch);
Assert.AreEqual(string.Empty, relatedActivityIdMatch);
}
}
private static async Task SendSuccessMailInternal([NotNull] string description, [NotNull] string message, TimeSpan duration)
{
var errors = EventSourceRegistrar.GetSessionErrors();
var eventFormatter = new EventTextFormatter();
string errorsText;
using (var writer = new StringWriter())
{
foreach (var error in errors)
{
eventFormatter.WriteEvent(error, writer);
}
errorsText = writer.ToString();
}
CommonEventSource.Log.SendSuccessMailStart(description);
var from = new EmailAddress("*****@*****.**", "HLTBS webjobs");
var to = new EmailAddress("*****@*****.**", "HLTBS contact");
var subject = String.Format(CultureInfo.InvariantCulture, "{0} - Success ({1}) [{2}]",
WebJobName, duration, message + (errors.Length == 0 ? String.Empty : " (with session errors)"));
var text = String.Format(CultureInfo.InvariantCulture, "{1}{0}Run ID: {2}{0}Start time: {3}{0}End time:{4}{0}Output log file: {5}{6}",
Environment.NewLine, GetTriggeredRunUrl(), WebJobRunId, DateTime.UtcNow - duration, DateTime.UtcNow, GetTriggeredLogUrl(),
errors.Length == 0 ? String.Empty : String.Format("{0}Session Errors:{0}{1}", Environment.NewLine, errorsText));
var mail = MailHelper.CreateSingleEmail(from, to, subject, text, null);
using (var response = await SendGridClient.PostAsJsonAsync <SendGridMessage, string>(SendGridApiSendAddress, mail))
{
CommonEventSource.Log.SendSuccessMailStop(
description, response.ResponseMessage.StatusCode, response.ResponseMessage.Headers.ToString(), response.Content);
}
}
public void WhenConcurrentEventsRaised()
{
var logger = MockEventSourceOutProc.Logger;
EventTextFormatter formatter = new EventTextFormatter();
EventSourceSettings settings = new EventSourceSettings("MockEventSourceOutProc", null, EventLevel.LogAlways);
InMemorySink sink = new InMemorySink(formatter);
SinkSettings sinkSettings = new SinkSettings("memorySink", sink, new List <EventSourceSettings>()
{
{ settings }
});
List <SinkSettings> sinks = new List <SinkSettings>()
{
{ sinkSettings }
};
TraceEventServiceConfiguration svcConfiguration = new TraceEventServiceConfiguration(sinks);
TestScenario.WithConfiguration(
svcConfiguration,
() =>
{
sink.WaitSignalCondition = () => sink.EventWrittenCount == 100;
for (int n = 0; n < 100; n++)
{
logger.LogSomeMessage("some message" + n.ToString());
}
sink.WaitOnAsyncEvents.WaitOne(TimeSpan.FromSeconds(10));
});
StringAssert.Contains(sink.ToString(), "some message99");
}
public void WritesProcessIdAndThreadIdOnSummary()
{
var formatter = new EventTextFormatter(verbosityThreshold: EventLevel.Critical);
using (var writer = new StringWriter())
{
var processId = 200;
var threadId = 300;
formatter.WriteEvent(
new EventEntry(
Guid.NewGuid(),
0,
string.Empty,
new System.Collections.ObjectModel.ReadOnlyCollection <object>(new object[0]),
DateTimeOffset.MaxValue,
processId,
threadId,
Guid.Empty,
Guid.Empty,
new EventSourceSchemaReader().GetSchema(Logger).Values.First()),
writer);
var message = writer.ToString();
var processIdMatch = Regex.Match(message, "\\bProcessId : (?<id>\\d+)\\w?").Groups["id"].Value;
var threadIdMatch = Regex.Match(message, "\\bThreadId : (?<id>\\d+)\\w?").Groups["id"].Value;
Assert.AreEqual(processId.ToString(), processIdMatch);
Assert.AreEqual(threadId.ToString(), threadIdMatch);
}
}
public void WritesNonEmptyActivityIds()
{
var formatter = new EventTextFormatter();
using (var writer = new StringWriter())
{
var activityId = Guid.NewGuid();
var relatedActivityId = Guid.NewGuid();
formatter.WriteEvent(
new EventEntry(
Guid.NewGuid(),
0,
string.Empty,
new System.Collections.ObjectModel.ReadOnlyCollection <object>(new object[0]),
DateTimeOffset.MaxValue,
200,
300,
activityId,
relatedActivityId,
new EventSourceSchemaReader().GetSchema(Logger).Values.First()),
writer);
var message = writer.ToString();
var activityIdMatch = Regex.Match(message, "\\bActivityId : (?<id>[-A-Fa-f0-9]+)\\w?").Groups["id"].Value;
var relatedActivityIdMatch = Regex.Match(message, "\\bRelatedActivityId : (?<id>[-A-Fa-f0-9]+)\\w?").Groups["id"].Value;
Assert.AreEqual(activityId.ToString(), activityIdMatch);
Assert.AreEqual(relatedActivityId.ToString(), relatedActivityIdMatch);
}
}
public void SetUp()
{
AppDomain.CurrentDomain.SetData("APPBASE", Environment.CurrentDirectory);
this.fileName = Path.ChangeExtension(Guid.NewGuid().ToString("N"), ".log");
this.eventTextFormatter = new EventTextFormatter(EventTextFormatter.DashSeparator);
this.listener = new ObservableEventListener();
}
public void WhenThreadId()
{
var validConnectionString = System.Configuration.ConfigurationManager.ConnectionStrings["valid"].ConnectionString;
DatabaseHelper.CleanLoggingDB(validConnectionString);
var logger = MockEventSourceOutProcEnum.Logger;
EventTextFormatter formatter = new EventTextFormatter();
System.Data.DataTable eventsDataTable = null;
var subject = new EventEntrySubject();
subject.LogToSqlDatabase("testInstance", validConnectionString, "Traces", bufferingCount: 1);
EventSourceSettings settings = new EventSourceSettings("MockEventSourceOutProcEnum", null, EventLevel.LogAlways);
SinkSettings sinkSettings = new SinkSettings("sqlDBsink", subject, new List <EventSourceSettings>()
{
{ settings }
});
List <SinkSettings> sinks = new List <SinkSettings>()
{
{ sinkSettings }
};
TraceEventServiceConfiguration svcConfiguration = new TraceEventServiceConfiguration(sinks);
TestScenario.WithConfiguration(
svcConfiguration,
() =>
{
logger.SaveExpenseStarted(Guid.NewGuid());
eventsDataTable = DatabaseHelper.PollUntilEventsAreWritten(validConnectionString, 1);
});
Assert.AreEqual(1, eventsDataTable.Rows.Count);
Assert.AreEqual(ThreadHelper.GetCurrentUnManagedThreadId(), Convert.ToInt32(eventsDataTable.Rows[0]["ThreadId"]));
}
public override bool OnStart()
{
digest_event_log_listener.EnableEvents(Log, EventLevel.LogAlways,
AzureDigestEventSource.Keywords.Perf | AzureDigestEventSource.Keywords.Diagnostic);
EventTextFormatter formatter = new EventTextFormatter()
{
VerbosityThreshold = EventLevel.Error
};
digest_event_log_listener.LogToFlatFile("Overlord.Digest.Azure.log", formatter, true);
storage_event_log_listener.EnableEvents(AzureStorageEventSource.Log, EventLevel.LogAlways,
AzureStorageEventSource.Keywords.Perf | AzureStorageEventSource.Keywords.Diagnostic);
storage_event_log_listener.LogToFlatFile("Overlord.Storage.Azure.log", formatter, true);
// Set the maximum number of concurrent connections
jss.Converters.Add(new GuidConverter());
ServicePointManager.DefaultConnectionLimit = 12;
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
bool result = base.OnStart();
Trace.TraceInformation("Overlord.Digest.Azure has been started");
return(result);
}
public void WritingNullEntryThrows()
{
var formatter = new EventTextFormatter();
using (var writer = new StringWriter())
{
formatter.WriteEvent(null, writer);
}
}
public void TwoCollectorsSameEventSource()
{
var validConnectionString = System.Configuration.ConfigurationManager.ConnectionStrings["valid"].ConnectionString;
DatabaseHelper.CleanLoggingDB(validConnectionString);
var logger = MockEventSourceOutProc.Logger;
EventTextFormatter formatter = new EventTextFormatter();
EventSourceSettings settings = new EventSourceSettings("MockEventSourceOutProc", null, EventLevel.LogAlways);
var subject = new EventEntrySubject();
subject.LogToSqlDatabase("testInstance", validConnectionString, "Traces", TimeSpan.FromSeconds(1), 1);
SinkSettings sinkSettings = new SinkSettings("dbSink", subject, new List <EventSourceSettings>()
{
{ settings }
});
var subject2 = new EventEntrySubject();
subject2.LogToSqlDatabase("testInstance", validConnectionString, "Traces", TimeSpan.FromSeconds(1), 1);
SinkSettings sinkSettings2 = new SinkSettings("dbSink2", subject2, new List <EventSourceSettings>()
{
{ settings }
});
System.Data.DataTable eventsDataTable = null;
List <SinkSettings> sinks = new List <SinkSettings>()
{
sinkSettings, sinkSettings2
};
TraceEventServiceConfiguration svcConfiguration = new TraceEventServiceConfiguration(sinks);
using (TraceEventService collector = new TraceEventService(svcConfiguration))
using (TraceEventService collector2 = new TraceEventService(svcConfiguration))
{
collector.Start();
collector2.Start();
try
{
for (int n = 0; n < 10; n++)
{
logger.LogSomeMessage("some message" + n.ToString());
}
eventsDataTable = DatabaseHelper.PollUntilEventsAreWritten(validConnectionString, 20);
}
finally
{
collector.Stop();
collector2.Stop();
}
}
Assert.AreEqual(20, eventsDataTable.Rows.Count);
StringAssert.Contains(eventsDataTable.Rows[0]["payload"].ToString(), "some message");
}
public AzureStorageIngestTests()
{
EventTextFormatter formatter = new EventTextFormatter()
{
VerbosityThreshold = EventLevel.Error
};
storage_event_log_listener.EnableEvents(AzureStorageEventSource.Log, EventLevel.LogAlways,
AzureStorageEventSource.Keywords.Perf | AzureStorageEventSource.Keywords.Diagnostic);
storage_event_log_listener.LogToFlatFile("Overlord.Storage.Azure.log", formatter, true);
}
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 Configure()
{
var formatter = new EventTextFormatter()
{
VerbosityThreshold = EventLevel.Error
};
ObservableEventListener http_event_log_listener = new ObservableEventListener();
http_event_log_listener.EnableEvents(HttpEventSource.Log, EventLevel.LogAlways,
HttpEventSource.Keywords.Perf | HttpEventSource.Keywords.Diagnostic);
http_event_log_listener.LogToFlatFile("Overlord.Http.log", formatter, true);
}
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);
}
public void WritesEventData()
{
var formatter = new EventTextFormatter(EventTextFormatter.DashSeparator)
{
VerbosityThreshold = EventLevel.Critical
};
using (var listener = new InMemoryEventListener(formatter))
{
listener.EnableEvents(Logger, EventLevel.LogAlways, Keywords.All);
Logger.Failure("Failure message");
formatter.VerbosityThreshold = EventLevel.Informational;
Logger.DBQueryStart("select * from table");
Logger.DBQueryStop();
Logger.LogColor(MyColor.Red);
var entries = Regex.Split(listener.ToString(), formatter.Header + "\r\n").Where(c => !string.IsNullOrWhiteSpace(c)).ToList();
StringAssert.Contains(entries[0], "EventId : 1");
StringAssert.Contains(entries[0], "Level : Error");
StringAssert.Contains(entries[0], "Payload : [message : Failure message]");
StringAssert.Contains(Regex.Replace(entries[1], @"\s+", string.Empty), Regex.Replace(
@"EventId : 5
Keywords : 2
Level : Informational
Message :
Opcode : Start
Task : 2
Version : 0
Payload : [sqlQuery : select * from table]", @"\s+", string.Empty));
StringAssert.Contains(Regex.Replace(entries[2], @"\s+", string.Empty), Regex.Replace(
@"EventId : 6
Keywords : 2
Level : Informational
Message :
Opcode : Stop
Task : 2
Version : 0
Payload :", @"\s+", string.Empty));
StringAssert.Contains(Regex.Replace(entries[3], @"\s+", string.Empty), Regex.Replace(
@"EventId : 8
Keywords : None
Level : Informational
Message :
Opcode : Info
Task : 65526
Version : 0
Payload : [color : 0]", @"\s+", string.Empty));
}
}
public void WritesCustomFooter()
{
var formatter = new EventTextFormatter(null, "___footer___");
using (var listener = new InMemoryEventListener(formatter))
{
listener.EnableEvents(Logger, EventLevel.LogAlways, EventKeywords.All);
Logger.Startup();
Assert.IsTrue(listener.ToString().Contains(formatter.Footer));
}
}
public void WritesCustomHeader()
{
var formatter = new EventTextFormatter("*** header ***");
using (var listener = new InMemoryEventListener(formatter))
{
listener.EnableEvents(Logger, EventLevel.LogAlways, EventKeywords.All);
Logger.DBQueryStart("select * from table");
Assert.IsTrue(listener.ToString().Contains(formatter.Header));
}
}
public void WhenTwoEventSourcesAreUsedInOneCollector()
{
var validConnectionString = System.Configuration.ConfigurationManager.ConnectionStrings["valid"].ConnectionString;
DatabaseHelper.CleanLoggingDB(validConnectionString);
var logger = MockEventSourceOutProc.Logger;
var logger2 = MockEventSourceOutProc2.Logger;
EventTextFormatter formatter = new EventTextFormatter();
EventSourceSettings settings = new EventSourceSettings("MockEventSourceOutProc", null, EventLevel.LogAlways);
EventSourceSettings settings2 = new EventSourceSettings("MockEventSourceOutProc2", null, EventLevel.LogAlways);
var subject = new EventEntrySubject();
subject.LogToSqlDatabase("testInstance", validConnectionString, "Traces", TimeSpan.FromSeconds(1), 1);
SinkSettings sinkSettings = new SinkSettings("dbSink", subject, new List <EventSourceSettings>()
{
settings, settings2
});
List <SinkSettings> sinks = new List <SinkSettings>()
{
sinkSettings
};
TraceEventServiceConfiguration svcConfiguration = new TraceEventServiceConfiguration(sinks);
TestScenario.WithConfiguration(
svcConfiguration,
() =>
{
for (int n = 0; n < 200; n++)
{
logger.LogSomeMessage("some message" + n.ToString());
}
var eventsDataTable = DatabaseHelper.PollUntilEventsAreWritten(validConnectionString, 200);
Assert.AreEqual(200, eventsDataTable.Rows.Count);
StringAssert.Contains(eventsDataTable.Rows[0]["payload"].ToString(), "some message");
DatabaseHelper.CleanLoggingDB(validConnectionString);
for (int n = 0; n < 200; n++)
{
logger2.LogSomeMessage("some message" + n.ToString());
}
var eventsDataTable2 = DatabaseHelper.PollUntilEventsAreWritten(validConnectionString, 200);
Assert.AreEqual(200, eventsDataTable2.Rows.Count);
StringAssert.Contains(eventsDataTable2.Rows[0]["payload"].ToString(), "some message");
});
}
public void WritesCustomHeaderAndFooter()
{
var formatter = new EventTextFormatter("---header---", "___footer___");
using (var listener = new InMemoryEventListener(formatter))
{
listener.EnableEvents(Logger, EventLevel.LogAlways, EventKeywords.All);
Logger.Startup();
var contents = listener.ToString();
Assert.IsTrue(contents.Contains(formatter.Header));
Assert.IsTrue(contents.Contains(formatter.Footer));
}
}
public void WhenSourceEnabledAndNotSpecifyingKeyword()
{
var consoleOutputInterceptor = new MockConsoleOutputInterceptor();
var formatter = new EventTextFormatter(EventTextFormatter.DashSeparator);
using (var eventListener = new ObservableEventListener())
{
eventListener.LogToConsole();
eventListener.EnableEvents(MockConsoleListenerEventSource.Logger, EventLevel.LogAlways);
MockConsoleListenerEventSource.Logger.InfoWithKeywordDiagnostic("Info with keyword Diagnostic");
}
var entry = Regex.Split(consoleOutputInterceptor.Ouput, formatter.Header).Where(c => !string.IsNullOrWhiteSpace(c)).SingleOrDefault();
Assert.IsNull(entry);
}
public void IncludesTaskName()
{
var formatter = new EventTextFormatter(EventTextFormatter.DashSeparator, verbosityThreshold: EventLevel.LogAlways);
using (var listener = new InMemoryEventListener(formatter))
{
listener.EnableEvents(Logger, EventLevel.LogAlways, EventKeywords.All);
Logger.DBQueryStart("select * from table");
Logger.WithOpcodeAndNoTaskSpecfied(4);
var entries = Regex.Split(listener.ToString(), formatter.Header + "\r\n").Where(c => !string.IsNullOrWhiteSpace(c)).ToList();
StringAssert.Matches(entries[0], new Regex("EventName : .*DBQuery"));
StringAssert.Matches(entries[1], new Regex("Task : .*None"));
}
}
public void ShouldWriteTimestampWithDefaultDateTimeFormat()
{
var formatter = new EventTextFormatter(EventTextFormatter.DashSeparator);
using (var listener = new InMemoryEventListener(formatter))
{
listener.EnableEvents(Logger, EventLevel.LogAlways, EventKeywords.All);
Logger.Failure("error");
var logged = listener.ToString();
var lookup = "Timestamp : ";
var ts = logged.Substring(logged.IndexOf(lookup) + lookup.Length).Replace("\r\n", "");
DateTime dt;
Assert.IsTrue(DateTime.TryParseExact(ts, formatter.DateTimeFormat ?? EventEntry.DefaultDateTimeFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out dt));
}
}
public void WhenHighEventIds()
{
var consoleOutputInterceptor = new MockConsoleOutputInterceptor();
var formatter = new EventTextFormatter(EventTextFormatter.DashSeparator);
var logger = MockHighEventIdEventSource.HigheventIdLogger;
using (var eventListener = new ObservableEventListener())
{
eventListener.LogToConsole();
eventListener.EnableEvents(logger, EventLevel.Warning);
logger.Warning();
}
var entry = Regex.Split(consoleOutputInterceptor.Ouput, formatter.Header).Where(c => !string.IsNullOrWhiteSpace(c)).SingleOrDefault();
Assert.IsNotNull(entry);
}
static Api()
{
var formatter = new EventTextFormatter()
{
VerbosityThreshold = EventLevel.Error
};
ObservableEventListener api_event_log_listener = new ObservableEventListener();
api_event_log_listener.EnableEvents(ApiEventSource.Log, EventLevel.LogAlways,
ApiEventSource.Keywords.Perf | ApiEventSource.Keywords.Diagnostic);
api_event_log_listener.LogToFlatFile("Overlord.Core.Api.log", formatter, true);
ObservableEventListener storage_event_log_listener = new ObservableEventListener();
storage_event_log_listener.EnableEvents(AzureStorageEventSource.Log, EventLevel.LogAlways,
AzureStorageEventSource.Keywords.Perf | AzureStorageEventSource.Keywords.Diagnostic);
storage_event_log_listener.LogToFlatFile("Overlord.Storage.Azure.log", formatter, true);
}
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");
}
