public void SkipsFilesWithinOffset()
{
using (var file1 = new StringLogFile("sample-1", Sample1))
using (var file2 = new StringLogFile("sample-2", Sample2))
using (var file3 = new StringLogFile("sample-3", Sample3))
{
var statsProvider = new LogFileStatsCache();
file1.InitializeDefaultStats(statsProvider);
file2.InitializeDefaultStats(statsProvider);
file3.InitializeDefaultStats(statsProvider);
var query = new SimpleLogQuery
{
Offset = statsProvider.GetStats(file1, null).EventCount,
Quantity = statsProvider.GetStats(file2, null).EventCount
};
var subject = new LogAccumulator(statsProvider, query);
var actual = subject
.Consume(file1)
.Consume(file2)
.Consume(file3);
Assert.That(actual.IsComplete);
Assert.That(file1.WasRead, Is.False);
Assert.That(file2.WasRead, Is.True);
Assert.That(file3.WasRead, Is.False);
Assert.That(actual.Events, Is.EqualTo(Sample2Events));
}
}
public void DoesNotConsumeEventsBeyondCompletion()
{
using (var file1 = new StringLogFile("sample-1-a", Sample1))
using (var file2 = new StringLogFile("sample-1-b", Sample1))
{
var statsProvider = new LogFileStatsCache();
var query = new SimpleLogQuery
{
Quantity = statsProvider.GetStats(file1, null).EventCount
};
file1.InitializeStats(query, statsProvider);
file2.InitializeStats(query, statsProvider);
var subject = new LogAccumulator(statsProvider, query);
var actual = subject
.Consume(file1)
.Consume(file2);
Assert.That(file1.WasRead, Is.True);
Assert.That(file2.WasRead, Is.False);
Assert.That(actual.Events, Is.EqualTo(Sample1Events));
}
}
public void CanConsumeAllEvents()
{
using (var file1 = new StringLogFile("sample-1", Sample1))
using (var file2 = new StringLogFile("sample-2", Sample2))
{
var expected = Sample1Events.Concat(Sample2Events).ToList();
var statsProvider = new LogFileStatsCache();
file1.InitializeDefaultStats(statsProvider);
file2.InitializeDefaultStats(statsProvider);
var file1Events = statsProvider.GetStats(file1, null).EventCount;
var file2Events = statsProvider.GetStats(file2, null).EventCount;
var query = new SimpleLogQuery
{
Quantity = file1Events + file2Events + 1
};
var subject = new LogAccumulator(statsProvider, query);
var actual = subject
.Consume(file1)
.Consume(file2);
Assert.That(actual.IsComplete, Is.False);
Assert.That(file1.WasRead, Is.True);
Assert.That(file2.WasRead, Is.True);
Assert.That(actual.Events, Is.EqualTo(expected));
}
}
public LogSource(ILogDirectoryConfig config, LogFileStatsCache statsCache)
{
Debug.Assert(config != null, "LogSource.ctor: config is null.");
Debug.Assert(statsCache != null, "LogSource.ctor: statsCache is null.");
config_ = config;
statsCache_ = statsCache;
}
public void InitializeStats(Filter filter, LogFileStatsCache statsCache)
{
using (var copy = Clone())
{
statsCache.GetStats(copy, filter);
}
}
public void SkipsFilesByLoggerCount()
{
using (var file1 = new StringLogFile("sample-1", Sample1))
using (var file2 = new StringLogFile("sample-2", Sample2))
using (var file3 = new StringLogFile("sample-3", Sample3))
{
var statsProvider = new LogFileStatsCache();
file1.InitializeDefaultStats(statsProvider);
file2.InitializeDefaultStats(statsProvider);
file3.InitializeDefaultStats(statsProvider);
var file1Stats = statsProvider.GetStats(file1, null);
var file2Stats = statsProvider.GetStats(file2, null);
var file3Stats = statsProvider.GetStats(file3, null);
const string logger = "Root.ChildA";
var sample1Matching = Sample1Events
.Where(e => e.Logger.StartsWith(logger))
.ToList();
var sample2Matching = Sample2Events
.Where(e => e.Logger.StartsWith(logger))
.ToList();
Assume.That(sample1Matching.Count, Is.LessThan(file1Stats.EventCount));
Assume.That(sample2Matching.Count, Is.LessThan(file2Stats.EventCount));
var expected = sample2Matching;
var minTime = expected.Last().Time;
var maxTime = expected.First().Time;
var query = new SimpleLogQuery
{
Offset = sample1Matching.Count,
Quantity = expected.Count,
Filter = Filter.Logger(logger)
};
var subject = new LogAccumulator(statsProvider, query);
var actual = subject
.Consume(file1)
.Consume(file2)
.Consume(file3);
Assert.That(actual.IsComplete);
Assert.That(file1.WasRead, Is.False);
Assert.That(file2.WasRead, Is.True);
Assert.That(file3.WasRead, Is.False);
Assert.That(actual.Events, Is.EqualTo(expected));
}
}
public void DoesNotRereadUsedFiles()
{
using (var firstAccess = new StringLogFile("sample", Sample))
using (var secondAccess = firstAccess.Clone())
{
var subject = new LogFileStatsCache();
subject.GetStats(firstAccess, null);
subject.GetStats(secondAccess, null);
Assert.That(secondAccess.WasRead, Is.False);
}
}
public void SkipsFilesOutsideQueriedTimeFrame()
{
using (var file1 = new StringLogFile("sample-1", Sample1))
using (var file2 = new StringLogFile("sample-2", Sample2))
using (var file3 = new StringLogFile("sample-3", Sample3))
{
var statsProvider = new LogFileStatsCache();
file1.InitializeDefaultStats(statsProvider);
file2.InitializeDefaultStats(statsProvider);
file3.InitializeDefaultStats(statsProvider);
var file1Stats = statsProvider.GetStats(file1, null);
var file2Stats = statsProvider.GetStats(file2, null);
var file3Stats = statsProvider.GetStats(file3, null);
Assume.That(file1Stats.EarliestTimestamp, Is.GreaterThan(file2Stats.LatestTimestamp));
Assume.That(file2Stats.EarliestTimestamp, Is.GreaterThan(file3Stats.LatestTimestamp));
Assume.That(file2Stats.EventCount, Is.GreaterThanOrEqualTo(4));
var expected = Sample2Events
.Skip(1)
.Take(Sample2Events.Length - 2)
.ToList();
var minTime = expected.Last().Time;
var maxTime = expected.First().Time;
var query = new SimpleLogQuery
{
Offset = 0,
Quantity = expected.Count,
MinTimestamp = Timestamp.FromDateTime(minTime),
MaxTimestamp = Timestamp.FromDateTime(maxTime),
Filter = Filter.Timestamp(minTime, maxTime)
};
var subject = new LogAccumulator(statsProvider, query);
var actual = subject
.Consume(file1)
.Consume(file2)
.Consume(file3);
Assert.That(actual.IsComplete);
Assert.That(file1.WasRead, Is.False);
Assert.That(file2.WasRead, Is.True);
Assert.That(file3.WasRead, Is.False);
Assert.That(actual.Events, Is.EqualTo(expected));
}
}
public void CanFillUpEventsFromMultipleFiles()
{
using (var file1 = new StringLogFile("sample-1", Sample1))
using (var file2 = new StringLogFile("sample-2", Sample2))
using (var file3 = new StringLogFile("sample-3", Sample3))
{
var statsProvider = new LogFileStatsCache();
file1.InitializeDefaultStats(statsProvider);
file2.InitializeDefaultStats(statsProvider);
file3.InitializeDefaultStats(statsProvider);
var file1Events = statsProvider.GetStats(file1, null).EventCount;
var file2Events = statsProvider.GetStats(file2, null).EventCount;
var file3Events = statsProvider.GetStats(file2, null).EventCount;
Assume.That(file2Events, Is.GreaterThanOrEqualTo(2));
Assume.That(file3Events, Is.GreaterThan(file2Events / 2 + file2Events % 2));
var offset = file1Events + file2Events / 2;
var quantity = file3Events;
var expected = Sample1Events.Concat(Sample2Events).Concat(Sample3Events)
.Skip(offset)
.Take(quantity);
var query = new SimpleLogQuery
{
Offset = offset,
Quantity = quantity
};
var subject = new LogAccumulator(statsProvider, query);
var actual = subject
.Consume(file1)
.Consume(file2)
.Consume(file3);
Assert.That(actual.IsComplete);
Assert.That(file1.WasRead, Is.False);
Assert.That(file2.WasRead, Is.True);
Assert.That(file3.WasRead, Is.True);
Assert.That(actual.Events, Is.EqualTo(expected));
}
}
public void HintAddsFilesToCache()
{
using (var file = new StringLogFile("sample", Sample))
{
var subject = new LogFileStatsCache();
using (subject.StartPrecacheThread())
{
subject.Hint(file, null);
Thread.Sleep(100);
subject.GetStats(file, null);
}
Assert.That(file.WasRead, Is.False);
}
}
public void GathersStatsFromFile()
{
using (var file = new StringLogFile("sample", Sample))
{
var subject = new LogFileStatsCache();
var actual = subject.GetStats(file, null);
Assert.That(actual.EventCount, Is.EqualTo(6));
Assert.That(actual.GroupStats.Count, Is.EqualTo(5));
Assert.That(actual.GroupStats[new LogFileStats.EventGroupKey("INFO", "Root.ChildA.LoggerA2")], Is.EqualTo(1));
Assert.That(actual.GroupStats[new LogFileStats.EventGroupKey("DEBUG", "Root.ChildB.LoggerB2")], Is.EqualTo(2));
Assert.That(actual.GroupStats[new LogFileStats.EventGroupKey("FATAL", "Root.ChildA.LoggerA2")], Is.EqualTo(1));
Assert.That(actual.GroupStats[new LogFileStats.EventGroupKey("WARN", "Root.ChildA.LoggerA1")], Is.EqualTo(1));
Assert.That(actual.GroupStats[new LogFileStats.EventGroupKey("ERROR", "Root.ChildA.LoggerA1")], Is.EqualTo(1));
Assert.That(actual.EarliestTimestamp, Is.EqualTo(1500000001000L));
Assert.That(actual.LatestTimestamp, Is.EqualTo(1500000006000L));
}
}
public void GatheredStatsRespectUnstatableFilters()
{
using (var file = new StringLogFile("sample", Sample))
{
var filter = Filter.All
(
Filter.Logger("Root.ChildA.LoggerA2"),
Filter.Timestamp(1500000003000L, 1500000003000L),
Filter.Message("Test event B.")
);
var subject = new LogFileStatsCache();
var actual = subject.GetStats(file, filter);
Assert.That(actual.EventCount, Is.EqualTo(2));
Assert.That(actual.GroupStats.Count, Is.EqualTo(1));
Assert.That(actual.GroupStats[new LogFileStats.EventGroupKey("DEBUG", "Root.ChildB.LoggerB2")], Is.EqualTo(2));
Assert.That(actual.EarliestTimestamp, Is.EqualTo(1500000002000L));
Assert.That(actual.LatestTimestamp, Is.EqualTo(1500000006000L));
}
}
public void DoesNotConsumeEventsZeroQuantity()
{
using (var file = new StringLogFile("sample-1", Sample1))
{
var statsProvider = new LogFileStatsCache();
var query = new SimpleLogQuery
{
Quantity = 0
};
file.InitializeStats(query, statsProvider);
var subject = new LogAccumulator(statsProvider, query);
Assert.That(subject.IsComplete);
var actual = subject.Consume(file);
Assert.That(file.WasRead, Is.False);
Assert.That(actual.Events, Is.Empty);
}
}
public void InitializeStats(ILogQuery query, LogFileStatsCache statsCache) => InitializeStats(query.CreateFilter(), statsCache);
public void InitializeDefaultStats(LogFileStatsCache statsCache) => InitializeStats((Filter)null, statsCache);
