public void EventStatisticCacheGetTypeStatisticsIncorrectFilePathsTest() { TypeCache typecache = new TypeCache(); EventStatisticCache cache = new EventStatisticCache(); cache.GetTypeStatistics(typecache, new[] { @"C:\hello\world.etl", testDataFile }); }
public void EventStatisticCacheGetTypeStatisticsFilesInvalidTest() { TypeCache typecache = new TypeCache(); EventStatisticCache cache = new EventStatisticCache(); cache.GetTypeStatistics(typecache, new[] { string.Empty, testDataFile }); }
public void TypeCacheIgnoresTypesContainingImportTest() { var typeCache = new TypeCache(); typeCache.Initialize("TypeCacheIgnoresTypesContainingImportTest", @"TestData\TrianglesWithImport.etl"); Assert.AreEqual(3, typeCache.Cache.Count); }
public void TypeCacheIgnoresTypesContainingImportTest() { var typeCache = new TypeCache(); typeCache.Init("test5", new[] { @"TestData\TrianglesWithImport.etl" }); Assert.AreEqual(4, typeCache.Types.Length); Assert.AreEqual(3, typeCache.Manifests.Length); }
public void TypeCacheInitHappyPathTest() { var typeCache = new TypeCache(); typeCache.Initialize("test", new[] { testDataFile }); var dir = typeCache.CacheDirectory; Assert.AreEqual(3, Directory.GetFiles(dir, "*.bond").Length); Assert.AreEqual(3, typeCache.Cache.Count); Utilities.ForceDeleteDirectory("test"); }
public void TypeCacheInitHappyPathTest() { var typeCache = new TypeCache(); typeCache.Init("test", new[] { testDataFile }); var dir = typeCache.CacheDirectory; Assert.AreEqual(3, Directory.GetFiles(dir, "*.bond").Length); Assert.AreEqual(3, typeCache.Manifests.Length); Directory.Delete(dir, true); }
public void EventStatisticCacheCreatesCsvTest() { TypeCache typecache = new TypeCache(); typecache.Initialize("test2", new[] { testDataFile }); EventStatisticCache cache = new EventStatisticCache(); var result = cache.GetTypeStatistics(typecache, new[] { testDataFile }); Assert.IsTrue(File.Exists(Path.Combine(Environment.CurrentDirectory, "TestData", Path.GetFileNameWithoutExtension(testDataFile) + ".csv"))); File.Delete(Path.Combine(Environment.CurrentDirectory, Path.GetFileNameWithoutExtension(testDataFile) + ".csv")); }
public void EventStatisticCacheGetTypeStatisticsHappyPathTest() { TypeCache typecache = new TypeCache(); typecache.Initialize("test1", new[] { testDataFile }); EventStatisticCache cache = new EventStatisticCache(); var result = cache.GetTypeStatistics(typecache, new[] { testDataFile }); Assert.AreEqual(3, result.Keys.Count); Assert.IsTrue(result.All(a => a.Value.EventCount == 10)); var typeNames = new[] { "IsoscelesTriangle", "EquilateralTriangle", "RightAngledTriangle" }; Assert.IsTrue(result.All(a => typeNames.Contains(a.Key.Name))); }
public void EventStatisticLoadCsvValuesTest() { TypeCache typecache = new TypeCache(); typecache.Initialize("test3", new[] { testDataFile }); EventStatisticCache cache = new EventStatisticCache(); var result = cache.GetTypeStatistics(typecache, new[] { testDataFile }); Assert.IsTrue(File.Exists(Path.Combine(Environment.CurrentDirectory, "TestData", Path.GetFileNameWithoutExtension(testDataFile) + ".csv"))); File.Delete(Path.Combine(Environment.CurrentDirectory, Path.GetFileNameWithoutExtension(testDataFile) + ".csv")); foreach (var item in result) { switch (item.Key.Name) { case "IsoscelesTriangle": Assert.AreEqual(27D, item.Value.AverageByteSize); Assert.AreEqual(270, item.Value.ByteSize); Assert.AreEqual(10, item.Value.EventCount); Assert.AreEqual(0.0370, item.Value.EventsPerSecond); break; case "EquilateralTriangle": Assert.AreEqual(25D, item.Value.AverageByteSize); Assert.AreEqual(250, item.Value.ByteSize); Assert.AreEqual(10, item.Value.EventCount); Assert.AreEqual(0.0370, item.Value.EventsPerSecond); break; case "RightAngledTriangle": Assert.AreEqual(29D, item.Value.AverageByteSize); Assert.AreEqual(290, item.Value.ByteSize); Assert.AreEqual(10, item.Value.EventCount); Assert.AreEqual(0.037, item.Value.EventsPerSecond); break; default: Assert.Fail("Unexpected test result. Test fails."); break; } } }
public void MultipleTypesStatsCalculationTest() { TypeCache typecache = new TypeCache(); typecache.Initialize("MultipleTypesStatsCalculationTest", new[] { testDataFile }); Assert.AreEqual(4, typecache.Cache.Count); Assert.IsTrue(typecache.Cache.All(a => a != null && a.Manifest != null && a.Type != null)); EventStatisticCache cache = new EventStatisticCache(); var result = cache.GetTypeStatistics(typecache, new[] { testDataFile }); Assert.AreEqual(3, result.Count); var values = result.Values.ToArray(); Assert.AreEqual(10, values[0].EventCount); Assert.AreEqual(10, values[1].EventCount); Assert.AreEqual(10, values[2].EventCount); File.Delete(Path.Combine("TestData", Path.GetFileNameWithoutExtension(testDataFile) + ".csv")); }
public void ReadTypesFromSingleManifestTest() { TypeCache typecache = new TypeCache(); typecache.Initialize("ReadTypesFromSingleManifestTest", new[] { testDataFile }); Debug.WriteLine(typecache.CacheDirectory); Assert.AreEqual(4, typecache.Cache.Count); Debug.WriteLine(typecache.Cache[0].Manifest.ManifestId); Debug.WriteLine(typecache.Cache[1].Manifest.ManifestId); Debug.WriteLine(typecache.Cache[2].Manifest.ManifestId); Debug.WriteLine(typecache.Cache[3].Manifest.ManifestId); Debug.WriteLine(typecache.Cache[0].Type.Name); Debug.WriteLine(typecache.Cache[1].Type.Name); Debug.WriteLine(typecache.Cache[2].Type.Name); Debug.WriteLine(typecache.Cache[3].Type.Name); Assert.IsTrue(typecache.Cache.All(a => a != null && a.Manifest != null && a.Type != null)); }
public void TypeCacheInitTargetDirNullTest() { var typeCache = new TypeCache(); typeCache.Init(null, new string[] { testDataFile }); }
public void TypeCacheInitNullFilesTest() { var typeCache = new TypeCache(); typeCache.Init("dir", null); }
public void TypeCacheInitNoFilesTest() { var typeCache = new TypeCache(); typeCache.Init("dir", new string[] { }); typeCache.Init("dir", null); }
private Dictionary<Type, CsvRelatedStats> CalculateTypeStatistics(TypeCache typeCache, string inputFile) { Console.WriteLine("Getting statistics from file {0}.", inputFile); var statsPerType = new Dictionary<Type, CsvRelatedStats>(); Stopwatch sw = Stopwatch.StartNew(); var rawCount = from events in BinaryEtwObservable.FromSequentialFiles(inputFile) group events by events.PayloadId into eventTypes from all in eventTypes.Aggregate( new { EventCount = (long)0, Bytes = (long)0, minTime = long.MaxValue, maxTime = 0L }, (ac, events) => new { EventCount = ac.EventCount + 1, Bytes = ac.Bytes + events.EventPayloadLength, minTime = Math.Min(ac.minTime, events.ReceiveFileTimeUtc), maxTime = Math.Max(ac.maxTime, events.ReceiveFileTimeUtc) }) select new { ManifestId = eventTypes.Key, all.EventCount, all.Bytes, all.minTime, all.maxTime }; var counts = rawCount.ToEnumerable().ToArray(); sw.Stop(); Console.WriteLine("Query took {0} milliseconds.", sw.ElapsedMilliseconds); foreach (var c in counts) { var manifest = typeCache.Manifests .FirstOrDefault(m => string.Equals(m.ManifestId, c.ManifestId, StringComparison.OrdinalIgnoreCase)); if (manifest != null) { var line = manifest.Manifest .Split('\n').LastOrDefault(l => l.Trim().StartsWith(@"struct ", StringComparison.OrdinalIgnoreCase)); if (line != null) { var className = line.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)[1].Trim(); var type = typeCache.Types.FirstOrDefault(t => t.Name == className); if (type != null) { var minDateTime = DateTime.FromFileTimeUtc(c.minTime); var maxDateTime = DateTime.FromFileTimeUtc(c.maxTime); var duration = (maxDateTime - minDateTime).TotalSeconds; if (Math.Abs(duration) < 0.01) duration = 1; var stats = new EventStatistics { AverageByteSize = c.Bytes / c.EventCount, ByteSize = c.Bytes, EventCount = c.EventCount, EventsPerSecond = c.EventCount / duration }; statsPerType[type] = new CsvRelatedStats { ManifestId = c.ManifestId, Statistics = stats, }; } } } } return statsPerType; }
private Dictionary<Type, CsvRelatedStats> CalculateTypeStatistics(TypeCache typeCache, string inputFile) { Console.WriteLine("Getting statistics from file {0}.", inputFile); var statsPerType = new Dictionary<Type, CsvRelatedStats>(); Stopwatch sw = Stopwatch.StartNew(); var rawCount = from events in BinaryEtwObservable.FromSequentialFiles(inputFile) group events by events.TypeId into eventTypes from all in eventTypes.Aggregate( new { EventCount = (long)0, Bytes = (long)0, minTime = long.MaxValue, maxTime = 0L }, (ac, events) => new { EventCount = ac.EventCount + 1, Bytes = ac.Bytes + events.Payload.Length, minTime = Math.Min(ac.minTime, events.ReceivedTime.ToFileTime()), maxTime = Math.Max(ac.maxTime, events.ReceivedTime.ToFileTime()), }) select new { ManifestId = eventTypes.Key, all.EventCount, all.Bytes, all.minTime, all.maxTime, }; var counts = rawCount.ToEnumerable().ToArray(); sw.Stop(); Console.WriteLine("Query took {0} milliseconds.", sw.ElapsedMilliseconds); foreach (var c in counts) { var typeCacheItem = typeCache.FindMatchOrDefault(c.ManifestId); if (typeCacheItem != null && typeCacheItem.Type != null) { var type = typeCacheItem.Type; if (type != null) { var minDateTime = DateTime.FromFileTimeUtc(c.minTime); var maxDateTime = DateTime.FromFileTimeUtc(c.maxTime); var duration = (maxDateTime - minDateTime).TotalSeconds; if (Math.Abs(duration) < 0.01) duration = 1; var stats = new EventStatistics { AverageByteSize = c.Bytes / c.EventCount, ByteSize = c.Bytes, EventCount = c.EventCount, EventsPerSecond = Math.Round(c.EventCount / duration, 3, MidpointRounding.AwayFromZero), }; statsPerType[type] = new CsvRelatedStats { ManifestId = c.ManifestId, Statistics = stats, }; } } } return statsPerType; }
public void TypeCacheParseStructNameIgnoresInvalidTypesTest() { var testManifest = @"namespace DataModel struct EquilateralTriangle{ 1: optional int64 Side; 2: optional string Source; [OccurenceTime("")] 3: optional int64 TimeStampUtc; }; struct InvalidTriangle} 1: optional int64 Side; 2: optional string Source; [OccurenceTime("")] 3: optional int64 TimeStampUtc; }; struct ValidTriangle{ 1: optional int64 Side; 2: optional string Source; [OccurenceTime("")] 3: optional int64 TimeStampUtc; };"; var typeCache = new TypeCache(); var tuple = typeCache.ParseClassNames(testManifest); Assert.AreEqual("DataModel", tuple.Item1); Assert.AreEqual("EquilateralTriangle", tuple.Item2[0]); Assert.AreEqual("ValidTriangle", tuple.Item2[1]); }
public void TypeCacheParseStructNameHasCurlyBracesHappyPathTest() { var testManifest = @"namespace DataModel struct EquilateralTriangle{ 1: optional int64 Side; 2: optional string Source; [OccurenceTime("")] 3: optional int64 TimeStampUtc; }; struct SomeOtherTriangle{ 1: optional int64 Side; 2: optional string Source; [OccurenceTime("")] 3: optional int64 TimeStampUtc; };"; var typeCache = new TypeCache(); var tuple = typeCache.ParseClassNames(testManifest); Assert.AreEqual("DataModel", tuple.Item1); Assert.AreEqual("EquilateralTriangle", tuple.Item2[0]); Assert.AreEqual("SomeOtherTriangle", tuple.Item2[1]); }
public void TypeCacheParseClassNamesNullTest() { var typeCache = new TypeCache(); typeCache.ParseClassNames(null); }
public void TypeCacheParseClassNamesEmptyManifestTest() { var typeCache = new TypeCache(); typeCache.ParseClassNames(string.Empty); }
private bool IsCsvLineParsable(string line, TypeCache typeCache, Dictionary<Type, EventStatistics> eventStatsCollection) { bool isParsable = false; var tokens = line.Split(CsvSeparator); string eventManifestIdFromCsv = string.Empty; string typeNameFromCsv = string.Empty; if (tokens != null && tokens.Length == 6 && tokens.All(a => !string.IsNullOrWhiteSpace(a))) { eventManifestIdFromCsv = tokens[0]; typeNameFromCsv = tokens[1]; var typeCacheItem = typeCache.FindMatchOrDefault(eventManifestIdFromCsv); if (typeCacheItem != null && typeCacheItem.Type != null && string.Equals(typeCacheItem.Type.Name, typeNameFromCsv, StringComparison.OrdinalIgnoreCase)) { Debug.WriteLine(typeCacheItem.Type.Name); EventStatistics statsFromCsv = new EventStatistics { AverageByteSize = long.Parse(tokens[5]), ByteSize = long.Parse(tokens[4]), EventCount = long.Parse(tokens[2]), EventsPerSecond = double.Parse(tokens[3]), }; EventStatistics existingStats; if (eventStatsCollection.TryGetValue(typeCacheItem.Type, out existingStats)) { existingStats = existingStats + statsFromCsv; Console.WriteLine("Stats for type {0} updated.", typeNameFromCsv); } else { eventStatsCollection[typeCacheItem.Type] = statsFromCsv; Console.WriteLine("Stats for type {0} added.", typeNameFromCsv); } isParsable = true; } } return isParsable; }
private bool TryParseStatsFromCsv(string inputFile, TypeCache typeCache, out Dictionary<Type, EventStatistics> eventStatsCollection) { bool isParsingSuccessful = true; bool headersFound = false; using (var streamReader = File.OpenText(inputFile)) { eventStatsCollection = new Dictionary<Type, EventStatistics>(); // At any point parsing is not successful, means current csv is not good enough. Rewrite of csv is required. while (!streamReader.EndOfStream && isParsingSuccessful) { Console.WriteLine("Starting to parse csv..."); string line = string.Empty; // First few lines are not important for stats. while (!headersFound) { line = streamReader.ReadLine(); headersFound = !string.IsNullOrWhiteSpace(line) ? line.Contains(this.CsvHeaders) : false; } // headers found if (headersFound) { line = streamReader.ReadLine(); if (!string.IsNullOrWhiteSpace(line)) { // Every line should pass this test else rewrite of csv is required. isParsingSuccessful = this.IsCsvLineParsable(line, typeCache, eventStatsCollection); } } } } if (eventStatsCollection.Count == 0) { isParsingSuccessful = false; } return isParsingSuccessful; }
public IDictionary<Type, EventStatistics> GetTypeStatistics(TypeCache typeCache, params string[] inputFiles) { Stopwatch sw = Stopwatch.StartNew(); if (typeCache == null) { throw new ArgumentNullException("typeCache"); } if (inputFiles == null || inputFiles.Length <= 0 || inputFiles.Any(f => string.IsNullOrWhiteSpace(f))) { throw new ArgumentNullException("inputFiles"); } if (inputFiles.Any(a => !File.Exists(a))) { throw new ArgumentException("Some file paths are invalid."); } var overallStatsPerType = new Dictionary<Type, EventStatistics>(); Console.WriteLine("Getting Statistics..."); foreach (var file in inputFiles) { Dictionary<Type, EventStatistics> statsOfThisFile = null; var dir = System.IO.Path.GetDirectoryName(file); var fileName = System.IO.Path.GetFileNameWithoutExtension(file) + ".csv"; var expectedCsv = System.IO.Path.Combine(dir, fileName); if (!this.IsStatsCsvAvailable(expectedCsv) || !this.TryParseStatsFromCsv(expectedCsv, typeCache, out statsOfThisFile)) { var csvRelatedStatsOfThisFile = this.CalculateTypeStatistics(typeCache, file); if (csvRelatedStatsOfThisFile != null) { statsOfThisFile = new Dictionary<Type, EventStatistics>(); foreach (var item in csvRelatedStatsOfThisFile) { statsOfThisFile.Add(item.Key, item.Value.Statistics); } this.CreateCsvStatsFile(expectedCsv, csvRelatedStatsOfThisFile); } } if (statsOfThisFile != null) { foreach (var item in statsOfThisFile) { EventStatistics existingStatsForThisType; if (overallStatsPerType.TryGetValue(item.Key, out existingStatsForThisType)) { overallStatsPerType[item.Key] = existingStatsForThisType + item.Value; } else { overallStatsPerType[item.Key] = item.Value; } } } } sw.Stop(); Console.WriteLine("GetTypeStatistics took {0} milliseconds", sw.ElapsedMilliseconds); return overallStatsPerType; }