Defer and retry telemetry pipe attachment for GVFS.Service

GVFS.Service runs as SYSTEM and cannot read the user's global git
config (where gvfs.telemetry-pipe is set) at startup.  This meant
TelemetryDaemonEventListener was never created, and all service
telemetry events (PendingUpgradeHandler, etc.) were silently lost.

Add two new classes in GVFS.Common.Tracing:

- BufferingTelemetryListener: an EventListener that buffers telemetry
  messages in a bounded ConcurrentQueue, then replays them to a real
  listener on demand.

- DeferredTelemetryAttacher: manages the lifecycle of deferred
  telemetry pipe attachment.  Adds a BufferingTelemetryListener to
  the tracer, then periodically retries creating the real daemon
  listener (exponential backoff: 10s, 30s, 1m, 5m steady state).
  On success, replays buffered messages and stops the timer.
  Checks HasTelemetryDaemonListener to prevent duplicate listeners
  when the JsonTracer constructor already attached one.
  Designed for reuse by both GVFS.Service and GVFS.Mount.

TelemetryDaemonEventListener gains a globalConfigPath parameter so
callers can read a specific .gitconfig file via --file instead of
--global.  This lets GVFSService read the logged-on user's config
without mutating the process-wide HOME environment variable.

GVFSService creates a DeferredTelemetryAttacher at startup and calls
TryAttach on session logon events, passing the user's .gitconfig
path resolved via RunImpersonated.

JsonTracer gains only HasTelemetryDaemonListener (one-liner property)
to support the duplicate-listener guard.

Assisted-by: Claude Opus 4.6
Signed-off-by: Tyrie Vella <tyrielv@gmail.com>

Author: tyrielv

GVFS/GVFS.Common/NativeMethods.cs

@@ -247,6 +247,19 @@ private static extern bool DeviceIoControl(
         [DllImport("kernel32.dll")]
         private static extern ulong GetTickCount64();
 
+        [DllImport("kernel32.dll")]
+        private static extern int WTSGetActiveConsoleSessionId();
+
+        /// <summary>
+        /// Returns the session ID of the physical console session, or -1 if
+        /// no interactive session is active (e.g. at boot before logon).
+        /// </summary>
+        public static int GetActiveConsoleSessionId()
+        {
+            int sessionId = WTSGetActiveConsoleSessionId();
+            return sessionId == unchecked((int)0xFFFFFFFF) ? -1 : sessionId;
+        }
+
         [DllImport("kernel32.dll", SetLastError = true)]
         private static extern bool SetFileTime(
             SafeFileHandle hFile,

GVFS/GVFS.Common/Tracing/BufferingTelemetryListener.cs

@@ -0,0 +1,83 @@
+using System.Collections.Concurrent;
+
+namespace GVFS.Common.Tracing
+{
+    /// <summary>
+    /// An EventListener that buffers telemetry messages in memory.  After
+    /// a real listener is attached via <see cref="ReplayAndStop"/>, buffered
+    /// messages are replayed and this listener becomes a no-op.
+    /// </summary>
+    public class BufferingTelemetryListener : EventListener
+    {
+        public const int DefaultMaxBufferedMessages = 1000;
+
+        private ConcurrentQueue<TraceEventMessage> buffer = new ConcurrentQueue<TraceEventMessage>();
+        private readonly int maxBufferedMessages;
+        private volatile bool stopped;
+
+        public BufferingTelemetryListener(int maxBufferedMessages = DefaultMaxBufferedMessages)
+            : base(EventLevel.Verbose, Keywords.Telemetry, eventSink: null)
+        {
+            this.maxBufferedMessages = maxBufferedMessages;
+        }
+
+        /// <summary>
+        /// Number of messages currently buffered.
+        /// </summary>
+        public int BufferedCount => this.buffer?.Count ?? 0;
+
+        /// <summary>
+        /// Whether this listener has been stopped (replay completed).
+        /// </summary>
+        public bool IsStopped => this.stopped;
+
+        /// <summary>
+        /// Replays all buffered messages to <paramref name="target"/> and
+        /// stops further buffering.  This listener remains in the tracer's
+        /// listener list but becomes a no-op.  Safe to call multiple times;
+        /// only the first call replays.
+        /// </summary>
+        /// <returns>Number of messages replayed.</returns>
+        public int ReplayAndStop(EventListener target)
+        {
+            if (this.stopped)
+            {
+                return 0;
+            }
+
+            this.stopped = true;
+            ConcurrentQueue<TraceEventMessage> queue = this.buffer;
+            this.buffer = null;
+
+            int count = 0;
+            if (queue != null)
+            {
+                while (queue.TryDequeue(out TraceEventMessage message))
+                {
+                    target.RecordMessage(message);
+                    count++;
+                }
+            }
+
+            return count;
+        }
+
+        protected override void RecordMessageInternal(TraceEventMessage message)
+        {
+            if (this.stopped)
+            {
+                return;
+            }
+
+            // Soft cap: under high concurrency, a few messages may exceed
+            // maxBufferedMessages because Count and Enqueue are not atomic.
+            // This is acceptable — the cap prevents unbounded growth, and
+            // a small overshoot is harmless.
+            ConcurrentQueue<TraceEventMessage> queue = this.buffer;
+            if (queue != null && queue.Count < this.maxBufferedMessages)
+            {
+                queue.Enqueue(message);
+            }
+        }
+    }
+}

GVFS/GVFS.Common/Tracing/DeferredTelemetryAttacher.cs

@@ -0,0 +1,208 @@
+using System;
+using System.Threading;
+
+namespace GVFS.Common.Tracing
+{
+    /// <summary>
+    /// Manages deferred telemetry pipe attachment for processes that cannot
+    /// read the pipe config at startup (e.g. GVFS.Service running as SYSTEM,
+    /// or any process started before the telemetry collector is installed).
+    ///
+    /// Adds a <see cref="BufferingTelemetryListener"/> to the tracer at
+    /// construction time, then periodically retries creating a real
+    /// <see cref="TelemetryDaemonEventListener"/>.  On success, buffered
+    /// messages are replayed and the retry timer stops.
+    ///
+    /// Callers can also trigger an explicit attach attempt via
+    /// <see cref="TryAttach(string)"/> — e.g. on session logon when the
+    /// user's HOME is available.
+    ///
+    /// Designed for reuse by both GVFS.Service and GVFS.Mount.
+    /// </summary>
+    public class DeferredTelemetryAttacher : IDisposable
+    {
+        private readonly JsonTracer tracer;
+        private readonly BufferingTelemetryListener buffer;
+        private readonly string providerName;
+        private readonly string enlistmentId;
+        private readonly string mountId;
+        private readonly Lock attachLock = new Lock();
+
+        private Timer retryTimer;
+        private string retryGitBinRoot;
+        private int retryCount;
+        private bool attached;
+        private bool disposed;
+
+        public DeferredTelemetryAttacher(
+            JsonTracer tracer,
+            string providerName,
+            string enlistmentId,
+            string mountId)
+        {
+            this.tracer = tracer;
+            this.providerName = providerName;
+            this.enlistmentId = enlistmentId;
+            this.mountId = mountId;
+            this.buffer = new BufferingTelemetryListener();
+            tracer.AddEventListener(this.buffer);
+        }
+
+        public bool IsAttached
+        {
+            get
+            {
+                lock (this.attachLock)
+                {
+                    return this.attached;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Starts a background retry timer that periodically calls
+        /// <see cref="TryAttach"/> with the given gitBinRoot.  Uses
+        /// exponential backoff: 10s, 30s, 1m, then 5m steady state.
+        /// </summary>
+        public void StartRetryTimer(string gitBinRoot)
+        {
+            lock (this.attachLock)
+            {
+                if (this.attached || this.disposed || this.retryTimer != null)
+                {
+                    return;
+                }
+
+                this.retryGitBinRoot = gitBinRoot;
+                this.retryCount = 0;
+                this.retryTimer = new Timer(
+                    this.OnRetryTimer,
+                    null,
+                    GetRetryInterval(0),
+                    Timeout.Infinite);
+            }
+        }
+
+        /// <summary>
+        /// Attempts to create and attach a TelemetryDaemonEventListener.
+        /// Call this when environment conditions change (e.g. user session
+        /// becomes available).  Replays buffered messages on success.
+        /// Safe to call multiple times — no-ops after first successful attach.
+        /// </summary>
+        /// <param name="gitBinRoot">Path to git binary.</param>
+        /// <param name="globalConfigPath">
+        /// If non-null, reads this file with <c>git config --file</c> instead
+        /// of <c>--global</c>.  Use this when the caller needs to read another
+        /// user's .gitconfig without mutating the process-wide HOME variable.
+        /// </param>
+        /// <returns>true if attached (now or previously).</returns>
+        public bool TryAttach(string gitBinRoot, string globalConfigPath = null)
+        {
+            lock (this.attachLock)
+            {
+                if (this.attached || this.tracer.HasTelemetryDaemonListener)
+                {
+                    return true;
+                }
+
+                if (string.IsNullOrEmpty(gitBinRoot))
+                {
+                    return false;
+                }
+
+                TelemetryDaemonEventListener daemonListener;
+                try
+                {
+                    daemonListener = TelemetryDaemonEventListener.CreateIfEnabled(
+                        gitBinRoot,
+                        this.providerName,
+                        this.enlistmentId,
+                        this.mountId,
+                        this.tracer,
+                        globalConfigPath);
+                }
+                catch (Exception)
+                {
+                    return false;
+                }
+
+                if (daemonListener == null)
+                {
+                    return false;
+                }
+
+                this.tracer.AddEventListener(daemonListener);
+                int replayed = this.buffer.ReplayAndStop(daemonListener);
+                this.StopRetryTimer();
+                this.attached = true;
+
+                this.tracer.RelatedInfo(
+                    "DeferredTelemetryAttacher: Attached, replayed {0} buffered messages",
+                    replayed);
+
+                return true;
+            }
+        }
+
+        public void Dispose()
+        {
+            lock (this.attachLock)
+            {
+                if (this.disposed)
+                {
+                    return;
+                }
+
+                this.disposed = true;
+                this.StopRetryTimer();
+            }
+        }
+
+        internal static int GetRetryInterval(int retryCount)
+        {
+            return retryCount switch
+            {
+                0 => 10_000,      // 10 seconds
+                1 => 30_000,      // 30 seconds
+                2 => 60_000,      // 1 minute
+                _ => 300_000,     // 5 minutes
+            };
+        }
+
+        private void StopRetryTimer()
+        {
+            // Must be called while holding attachLock
+            if (this.retryTimer != null)
+            {
+                this.retryTimer.Dispose();
+                this.retryTimer = null;
+            }
+        }
+
+        private void OnRetryTimer(object state)
+        {
+            try
+            {
+                bool success = this.TryAttach(this.retryGitBinRoot);
+                if (!success)
+                {
+                    lock (this.attachLock)
+                    {
+                        if (this.retryTimer != null && !this.disposed)
+                        {
+                            this.retryCount++;
+                            this.retryTimer.Change(
+                                GetRetryInterval(this.retryCount),
+                                Timeout.Infinite);
+                        }
+                    }
+                }
+            }
+            catch (Exception)
+            {
+                // Swallow — timer will not reschedule, but the explicit
+                // TryAttach path (e.g. on SessionLogon) can still succeed.
+            }
+        }
+    }
+}

GVFS/GVFS.Common/Tracing/JsonTracer.cs

@@ -81,6 +81,14 @@ public bool HasLogFileEventListener
             }
         }
 
+        public bool HasTelemetryDaemonListener
+        {
+            get
+            {
+                return this.listeners.Any(listener => listener is TelemetryDaemonEventListener);
+            }
+        }
+
         public void SetGitCommandSessionId(string sessionId)
         {
             TelemetryDaemonEventListener daemonListener = this.listeners.FirstOrDefault(x => x is TelemetryDaemonEventListener) as TelemetryDaemonEventListener;

GVFS/GVFS.Common/Tracing/TelemetryDaemonEventListener.cs

@@ -37,9 +37,22 @@ private TelemetryDaemonEventListener(
         public string GitCommandSessionId { get; set; }
 
         public static TelemetryDaemonEventListener CreateIfEnabled(string gitBinRoot, string providerName, string enlistmentId, string mountId, IEventListenerEventSink eventSink)
+        {
+            return CreateIfEnabled(gitBinRoot, providerName, enlistmentId, mountId, eventSink, globalConfigPath: null);
+        }
+
+        /// <summary>
+        /// Creates a TelemetryDaemonEventListener if the telemetry pipe config
+        /// is set.  When <paramref name="globalConfigPath"/> is provided, reads
+        /// that file directly instead of using <c>git config --global</c>.
+        /// This avoids mutating the process-wide HOME environment variable
+        /// when the caller needs to read another user's config (e.g.
+        /// GVFS.Service reading the logged-on user's .gitconfig).
+        /// </summary>
+        public static TelemetryDaemonEventListener CreateIfEnabled(string gitBinRoot, string providerName, string enlistmentId, string mountId, IEventListenerEventSink eventSink, string globalConfigPath)
         {
             // This listener is disabled unless the user specifies the proper git config setting.
-            string telemetryPipe = GetConfigValue(gitBinRoot, GVFSConstants.GitConfig.GVFSTelemetryPipe);
+            string telemetryPipe = GetConfigValue(gitBinRoot, GVFSConstants.GitConfig.GVFSTelemetryPipe, globalConfigPath);
             if (!string.IsNullOrEmpty(telemetryPipe))
             {
                 return new TelemetryDaemonEventListener(providerName, enlistmentId, mountId, telemetryPipe, eventSink);
@@ -90,15 +103,23 @@ protected override void RecordMessageInternal(TraceEventMessage message)
             }
         }
 
-        private static string GetConfigValue(string gitBinRoot, string configKey)
+        private static string GetConfigValue(string gitBinRoot, string configKey, string globalConfigPath = null)
         {
             string value = string.Empty;
             string error;
 
             GitProcess.ConfigResult result = GitProcess.GetFromSystemConfig(gitBinRoot, configKey);
             if (!result.TryParseAsString(out value, out error, defaultValue: string.Empty) || string.IsNullOrWhiteSpace(value))
             {
-                result = GitProcess.GetFromGlobalConfig(gitBinRoot, configKey);
+                if (!string.IsNullOrEmpty(globalConfigPath))
+                {
+                    result = GitProcess.GetFromFileConfig(gitBinRoot, globalConfigPath, configKey);
+                }
+                else
+                {
+                    result = GitProcess.GetFromGlobalConfig(gitBinRoot, configKey);
+                }
+
                 result.TryParseAsString(out value, out error, defaultValue: string.Empty);
             }