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 SupersededWriterTest()
{
var logWriter = new TestLogWriter();
var accumulator = new LogAccumulator(logWriter, null);
Assert.AreSame(logWriter, accumulator.SupersededWriter);
}
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));
}
}
/// <summary>
/// Stops the current message accumulation. If the current accumulation
/// supersedes another accumulation, the superseded accumulation will be
/// in effect.
/// </summary>
public void StopMessageAccumulation()
{
if (_accumulator == null)
{
return;
}
_logWriter = _accumulator.SupersededWriter;
_accumulator = _logWriter as LogAccumulator; // This may result with null.
// FOR PORTING: Use if (_logWriter is LogAccumulator)...
}
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 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 DisposeTest()
{
var supersededWriter = new TestLogWriter();
bool callbackCalled = false;
LogAccumulator.DisposalCallback disposalCallback = () => { callbackCalled = true; };
LogAccumulator target = new LogAccumulator(supersededWriter, disposalCallback);
target.Dispose();
Assert.IsTrue(callbackCalled);
callbackCalled = false;
target.Dispose();
Assert.IsFalse(callbackCalled);
}
public void WriteLineTest()
{
ILogWriter supersededWriter = new TestLogWriter();
LogAccumulator.DisposalCallback disposalCallback = null;
LogAccumulator target = new LogAccumulator(supersededWriter, disposalCallback);
string message = "Hello";
target.WriteLine(message);
PrivateObject privateObj = new PrivateObject(target);
Assert.AreEqual(message + Environment.NewLine, privateObj.GetFieldOrProperty("accumulatedMessages").ToString());
target.WriteLine(message);
Assert.AreEqual(message + Environment.NewLine + message + Environment.NewLine, privateObj.GetFieldOrProperty("accumulatedMessages").ToString());
}
public void DiscardTest()
{
var supersededWriter = new TestLogWriter();
LogAccumulator.DisposalCallback disposalCallback = null;
LogAccumulator target = new LogAccumulator(supersededWriter, disposalCallback);
string message = "Hello";
target.WriteLine(message);
target.Discard();
var actual = supersededWriter.Output.ToString().Replace(Environment.NewLine, "$n");
Assert.AreEqual("", actual, "(Note: $n replaces new line characters)");
PrivateObject privateObj = new PrivateObject(target);
Assert.AreEqual("", privateObj.GetFieldOrProperty("accumulatedMessages").ToString());
}
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 EventsCollection GetEvents(ILogQuery query)
{
Debug.Assert(query != null, "LogSource.GetEvents: query is null.");
var files = GetFiles(true);
var encoding = config_.Encoding;
var logFiles = new LogFilesCollection(files, encoding, query.Snapshot);
var size = logFiles.GetSnapshot();
var accumulator = new LogAccumulator(statsCache_, query);
var hintMaker = new CacheHintMaker(statsCache_, query, accumulator);
var events = logFiles
.Aggregate(hintMaker, (a, f) => a.Consume(f))
.Events
.ToList();
events.Reverse();
return(new EventsCollection(events, Name, size));
}
/// <summary>
/// Constructor
/// </summary>
public Logger()
{
_logWriter = new ConsoleLogWriter();
_accumulator = null;
}
/// <summary>
/// Accumulate messages instead of writing them to current log writer.
/// </summary>
/// <returns>Returns a IDisposable object that can be used in a 'using' clause to ensure
/// the message accumulation is stopped.</returns>
public IDisposable AccumulateMessages()
{
_accumulator = new LogAccumulator(_logWriter, StopMessageAccumulation);
_logWriter = _accumulator;
return(_accumulator);
}
