Merge pull request #544 from IridiumIO/Logging

Added Logging

Author: Iridium-IO

CompactGUI.Core/Analyser.cs

@@ -1,5 +1,8 @@
-using System.Collections.Concurrent;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+using System.Collections.Concurrent;
 using System.Diagnostics;
+using CompactGUI.Logging.Core;
 
 namespace CompactGUI.Core;
 
@@ -12,18 +15,22 @@ public class Analyser
     public bool ContainsCompressedFiles { get; set; }
     public List<AnalysedFileDetails> FileCompressionDetailsList { get; set; } = new List<AnalysedFileDetails>();
 
+    private ILogger<Analyser> _logger;
 
-    public Analyser(string folder)
+    public Analyser(string folder, ILogger<Analyser> logger)
     {
         FolderName = folder;
         UncompressedBytes = 0;
         CompressedBytes = 0;
         ContainsCompressedFiles = false;
+        _logger = logger;
     }
 
 
     public async Task<Boolean?> AnalyseFolder(CancellationToken cancellationToken)
     {
+        AnalyserLog.StartingAnalysis(_logger, FolderName);
+        Stopwatch sw = Stopwatch.StartNew();
         try
         {
             var allFiles = await Task.Run(() => Directory.EnumerateFiles(FolderName, "*", new EnumerationOptions { RecurseSubdirectories = true, IgnoreInaccessible = true, AttributesToSkip = FileAttributes.ReparsePoint }).AsShortPathNames(), cancellationToken).ConfigureAwait(false);
@@ -39,22 +46,25 @@ public Analyser(string folder)
             ContainsCompressedFiles = fileDetails.Any(f => f.CompressionMode != WOFCompressionAlgorithm.NO_COMPRESSION);
 
             FileCompressionDetailsList = fileDetails;
-
-            return ContainsCompressedFiles;
         }
         catch (Exception ex)
         {
-            Debug.WriteLine(ex.Message);
+            AnalyserLog.AnalysisFailed(_logger, FolderName, ex.Message);
             return null;
         }
+        finally { sw.Stop(); }
+        
+        AnalyserLog.AnalysisCompleted(_logger, FolderName, Math.Round(sw.Elapsed.TotalSeconds, 3), CompressedBytes, UncompressedBytes, ContainsCompressedFiles);
 
+        return ContainsCompressedFiles;
 
 
     }
 
 
     private AnalysedFileDetails? AnalyseFile(string file)
     {
+        AnalyserLog.ProcessingFile(_logger, file);
         try
         {
             FileInfo fileInfo = new FileInfo(file);
@@ -67,8 +77,9 @@ public Analyser(string folder)
 
             return new AnalysedFileDetails { FileName = file, CompressedSize = compressedSize, UncompressedSize = uncompressedSize, CompressionMode = compressionMode, FileInfo = fileInfo };
         }
-        catch (IOException)
+        catch (IOException ex)
         {
+            AnalyserLog.ProcessingFileFailed(_logger, file, ex.Message);
             return null;
         }
     }

CompactGUI.Core/CompactGUI.Core.csproj

@@ -20,4 +20,9 @@
     <PackageReference Include="ZLinq" Version="1.4.10" />
   </ItemGroup>
 
+  
+  <ItemGroup>
+    <ProjectReference Include="..\CompactGUI.Logging\CompactGUI.Logging.csproj" />
+  </ItemGroup>
+
 </Project>

CompactGUI.Core/Compactor.cs

@@ -1,4 +1,7 @@
 
+using CompactGUI.Logging.Core;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
 using Microsoft.Win32.SafeHandles;
 using System.Collections.Concurrent;
 using System.Diagnostics;
@@ -23,13 +26,14 @@ public class Compactor : ICompressor, IDisposable
     private readonly SemaphoreSlim pauseSemaphore = new SemaphoreSlim(1, 2);
     private readonly CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
 
+    private ILogger<Compactor> _logger;
 
-    public Compactor(string folderPath, WOFCompressionAlgorithm compressionLevel, string[] excludedFileTypes)
+    public Compactor(string folderPath, WOFCompressionAlgorithm compressionLevel, string[] excludedFileTypes, ILogger<Compactor>? logger = null)
     {
         workingDirectory = folderPath;
         excludedFileExtensions = new HashSet<string>(excludedFileTypes);
         wofCompressionAlgorithm = compressionLevel;
-
+        _logger = logger ?? NullLogger<Compactor>.Instance;
         InitializeCompressionInfoPointer();
     }
 
@@ -47,32 +51,47 @@ public async Task<bool> RunAsync(List<string> filesList, IProgress<CompressionPr
     {
         if(cancellationTokenSource.IsCancellationRequested) { return false; }
 
+        CompactorLog.BuildingWorkingFilesList(_logger, workingDirectory);
         var workingFiles = await BuildWorkingFilesList().ConfigureAwait(false);
         long totalFilesSize = workingFiles.Sum((f) => f.UncompressedSize);
 
         totalProcessedBytes = 0;
 
-        if(maxParallelism <= 0) maxParallelism = Environment.ProcessorCount;
+        var sw = Stopwatch.StartNew();
+
+        if (maxParallelism <= 0) maxParallelism = Environment.ProcessorCount;
         ParallelOptions parallelOptions = new() { MaxDegreeOfParallelism = maxParallelism, CancellationToken = cancellationTokenSource.Token };
 
+        CompactorLog.StartingCompression(_logger, workingDirectory, wofCompressionAlgorithm.ToString(), maxParallelism);
         try
         {
-            await Parallel.ForEachAsync(workingFiles, parallelOptions,
+           await Parallel.ForEachAsync(workingFiles, parallelOptions,
                 (file, ctx) =>
                 {
                     ctx.ThrowIfCancellationRequested();
 
                     return new ValueTask(PauseAndProcessFile(file, totalFilesSize, cancellationTokenSource.Token, progressMonitor));
                 }).ConfigureAwait(false);
         }
-        catch (OperationCanceledException){ return false; }
-        catch (Exception){ return false; }
+        catch (OperationCanceledException){
+            CompactorLog.CompressionCanceled(_logger);
+            return false; 
+        }
+        catch (Exception ex){ 
+            CompactorLog.CompressionFailed(_logger, ex.Message);
+            return false; 
+        }
+        finally { sw.Stop();}
+
 
+        
+        CompactorLog.CompressionCompleted(_logger, Math.Round(sw.Elapsed.TotalSeconds, 3));
         return true;
     }
 
     private async Task PauseAndProcessFile(FileDetails file, long totalFilesSize, CancellationToken token, IProgress<CompressionProgress> progressMonitor)
     {
+        CompactorLog.ProcessingFile(_logger, file.FileName, file.UncompressedSize);
 
         await pauseSemaphore.WaitAsync(token).ConfigureAwait(false);
         pauseSemaphore.Release();
@@ -94,7 +113,7 @@ private async Task PauseAndProcessFile(FileDetails file, long totalFilesSize, Ca
         }
         catch (Exception ex)
         {
-            Debug.WriteLine(ex.Message);
+            CompactorLog.FileCompressionFailed(_logger, filePath, ex.Message);
             return null;
         }
     }
@@ -103,7 +122,7 @@ public async Task<IEnumerable<FileDetails>> BuildWorkingFilesList()
     {
         uint clusterSize = SharedMethods.GetClusterSize(workingDirectory);
 
-        var analyser = new Analyser(workingDirectory);
+        var analyser = new Analyser(workingDirectory, NullLogger<Analyser>.Instance);
         var ret = await analyser.AnalyseFolder(cancellationTokenSource.Token);
 
         var filesList = analyser.FileCompressionDetailsList
@@ -123,13 +142,15 @@ public async Task<IEnumerable<FileDetails>> BuildWorkingFilesList()
 
     public void Pause()
     {
+        CompactorLog.CompressionPaused(_logger);
         pauseSemaphore.Wait(cancellationTokenSource.Token);
     }
 
 
     public void Resume()
     {
         if (pauseSemaphore.CurrentCount == 0) pauseSemaphore.Release();  
+        CompactorLog.CompressionResumed(_logger);
     }
 
 

CompactGUI.Core/Uncompactor.cs

@@ -1,7 +1,11 @@
 
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
 using Microsoft.Win32.SafeHandles;
 using System.Collections.Concurrent;
 using Windows.Win32;
+using CompactGUI.Logging.Core;
+using System.Diagnostics;
 
 namespace CompactGUI.Core;
 
@@ -12,6 +16,12 @@ public class Uncompactor : ICompressor, IDisposable
     private CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
     private ConcurrentDictionary<string, int> processedFileCount = new ConcurrentDictionary<string, int>();
 
+    private readonly ILogger<Uncompactor> _logger;
+
+    public Uncompactor(ILogger<Uncompactor>? logger = null)
+    {
+        _logger = logger ?? NullLogger<Uncompactor>.Instance;
+    }
 
     public async Task<bool> RunAsync(List<string> filesList, IProgress<CompressionProgress>? progressMonitor = null, int maxParallelism = 1)
     {
@@ -20,6 +30,8 @@ public async Task<bool> RunAsync(List<string> filesList, IProgress<CompressionPr
         ParallelOptions parallelOptions = new() { MaxDegreeOfParallelism = maxParallelism };
         processedFileCount.Clear();
 
+        UncompactorLog.StartingDecompression(_logger, totalFiles, maxParallelism);
+        Stopwatch sw = Stopwatch.StartNew();
         try
         {
             await Parallel.ForEachAsync(filesList, parallelOptions,
@@ -29,14 +41,20 @@ await Parallel.ForEachAsync(filesList, parallelOptions,
                     return new ValueTask(PauseAndProcessFile(file, totalFiles, progressMonitor, cancellationTokenSource.Token));
                 });
         }
-        catch (OperationCanceledException) { return false; }
+        catch (OperationCanceledException) {
+            UncompactorLog.DecompressionCanceled(_logger);
+            return false; 
+        }
+        finally { sw.Stop(); }
 
+        UncompactorLog.DecompressionCompleted(_logger, Math.Round(sw.Elapsed.TotalSeconds, 3));
         return true;
 
     }
 
     private async Task PauseAndProcessFile(string file, int totalFiles, IProgress<CompressionProgress>? progressMonitor, CancellationToken ctx)
     {
+        UncompactorLog.ProcessingFile(_logger, file);
         try
         {
             await pauseSemaphore.WaitAsync(ctx).ConfigureAwait(false);
@@ -64,18 +82,23 @@ private async Task PauseAndProcessFile(string file, int totalFiles, IProgress<Co
                 return res;
             }  
         }
-        catch (Exception) { return null; }
+        catch (Exception ex) { 
+            UncompactorLog.FileDecompressionFailed(_logger, file, ex.Message);
+            return null; 
+        }
     }
 
     public void Pause()
     {
+        UncompactorLog.DecompressionPaused(_logger);
         pauseSemaphore.Wait();
     }
 
 
     public void Resume()
     {
         if (pauseSemaphore.CurrentCount == 0) pauseSemaphore.Release();
+        UncompactorLog.DecompressionResumed(_logger);
     }
 
 

CompactGUI.Logging/CompactGUI.Logging.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="9.0.5" />
+  </ItemGroup>
+
+</Project>

CompactGUI.Logging/Core/AnalyserLog.cs

@@ -0,0 +1,31 @@
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CompactGUI.Logging.Core;
+
+public static partial class AnalyserLog
+{
+
+    [LoggerMessage(Level = LogLevel.Debug, Message = "Starting analysis of directory: {Directory}")]
+    public static partial void StartingAnalysis(ILogger logger, string directory);
+
+    [LoggerMessage(Level = LogLevel.Trace, Message = "Processing file: {FileName}")]
+    public static partial void ProcessingFile(ILogger logger, string fileName);
+
+    [LoggerMessage(Level = LogLevel.Warning, Message = "Processing file failed: {FileName} with message: {Message}")]
+    public static partial void ProcessingFileFailed(ILogger logger, string fileName, string message);
+
+
+    [LoggerMessage(Level = LogLevel.Trace, Message = "Processing folder: {FolderName}")]
+    public static partial void ProcessingFolder(ILogger logger, string folderName);
+
+    [LoggerMessage(Level = LogLevel.Warning, Message = "Analysis failed for: {Path} with error: {ErrorMessage}")]
+    public static partial void AnalysisFailed(ILogger logger, string path, string errorMessage);
+
+    [LoggerMessage(Level = LogLevel.Information, Message = "Analysis completed for directory: {Directory} in {TimeTaken}s. Uncompressed Size: {UncompressedBytes}b, CompressedSize: {CompressedBytes}b, ContainsCompressedFiles: {ContainsCompressedFiles}")]
+    public static partial void AnalysisCompleted(ILogger logger, string directory, double timeTaken, long compressedBytes, long uncompressedBytes, bool containsCompressedFiles);
+}

CompactGUI.Logging/Core/CompactorLog.cs

@@ -0,0 +1,40 @@
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CompactGUI.Logging.Core;
+
+public static partial class CompactorLog
+{
+
+    [LoggerMessage(Level = LogLevel.Information, Message = "Starting compression in directory: {Directory} with algorithm: {Algorithm} and using {MaxParallelism} threads")]
+    public static partial void StartingCompression(ILogger logger, string directory, string algorithm, int maxParallelism);
+
+    [LoggerMessage(Level = LogLevel.Debug, Message = "Building working files list for directory: {Directory}")]
+    public static partial void BuildingWorkingFilesList(ILogger logger, string directory);
+
+    [LoggerMessage(Level = LogLevel.Trace, Message = "Processing file: {FileName} ({UncompressedSize} bytes)")]
+    public static partial void ProcessingFile(ILogger logger, string fileName, long uncompressedSize);
+
+    [LoggerMessage(Level = LogLevel.Warning, Message = "File compression failed for: {FileName} with error: {ErrorMessage}")]
+    public static partial void FileCompressionFailed(ILogger logger, string fileName, string errorMessage);
+
+    [LoggerMessage(Level = LogLevel.Information, Message = "Compression paused.")]
+    public static partial void CompressionPaused(ILogger logger);
+
+    [LoggerMessage(Level = LogLevel.Information, Message = "Compression resumed.")]
+    public static partial void CompressionResumed(ILogger logger);
+
+    [LoggerMessage(Level = LogLevel.Information, Message = "Compression canceled.")]
+    public static partial void CompressionCanceled(ILogger logger);
+
+    [LoggerMessage(Level = LogLevel.Information, Message = "Compression completed successfully in {TimeTaken}s.")]
+    public static partial void CompressionCompleted(ILogger logger, double timeTaken);
+
+    [LoggerMessage(Level = LogLevel.Error, Message = "Compression failed with error: {ErrorMessage}")]
+    public static partial void CompressionFailed(ILogger logger, string errorMessage);
+
+}

CompactGUI.Logging/Core/UncompactorLog.cs

@@ -0,0 +1,32 @@
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CompactGUI.Logging.Core;
+
+public static partial class UncompactorLog
+{
+    [LoggerMessage(Level = LogLevel.Information, Message = "Starting decompression of {FileCount} files with {MaxParallelism} threads")]
+    public static partial void StartingDecompression(ILogger logger, int fileCount, int maxParallelism);
+
+    [LoggerMessage(Level = LogLevel.Trace, Message = "Processing file: {FileName}")]
+    public static partial void ProcessingFile(ILogger logger, string fileName);
+
+    [LoggerMessage(Level = LogLevel.Warning, Message = "File decompression failed for: {FileName} with error: {ErrorMessage}")]
+    public static partial void FileDecompressionFailed(ILogger logger, string fileName, string errorMessage);
+
+    [LoggerMessage(Level = LogLevel.Information, Message = "Decompression paused.")]
+    public static partial void DecompressionPaused(ILogger logger);
+
+    [LoggerMessage(Level = LogLevel.Information, Message = "Decompression resumed.")]
+    public static partial void DecompressionResumed(ILogger logger);
+
+    [LoggerMessage(Level = LogLevel.Information, Message = "Decompression canceled.")]
+    public static partial void DecompressionCanceled(ILogger logger);
+
+    [LoggerMessage(Level = LogLevel.Information, Message = "Decompression completed successfully in {TimeTaken}s.")]
+    public static partial void DecompressionCompleted(ILogger logger, double timeTaken);
+}