fix: make PagingLogger IDisposable to prevent partial log loss on step fault

Steps that throw before Complete() never reach End(), silently dropping
their partial page and results block. Make IPagingLogger : IDisposable
and implement Dispose() (canonical pattern, idempotent, never throws)
to flush+queue partial content and release the FileStream on any exit.

Author: herbenderbler

src/Runner.Common/Logging.cs

@@ -4,7 +4,7 @@
 namespace GitHub.Runner.Common
 {
     [ServiceLocator(Default = typeof(PagingLogger))]
-    public interface IPagingLogger : IRunnerService
+    public interface IPagingLogger : IRunnerService, IDisposable
     {
         long TotalLines { get; }
         void Setup(Guid timelineId, Guid timelineRecordId);
@@ -45,6 +45,8 @@ public class PagingLogger : RunnerService, IPagingLogger
         private int _blockByteCount;
         private int _blockCount;
 
+        private bool _disposed;
+
         public long TotalLines => _totalLines;
 
         public override void Initialize(IHostContext hostContext)
@@ -164,5 +166,75 @@ private void EndBlock(bool finalize)
                 _jobServerQueue.QueueResultsUpload(_timelineRecordId, "ResultsLog", _resultsDataFileName, "Results.Core.Log", deleteSource: true, finalize, firstBlock: _resultsDataFileName.EndsWith(".1"), totalLines: _totalLines);
             }
         }
+
+        // Close any page/block writers that were opened by Write() but never
+        // finalized by End() - for example when the owning step throws between
+        // Setup() and End(). Prior to this being IDisposable, such a throw left
+        // the FileStream handles open until GC finalization eventually ran, and
+        // - more importantly - silently dropped the partial page's content:
+        // QueueFileUpload/QueueResultsUpload are only invoked from EndPage /
+        // EndBlock, so any partial page on a faulted step was never shipped to
+        // the server-side log. On long-running self-hosted runners this also
+        // adds pressure on the per-process file descriptor quota (the runner's
+        // systemd template inherits systemd's DefaultLimitNOFILE, which ranges
+        // from 1024 on older distros to 524288+ on modern systemd >= 240).
+        //
+        // Dispose is best-effort and must not throw, because it also runs from
+        // service-shutdown paths. We still try to flush+upload partial content
+        // so no log data is silently dropped; failures there are swallowed.
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            if (disposing)
+            {
+                // Try the normal flush+queue path first. If it throws (e.g. the
+                // JobServerQueue is already shutting down) we fall through to the
+                // safety-net cleanup below.
+                try { EndPage(); } catch { }
+
+                // Safety net: EndPage early-returns when _pageWriter is null, so
+                // it does not cover the case where the StreamWriter ctor in
+                // NewPage threw after the FileStream was opened (leaving
+                // _pageData non-null with _pageWriter null). Always release any
+                // remaining handle so the fd is returned to the OS.
+                if (_pageWriter != null)
+                {
+                    try { _pageWriter.Dispose(); } catch { }
+                    _pageWriter = null;
+                    _pageData = null;
+                }
+                else if (_pageData != null)
+                {
+                    try { _pageData.Dispose(); } catch { }
+                    _pageData = null;
+                }
+
+                try { EndBlock(finalize: true); } catch { }
+
+                if (_resultsBlockWriter != null)
+                {
+                    try { _resultsBlockWriter.Dispose(); } catch { }
+                    _resultsBlockWriter = null;
+                    _resultsBlockData = null;
+                }
+                else if (_resultsBlockData != null)
+                {
+                    try { _resultsBlockData.Dispose(); } catch { }
+                    _resultsBlockData = null;
+                }
+            }
+
+            _disposed = true;
+        }
     }
 }