Compress for cdb output files

Author: CapulusCodeNinja

Directory.Build.props

@@ -39,7 +39,7 @@
     <PropertyGroup Label="Default Versioning">
         <!-- Default version for all projects (can be overridden per project) -->
         <VersionPrefix>1.1.2</VersionPrefix>
-        <VersionSuffix>3</VersionSuffix>
+        <VersionSuffix>4</VersionSuffix>
 
         <!-- Calculated version -->
         <Version Condition="'$(Version)' == ''">$(VersionPrefix).$(VersionSuffix)</Version>

nexus_engine/nexus_engine/Internal/CdbSession.cs

@@ -1,4 +1,5 @@
 using System.Diagnostics;
+using System.IO.Compression;
 using System.Text;
 
 using Nexus.Config;
@@ -233,6 +234,7 @@ public async Task DisposeAsync()
         {
             await SendQuitCommandAsync();
             await WaitForProcessExitAsync();
+            await CompressCdbLogIfAvailableAsync();
             DisposeResources();
         }
         catch (Exception ex)
@@ -499,7 +501,7 @@ protected void CleanupOldCdbLogs(string sessionsDirectory, int retentionDays)
         try
         {
             var directoryInfo = m_FileSystem.GetDirectoryInfo(sessionsDirectory);
-            var files = directoryInfo.GetFiles("cdb_*.log");
+            var files = directoryInfo.GetFiles("cdb_*.log*");
 
             if (files.Length == 0)
             {
@@ -542,6 +544,50 @@ protected void CleanupOldCdbLogs(string sessionsDirectory, int retentionDays)
         }
     }
 
+    /// <summary>
+    /// Attempts to compress the current session's CDB log file using GZip in a best-effort manner.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous compression operation.</returns>
+    private async Task CompressCdbLogIfAvailableAsync()
+    {
+        try
+        {
+            if (string.IsNullOrWhiteSpace(SessionId))
+            {
+                return;
+            }
+
+            var cdbLogFilePath = GetCdbSessionBasedLogPath(SessionId);
+
+            if (!File.Exists(cdbLogFilePath))
+            {
+                return;
+            }
+
+            var compressedPath = $"{cdbLogFilePath}.gz";
+
+            if (File.Exists(compressedPath))
+            {
+                return;
+            }
+
+            using (var sourceStream = new FileStream(cdbLogFilePath, FileMode.Open, FileAccess.Read, FileShare.Read))
+            using (var destinationStream = new FileStream(compressedPath, FileMode.Create, FileAccess.Write, FileShare.None))
+            using (var gzipStream = new GZipStream(destinationStream, CompressionLevel.Optimal))
+            {
+                await sourceStream.CopyToAsync(gzipStream).ConfigureAwait(false);
+            }
+
+            File.Delete(cdbLogFilePath);
+
+            m_Logger.Info("Compressed CDB log for session {SessionId} to {CompressedPath}", SessionId, compressedPath);
+        }
+        catch (Exception ex)
+        {
+            m_Logger.Info(ex, "Failed to compress CDB log for session {SessionId}. Keeping uncompressed log file.", SessionId);
+        }
+    }
+
     /// <summary>
     /// Builds the command line arguments for starting the CDB process.
     /// </summary>

unittests/nexus_engine/nexus_engine_unittests/Internal/CdbSessionTests.cs

@@ -13,6 +13,10 @@
 using Nexus.External.Apis.FileSystem;
 using Nexus.External.Apis.ProcessManagement;
 
+using NLog;
+using NLog.Config;
+using NLog.Targets;
+
 using Xunit;
 
 namespace Nexus.Engine.Tests.Internal;
@@ -594,12 +598,18 @@ public void CleanupOldCdbLogs_DeletesFilesOlderThanRetentionDays()
 
         var oldFilePath = Path.Combine(sessionsDirectory, "cdb_old.log");
         var recentFilePath = Path.Combine(sessionsDirectory, "cdb_recent.log");
+        var oldCompressedFilePath = Path.Combine(sessionsDirectory, "cdb_old.log.gz");
+        var recentCompressedFilePath = Path.Combine(sessionsDirectory, "cdb_recent.log.gz");
 
         File.WriteAllText(oldFilePath, "old");
         File.WriteAllText(recentFilePath, "recent");
+        File.WriteAllText(oldCompressedFilePath, "old_compressed");
+        File.WriteAllText(recentCompressedFilePath, "recent_compressed");
 
         File.SetCreationTime(oldFilePath, DateTime.Now.AddDays(-10));
+        File.SetCreationTime(oldCompressedFilePath, DateTime.Now.AddDays(-10));
         File.SetCreationTime(recentFilePath, DateTime.Now);
+        File.SetCreationTime(recentCompressedFilePath, DateTime.Now);
 
         try
         {
@@ -615,8 +625,11 @@ public void CleanupOldCdbLogs_DeletesFilesOlderThanRetentionDays()
 
             // Assert
             _ = File.Exists(oldFilePath).Should().BeFalse();
+            _ = File.Exists(oldCompressedFilePath).Should().BeFalse();
             _ = File.Exists(recentFilePath).Should().BeTrue();
+            _ = File.Exists(recentCompressedFilePath).Should().BeTrue();
             m_MockFileSystem.Verify(fs => fs.DeleteFile(oldFilePath), Times.Once);
+            m_MockFileSystem.Verify(fs => fs.DeleteFile(oldCompressedFilePath), Times.Once);
         }
         finally
         {
@@ -1373,4 +1386,68 @@ public async Task InitializeAsync_WhenInitializationFails_DisposesSession()
         // Assert - Session should be disposed after initialization failure
         _ = session.IsInitialized.Should().BeFalse();
     }
+
+    /// <summary>
+    /// Verifies that disposing the session compresses the CDB log file and deletes the original log.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+    [Fact]
+    public async Task DisposeAsync_CompressesCdbLog_AndDeletesOriginalLog()
+    {
+        // Arrange
+        var originalConfig = LogManager.Configuration;
+        var tempRoot = Path.Combine(Path.GetTempPath(), "MCPNexusCdbCompressionTests", Guid.NewGuid().ToString("N"));
+        var logsDirectory = Path.Combine(tempRoot, "Logs");
+        _ = Directory.CreateDirectory(logsDirectory);
+
+        try
+        {
+            var config = new LoggingConfiguration();
+            var mainLogPath = Path.Combine(logsDirectory, "main.log");
+            var fileTarget = new FileTarget("mainFile")
+            {
+                FileName = mainLogPath,
+            };
+            config.AddTarget(fileTarget);
+            config.AddRuleForAllLevels(fileTarget);
+            LogManager.Configuration = config;
+
+            var accessor = new CdbSessionTestAccessor(m_Settings.Object, m_MockFileSystem.Object, m_MockProcessManager.Object);
+
+            var sessionId = "session-compress";
+            var sessionIdProperty = typeof(CdbSession).GetProperty("SessionId", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Public);
+            sessionIdProperty!.SetValue(accessor, sessionId);
+
+            var getLogPathMethod = typeof(CdbSession).GetMethod("GetCdbSessionBasedLogPath", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
+            var logPath = (string)getLogPathMethod!.Invoke(accessor, new object[] { sessionId })!;
+
+            var logDirectory = Path.GetDirectoryName(logPath);
+            if (!string.IsNullOrEmpty(logDirectory))
+            {
+                _ = Directory.CreateDirectory(logDirectory);
+            }
+
+            const string logContent = "cdb log content";
+            File.WriteAllText(logPath, logContent);
+
+            // Act
+            await accessor.DisposeAsync();
+
+            // Assert
+            var compressedPath = $"{logPath}.gz";
+            _ = File.Exists(logPath).Should().BeFalse();
+            _ = File.Exists(compressedPath).Should().BeTrue();
+            var compressedFileInfo = new FileInfo(compressedPath);
+            _ = compressedFileInfo.Length.Should().BeGreaterThan(0);
+        }
+        finally
+        {
+            LogManager.Configuration = originalConfig;
+
+            if (Directory.Exists(tempRoot))
+            {
+                Directory.Delete(tempRoot, true);
+            }
+        }
+    }
 }