internal static Mock <ITraceFileEventReader> CreateForwardingEventReader(string filename)
{
var mockActiveTraceReader = MockRepository.Create <ITraceFileEventReader>();
mockActiveTraceReader
.Setup(reader => reader.ReadEvents(It.IsAny <DateTime>(), It.IsAny <DateTime>()))
.Callback((DateTime startTime, DateTime endTime) =>
{
var realTraceReader = new TraceFileEventReader(filename);
var eventIdx = 0;
realTraceReader.EventRead += (sender, arg) =>
{
// Only give x at a time. This should really be % of total to produce x passes.
if (eventIdx < 400)
{
mockActiveTraceReader.Raise(
reader => reader.EventRead += null,
arg);
}
eventIdx++;
};
realTraceReader.ReadEvents(startTime, endTime);
});
mockActiveTraceReader
.Setup(reader => reader.ReadTraceSessionMetadata())
.Returns(new TraceSessionMetadata("test", 0, DateTime.UtcNow, DateTime.UtcNow));
mockActiveTraceReader
.Setup(reader => reader.Dispose());
return(mockActiveTraceReader);
}
/// <inheritdoc />
public override Task StartReadingAsync(DateTimeOffset startTime, DateTimeOffset endTime, CancellationToken cancelToken)
{
this.token = cancelToken;
foreach (var oneFile in this.traceFiles)
{
using (var etwReader = new TraceFileEventReader(oneFile))
{
etwReader.EventRead += this.Reader_TraceRead;
etwReader.ReadEvents(startTime.UtcDateTime, endTime.UtcDateTime);
}
}
return(Task.FromResult(true));
}
public void ParseTraces(Action <T> traceDispatcher, string fileName, DateTime startTime, DateTime endTime)
{
_traceDispatcher = traceDispatcher;
using (var reader = new TraceFileEventReader(fileName))
{
TraceSessionMetaData = reader.ReadTraceSessionMetadata();
if (TraceSessionMetaData.StartTime > endTime | TraceSessionMetaData.EndTime < startTime)
{
Log.Warning($"{fileName} outside time range start:{TraceSessionMetaData.StartTime} end:{TraceSessionMetaData.EndTime}");
return;
}
reader.EventRead += this.OnEventRead;
reader.ReadEvents(startTime, endTime);
EventsLost = (int)reader.EventsLost;
}
}
internal static Mock <ITraceFileEventReader> CreateEventsLostReader(string filename)
{
var mockEventsLostReader = MockRepository.Create <ITraceFileEventReader>();
mockEventsLostReader
.Setup(reader => reader.ReadTraceSessionMetadata())
.Returns(() =>
{
using (var realTraceReader = new TraceFileEventReader(filename))
{
realTraceReader.TestEventsLost = 10;
return(realTraceReader.ReadTraceSessionMetadata());
}
});
mockEventsLostReader
.Setup(reader => reader.Dispose());
return(mockEventsLostReader);
}
private void Read(object state)
{
this.LatestProcessedEtwEventTimestamp = this.tableBackup.LatestBackupTime;
this.ResetMostRecentEtwEventTimestamp();
// Get all files in the ETL directory that match the pattern
Utility.TraceSource.WriteInfo(
TraceType,
"Searching for ETL files whose names match '{0}' in directory '{1}'.",
EtlFilePattern,
this.etlDirectory);
DirectoryInfo dirInfo = new DirectoryInfo(this.etlDirectory);
FileInfo[] etlFiles = dirInfo.GetFiles(EtlFilePattern);
Utility.TraceSource.WriteInfo(
TraceType,
"Found {0} ETL files whose names match '{1}' in directory '{2}'.",
etlFiles.Length,
EtlFilePattern,
this.etlDirectory);
// Sort the files such that the file with the oldest creation
// time comes first.
Array.Sort(etlFiles, this.CompareFileCreationTimesOldFirst);
// We read events that are old enough to have been flushed to disk
var etlFileFlushInterval = this.GetEtlFileFlushInterval();
DateTime endTime = DateTime.UtcNow.AddSeconds(-2 * etlFileFlushInterval.TotalSeconds);
foreach (FileInfo etlFile in etlFiles)
{
Utility.TraceSource.WriteInfo(
TraceType,
"Processing ETL file: {0}. Events with timestamp between {1} ({2}) and {3} ({4}) will be read from it.",
etlFile.Name,
this.LatestProcessedEtwEventTimestamp.Timestamp,
this.LatestProcessedEtwEventTimestamp.Timestamp.Ticks,
endTime,
endTime.Ticks);
// Note the timestamp of the event we received most recently before we start
// processing this ETL file. In case we retry the processing of this ETL file,
// we need to revert back to this timestamp.
this.mostRecentEtwEventTimestampBeforeCurrentEtl = this.MostRecentEtwEventTimestamp;
try
{
Utility.PerformWithRetries(
ctx =>
{
// Create a ETL file reader
using (var eventReader = new TraceFileEventReader(etlFile.FullName))
{
var traceSessionMetadata = eventReader.ReadTraceSessionMetadata();
FabricEvents.Events.TraceSessionStats(
traceSessionMetadata.TraceSessionName,
traceSessionMetadata.EventsLostCount,
traceSessionMetadata.StartTime,
traceSessionMetadata.EndTime);
// Register our ETW event processing callback
eventReader.EventRead += this.OnEtwEventReceived;
// Read ETW events from the ETL file
eventReader.ReadEvents(
this.LatestProcessedEtwEventTimestamp.Timestamp,
endTime);
}
},
(object)null,
new RetriableOperationExceptionHandler(this.ReadEventsExceptionHandler));
Utility.TraceSource.WriteInfo(
TraceType,
"Finished processing ETL file: {0}.",
etlFile.Name);
}
catch (Exception e)
{
Utility.TraceSource.WriteExceptionAsError(
TraceType,
e,
"Failed to read some or all of the events from ETL file {0}.",
etlFile.FullName);
}
if (this.Stopping)
{
Utility.TraceSource.WriteInfo(
TraceType,
"The DCA is stopping, so no more ETL files will be processed.");
break;
}
}
// Update the timestamp up to which ETW events can be read
Utility.ApplicationEtwTracesEndTime = this.LatestProcessedEtwEventTimestamp.Timestamp;
// Schedule the next pass, unless the DCA is being stopped
this.etlReadTimer.Start(this.GetEtlReadInterval());
}
