Add logging to recording controllers

Mohammad Dehghan · Mohammad Dehghan · commit 2491959150cc · 2020-12-29T13:46:28.000+03:30
diff --git a/SG.CodeCoverage.Tests.NetFx/InstrumenterTester.cs b/SG.CodeCoverage.Tests.NetFx/InstrumenterTester.cs
@@ -20,21 +20,24 @@ public class InstrumenterTester
         public string MapFilePath { get; }
         public InstrumentationMap Map { get; private set; }
         public string InstrumentedAssemblyPath { get; private set; }
+        private readonly ILogger _logger;
 
         static InstrumenterTester()
         {
             DefaultOutputPath = Path.Combine(Path.GetTempPath(), "SG.CodeCoverage");
         }
 
-        public InstrumenterTester()
+        public InstrumenterTester(ILogger logger = null)
         {
             OutputPath = DefaultOutputPath;
+            _logger = logger ?? new ConsoleLogger();
         }
 
-        public InstrumenterTester(string existingInstrumentedSampleFolder)
+        public InstrumenterTester(string existingInstrumentedSampleFolder, ILogger logger = null)
         {
             OutputPath = existingInstrumentedSampleFolder;
             InstrumentedAssemblyPath = Path.Combine(OutputPath, Path.GetFileName(typeof(PrimeCalculator).Assembly.Location));
+            _logger = logger ?? new ConsoleLogger();
         }
 
         public void InstrumentSampleProject()
@@ -55,7 +58,7 @@ public void InstrumentSampleProject()
             var options = new InstrumentationOptions(
                 new[] { assemblyFileName },
                 Array.Empty<string>(), OutputPath, PortNumber);
-            Instrumenter instrumenter = new Instrumenter(options, new ConsoleLogger());
+            Instrumenter instrumenter = new Instrumenter(options, _logger);
             instrumenter.BackupFolder = Path.Combine(OutputPath, "backup");
             Directory.CreateDirectory(instrumenter.BackupFolder);
             Map = instrumenter.Instrument();
@@ -74,7 +77,7 @@ public void RunSomeCode()
         {
             if (InstrumentedAssemblyPath == null)
                 throw new InvalidOperationException("Sample assembly is not instrumented.");
-            var client = RecordingController.ForEndPoint("localhost", PortNumber, Map);
+            var client = RecordingController.ForEndPoint("localhost", PortNumber, Map, _logger);
             Assembly.LoadFrom(Path.Combine(OutputPath, "SG.CodeCoverage.Recorder.dll"));
             var assembly = Assembly.LoadFrom(InstrumentedAssemblyPath);
             var calc = assembly.DefinedTypes.Where(x => x.Name == nameof(PrimeCalculator)).FirstOrDefault();
@@ -85,7 +88,7 @@ public List<string> GetVisitedFiles()
         {
             if (InstrumentedAssemblyPath == null)
                 throw new InvalidOperationException("Sample assembly is not instrumented.");
-            var client = RecordingController.ForEndPoint("localhost", PortNumber, Map);
+            var client = RecordingController.ForEndPoint("localhost", PortNumber, Map, _logger);
             return client.CollectResultAndReset().GetVisitedSources().ToList(); ;
         }
     }
diff --git a/SG.CodeCoverage/Collection/MultiRecordingController.cs b/SG.CodeCoverage/Collection/MultiRecordingController.cs
@@ -1,24 +1,28 @@
-﻿using SG.CodeCoverage.Coverage;
+﻿using SG.CodeCoverage.Common;
+using SG.CodeCoverage.Coverage;
 using SG.CodeCoverage.Metadata;
 using SG.CodeCoverage.Recorder.RecordingController;
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 
 namespace SG.CodeCoverage.Collection
 {
     internal class MultiRecordingController : IRecordingController
     {
         private readonly string _recorderRuntimeConfigFilePath;
         private readonly InstrumentationMap _map;
+        private readonly ILogger _logger;
         private DateTime _currentRuntimeConfigFileLastUpdate;
         private RuntimeConfig _currentRuntimeConfig;
         private const string _host = "localhost";
 
-        public MultiRecordingController(string recorderRuntimeConfigFilePath, InstrumentationMap map)
+        public MultiRecordingController(string recorderRuntimeConfigFilePath, InstrumentationMap map, ILogger logger = null)
         {
             _recorderRuntimeConfigFilePath = recorderRuntimeConfigFilePath;
             _map = map;
+            _logger = logger ?? new ConsoleLogger();
         }
 
         public void ResetHits()
@@ -27,6 +31,7 @@ public void ResetHits()
                 return;
             foreach(var process in _currentRuntimeConfig.Processes)
             {
+                _logger.LogInformation($"Resetting hits for process {process.ID} on port {process.ListeningPort}");
                 RecordingControllerClient.ResetHits(_host, process.ListeningPort);
             }
         }
@@ -38,6 +43,7 @@ public CoverageResult CollectResultAndReset()
             CoverageResult result = null;
             foreach(var process in _currentRuntimeConfig.Processes)
             {
+                _logger.LogInformation($"Collecting coverage result from process {process.ID} on port {process.ListeningPort}");
                 var procResult = RecordingControllerClient.CollectResultAndReset(_host, process.ListeningPort, _map);
                 if (result == null)
                     result = procResult;
@@ -53,15 +59,20 @@ private bool LoadRuntimeConfig()
             {
                 _currentRuntimeConfigFileLastUpdate = default;
                 _currentRuntimeConfig = null;
+                _logger.LogWarning($"Runtime Config file '{_recorderRuntimeConfigFilePath}' not found.");
                 return false;
             }
 
             var newUpdateDate = File.GetLastWriteTime(_recorderRuntimeConfigFilePath);
             if (_currentRuntimeConfig == null ||
                 newUpdateDate > _currentRuntimeConfigFileLastUpdate)
             {
+                _logger.LogInformation($"Loading Runtime Config file '{_recorderRuntimeConfigFilePath}'");
                 _currentRuntimeConfig = RuntimeConfig.Load(_recorderRuntimeConfigFilePath);
                 _currentRuntimeConfigFileLastUpdate = newUpdateDate;
+                _logger.LogVerbose($"Runtime Config file loaded. " +
+                                   $"Processes: {string.Join(", ", _currentRuntimeConfig.Processes.Select(p => p.ID))}" +
+                                   $" - Last update: {newUpdateDate:O}");
             }
             return true;
         }
diff --git a/SG.CodeCoverage/Collection/RecordingController.cs b/SG.CodeCoverage/Collection/RecordingController.cs
@@ -1,17 +1,18 @@
-﻿using SG.CodeCoverage.Metadata;
+﻿using SG.CodeCoverage.Common;
+using SG.CodeCoverage.Metadata;
 
 namespace SG.CodeCoverage.Collection
 {
     public static class RecordingController
     {
-        public static IRecordingController ForRuntimeConfigFile(string runtimeConfigFilePath, InstrumentationMap map)
+        public static IRecordingController ForRuntimeConfigFile(string runtimeConfigFilePath, InstrumentationMap map, ILogger logger)
         {
-            return new MultiRecordingController(runtimeConfigFilePath, map);
+            return new MultiRecordingController(runtimeConfigFilePath, map, logger);
         }
 
-        public static IRecordingController ForEndPoint(string host, int port, InstrumentationMap map)
+        public static IRecordingController ForEndPoint(string host, int port, InstrumentationMap map, ILogger logger)
         {
-            return new SingleRecordingController(host, port, map);
+            return new SingleRecordingController(host, port, map, logger);
         }
     }
 }
diff --git a/SG.CodeCoverage/Collection/SingleRecordingController.cs b/SG.CodeCoverage/Collection/SingleRecordingController.cs
@@ -1,4 +1,5 @@
-﻿using SG.CodeCoverage.Coverage;
+﻿using SG.CodeCoverage.Common;
+using SG.CodeCoverage.Coverage;
 using SG.CodeCoverage.Metadata;
 
 namespace SG.CodeCoverage.Collection
@@ -8,21 +9,25 @@ internal class SingleRecordingController : IRecordingController
         private readonly string _host;
         private readonly int _port;
         private readonly InstrumentationMap _map;
+        private readonly ILogger _logger;
 
-        public SingleRecordingController(string host, int port, InstrumentationMap map)
+        public SingleRecordingController(string host, int port, InstrumentationMap map, ILogger logger = null)
         {
             _host = host;
             _port = port;
             _map = map;
+            _logger = logger ?? new ConsoleLogger();
         }
 
         public CoverageResult CollectResultAndReset()
         {
+            _logger.LogInformation($"Collecting coverage result for {_host}:{_port}");
             return RecordingControllerClient.CollectResultAndReset(_host, _port, _map);
         }
 
         public void ResetHits()
         {
+            _logger.LogInformation($"Resetting hits for {_host}:{_port}");
             RecordingControllerClient.ResetHits(_host, _port);
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -20,21 +20,24 @@ public class InstrumenterTester`
`20`	`20`	`public string MapFilePath { get; }`
`21`	`21`	`public InstrumentationMap Map { get; private set; }`
`22`	`22`	`public string InstrumentedAssemblyPath { get; private set; }`
	`23`	`+ private readonly ILogger _logger;`
`23`	`24`
`24`	`25`	`static InstrumenterTester()`
`25`	`26`	`{`
`26`	`27`	`DefaultOutputPath = Path.Combine(Path.GetTempPath(), "SG.CodeCoverage");`
`27`	`28`	`}`
`28`	`29`
`29`		`- public InstrumenterTester()`
	`30`	`+ public InstrumenterTester(ILogger logger = null)`
`30`	`31`	`{`
`31`	`32`	`OutputPath = DefaultOutputPath;`
	`33`	`+ _logger = logger ?? new ConsoleLogger();`
`32`	`34`	`}`
`33`	`35`
`34`		`- public InstrumenterTester(string existingInstrumentedSampleFolder)`
	`36`	`+ public InstrumenterTester(string existingInstrumentedSampleFolder, ILogger logger = null)`
`35`	`37`	`{`
`36`	`38`	`OutputPath = existingInstrumentedSampleFolder;`
`37`	`39`	`InstrumentedAssemblyPath = Path.Combine(OutputPath, Path.GetFileName(typeof(PrimeCalculator).Assembly.Location));`
	`40`	`+ _logger = logger ?? new ConsoleLogger();`
`38`	`41`	`}`
`39`	`42`
`40`	`43`	`public void InstrumentSampleProject()`
`@@ -55,7 +58,7 @@ public void InstrumentSampleProject()`
`55`	`58`	`var options = new InstrumentationOptions(`
`56`	`59`	`new[] { assemblyFileName },`
`57`	`60`	`Array.Empty<string>(), OutputPath, PortNumber);`
`58`		`- Instrumenter instrumenter = new Instrumenter(options, new ConsoleLogger());`
	`61`	`+ Instrumenter instrumenter = new Instrumenter(options, _logger);`
`59`	`62`	`instrumenter.BackupFolder = Path.Combine(OutputPath, "backup");`
`60`	`63`	`Directory.CreateDirectory(instrumenter.BackupFolder);`
`61`	`64`	`Map = instrumenter.Instrument();`
`@@ -74,7 +77,7 @@ public void RunSomeCode()`
`74`	`77`	`{`
`75`	`78`	`if (InstrumentedAssemblyPath == null)`
`76`	`79`	`throw new InvalidOperationException("Sample assembly is not instrumented.");`
`77`		`- var client = RecordingController.ForEndPoint("localhost", PortNumber, Map);`
	`80`	`+ var client = RecordingController.ForEndPoint("localhost", PortNumber, Map, _logger);`
`78`	`81`	`Assembly.LoadFrom(Path.Combine(OutputPath, "SG.CodeCoverage.Recorder.dll"));`
`79`	`82`	`var assembly = Assembly.LoadFrom(InstrumentedAssemblyPath);`
`80`	`83`	`var calc = assembly.DefinedTypes.Where(x => x.Name == nameof(PrimeCalculator)).FirstOrDefault();`
`@@ -85,7 +88,7 @@ public List<string> GetVisitedFiles()`
`85`	`88`	`{`
`86`	`89`	`if (InstrumentedAssemblyPath == null)`
`87`	`90`	`throw new InvalidOperationException("Sample assembly is not instrumented.");`
`88`		`- var client = RecordingController.ForEndPoint("localhost", PortNumber, Map);`
	`91`	`+ var client = RecordingController.ForEndPoint("localhost", PortNumber, Map, _logger);`
`89`	`92`	`return client.CollectResultAndReset().GetVisitedSources().ToList(); ;`
`90`	`93`	`}`
`91`	`94`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,24 +1,28 @@`
`1`		`-using SG.CodeCoverage.Coverage;`
	`1`	`+using SG.CodeCoverage.Common;`
	`2`	`+using SG.CodeCoverage.Coverage;`
`2`	`3`	`using SG.CodeCoverage.Metadata;`
`3`	`4`	`using SG.CodeCoverage.Recorder.RecordingController;`
`4`	`5`	`using System;`
`5`	`6`	`using System.Collections.Generic;`
`6`	`7`	`using System.IO;`
	`8`	`+using System.Linq;`
`7`	`9`
`8`	`10`	`namespace SG.CodeCoverage.Collection`
`9`	`11`	`{`
`10`	`12`	`internal class MultiRecordingController : IRecordingController`
`11`	`13`	`{`
`12`	`14`	`private readonly string _recorderRuntimeConfigFilePath;`
`13`	`15`	`private readonly InstrumentationMap _map;`
	`16`	`+ private readonly ILogger _logger;`
`14`	`17`	`private DateTime _currentRuntimeConfigFileLastUpdate;`
`15`	`18`	`private RuntimeConfig _currentRuntimeConfig;`
`16`	`19`	`private const string _host = "localhost";`
`17`	`20`
`18`		`- public MultiRecordingController(string recorderRuntimeConfigFilePath, InstrumentationMap map)`
	`21`	`+ public MultiRecordingController(string recorderRuntimeConfigFilePath, InstrumentationMap map, ILogger logger = null)`
`19`	`22`	`{`
`20`	`23`	`_recorderRuntimeConfigFilePath = recorderRuntimeConfigFilePath;`
`21`	`24`	`_map = map;`
	`25`	`+ _logger = logger ?? new ConsoleLogger();`
`22`	`26`	`}`
`23`	`27`
`24`	`28`	`public void ResetHits()`
`@@ -27,6 +31,7 @@ public void ResetHits()`
`27`	`31`	`return;`
`28`	`32`	`foreach(var process in _currentRuntimeConfig.Processes)`
`29`	`33`	`{`
	`34`	`+ _logger.LogInformation($"Resetting hits for process {process.ID} on port {process.ListeningPort}");`
`30`	`35`	`RecordingControllerClient.ResetHits(_host, process.ListeningPort);`
`31`	`36`	`}`
`32`	`37`	`}`
`@@ -38,6 +43,7 @@ public CoverageResult CollectResultAndReset()`
`38`	`43`	`CoverageResult result = null;`
`39`	`44`	`foreach(var process in _currentRuntimeConfig.Processes)`
`40`	`45`	`{`
	`46`	`+ _logger.LogInformation($"Collecting coverage result from process {process.ID} on port {process.ListeningPort}");`
`41`	`47`	`var procResult = RecordingControllerClient.CollectResultAndReset(_host, process.ListeningPort, _map);`
`42`	`48`	`if (result == null)`
`43`	`49`	`result = procResult;`
`@@ -53,15 +59,20 @@ private bool LoadRuntimeConfig()`
`53`	`59`	`{`
`54`	`60`	`_currentRuntimeConfigFileLastUpdate = default;`
`55`	`61`	`_currentRuntimeConfig = null;`
	`62`	`+ _logger.LogWarning($"Runtime Config file '{_recorderRuntimeConfigFilePath}' not found.");`
`56`	`63`	`return false;`
`57`	`64`	`}`
`58`	`65`
`59`	`66`	`var newUpdateDate = File.GetLastWriteTime(_recorderRuntimeConfigFilePath);`
`60`	`67`	`if (_currentRuntimeConfig == null \|\|`
`61`	`68`	`newUpdateDate > _currentRuntimeConfigFileLastUpdate)`
`62`	`69`	`{`
	`70`	`+ _logger.LogInformation($"Loading Runtime Config file '{_recorderRuntimeConfigFilePath}'");`
`63`	`71`	`_currentRuntimeConfig = RuntimeConfig.Load(_recorderRuntimeConfigFilePath);`
`64`	`72`	`_currentRuntimeConfigFileLastUpdate = newUpdateDate;`
	`73`	`+ _logger.LogVerbose($"Runtime Config file loaded. " +`
	`74`	`+ $"Processes: {string.Join(", ", _currentRuntimeConfig.Processes.Select(p => p.ID))}" +`
	`75`	`+ $" - Last update: {newUpdateDate:O}");`
`65`	`76`	`}`
`66`	`77`	`return true;`
`67`	`78`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,17 +1,18 @@`
`1`		`-using SG.CodeCoverage.Metadata;`
	`1`	`+using SG.CodeCoverage.Common;`
	`2`	`+using SG.CodeCoverage.Metadata;`
`2`	`3`
`3`	`4`	`namespace SG.CodeCoverage.Collection`
`4`	`5`	`{`
`5`	`6`	`public static class RecordingController`
`6`	`7`	`{`
`7`		`- public static IRecordingController ForRuntimeConfigFile(string runtimeConfigFilePath, InstrumentationMap map)`
	`8`	`+ public static IRecordingController ForRuntimeConfigFile(string runtimeConfigFilePath, InstrumentationMap map, ILogger logger)`
`8`	`9`	`{`
`9`		`- return new MultiRecordingController(runtimeConfigFilePath, map);`
	`10`	`+ return new MultiRecordingController(runtimeConfigFilePath, map, logger);`
`10`	`11`	`}`
`11`	`12`
`12`		`- public static IRecordingController ForEndPoint(string host, int port, InstrumentationMap map)`
	`13`	`+ public static IRecordingController ForEndPoint(string host, int port, InstrumentationMap map, ILogger logger)`
`13`	`14`	`{`
`14`		`- return new SingleRecordingController(host, port, map);`
	`15`	`+ return new SingleRecordingController(host, port, map, logger);`
`15`	`16`	`}`
`16`	`17`	`}`
`17`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`		`-using SG.CodeCoverage.Coverage;`
	`1`	`+using SG.CodeCoverage.Common;`
	`2`	`+using SG.CodeCoverage.Coverage;`
`2`	`3`	`using SG.CodeCoverage.Metadata;`
`3`	`4`
`4`	`5`	`namespace SG.CodeCoverage.Collection`
`@@ -8,21 +9,25 @@ internal class SingleRecordingController : IRecordingController`
`8`	`9`	`private readonly string _host;`
`9`	`10`	`private readonly int _port;`
`10`	`11`	`private readonly InstrumentationMap _map;`
	`12`	`+ private readonly ILogger _logger;`
`11`	`13`
`12`		`- public SingleRecordingController(string host, int port, InstrumentationMap map)`
	`14`	`+ public SingleRecordingController(string host, int port, InstrumentationMap map, ILogger logger = null)`
`13`	`15`	`{`
`14`	`16`	`_host = host;`
`15`	`17`	`_port = port;`
`16`	`18`	`_map = map;`
	`19`	`+ _logger = logger ?? new ConsoleLogger();`
`17`	`20`	`}`
`18`	`21`
`19`	`22`	`public CoverageResult CollectResultAndReset()`
`20`	`23`	`{`
	`24`	`+ _logger.LogInformation($"Collecting coverage result for {_host}:{_port}");`
`21`	`25`	`return RecordingControllerClient.CollectResultAndReset(_host, _port, _map);`
`22`	`26`	`}`
`23`	`27`
`24`	`28`	`public void ResetHits()`
`25`	`29`	`{`
	`30`	`+ _logger.LogInformation($"Resetting hits for {_host}:{_port}");`
`26`	`31`	`RecordingControllerClient.ResetHits(_host, _port);`
`27`	`32`	`}`
`28`	`33`	`}`