refactor(audience-sdk): consolidate timing/retry constants in Constants.cs

The previous SSOT pass left twelve timing / retry constants co-located
with their owning module: HttpTransport.RequestTimeoutSeconds and
five Backoff*Ms constants, Session.HeartbeatIntervalMs / PauseTimeoutMs
/ HeartbeatDrainTimeoutMs / StartDrainTimeoutMs, and ImmutableAudience.
ConsentSyncMaxAttempts / ConsentSyncBaseRetryMs. Constants.cs already
held analogous timing / sizing knobs (DefaultFlushIntervalSeconds,
MaxBatchSize, ControlPlaneRequestTimeoutSeconds), so the split was
inconsistent.

Move all twelve into Constants.cs with module-prefixed names
(MessagesRequestTimeoutSeconds, HttpBackoff{1st,2nd,3rd,4th,Cap}Ms,
SessionHeartbeatIntervalMs, SessionPauseTimeoutMs,
SessionHeartbeatDrainTimeoutMs, SessionStartDrainTimeoutMs,
ConsentSyncMaxAttempts, ConsentSyncBaseRetryMs). Migrate runtime call
sites in HttpTransport, Session, and ImmutableAudience plus the one
test reference in SessionTests. Behaviour unchanged.

Follow-up to SDK-272 (centralisation of duplicated literals).

Author: ImmutableJeffrey

src/Packages/Audience/Runtime/Core/Constants.cs

@@ -25,6 +25,35 @@ internal static class Constants
         internal const string RoundTripNumberFormat = "R";
         internal const int ControlPlaneRequestTimeoutSeconds = 30;
 
+        // How long we wait for one POST before giving up.
+        // Without this, one stuck request can block everything else.
+        internal const int MessagesRequestTimeoutSeconds = 30;
+
+        // How long we wait before retrying after a failed POST. Doubles each time.
+        internal const int HttpBackoff1stMs = 5_000;
+        internal const int HttpBackoff2ndMs = 10_000;
+        internal const int HttpBackoff3rdMs = 20_000;
+        internal const int HttpBackoff4thMs = 40_000;
+        internal const int HttpBackoffCapMs = 60_000;
+
+        // How often a session_heartbeat is emitted while a session is live.
+        internal const int SessionHeartbeatIntervalMs = 60_000;
+
+        // How long a paused session can stay paused before Resume rolls it.
+        internal const int SessionPauseTimeoutMs = 30_000;
+
+        // How long we wait for an in-flight heartbeat callback to finish during teardown.
+        internal const int SessionHeartbeatDrainTimeoutMs = 1_000;
+
+        // How long we wait for the previous heartbeat to clear when Start is called twice.
+        internal const int SessionStartDrainTimeoutMs = 500;
+
+        // How many times we retry the consent-sync PUT after a 429.
+        internal const int ConsentSyncMaxAttempts = 4;
+
+        // How long we wait before the first consent-sync retry. Doubles each time.
+        internal const int ConsentSyncBaseRetryMs = 1_000;
+
         internal const string LibraryName = "com.immutable.audience";
         internal const string LibraryVersion = "0.1.0";
         internal const string Surface = "unity";

src/Packages/Audience/Runtime/Core/Session.cs

@@ -23,17 +23,6 @@ namespace Immutable.Audience
     // any thread.
     internal sealed class Session : IDisposable
     {
-        internal const int HeartbeatIntervalMs = 60_000;
-
-        // 30s: alt-tab beyond this rolls the session on Resume.
-        internal const int PauseTimeoutMs = 30_000;
-
-        // How long we wait for an in-flight heartbeat callback to finish during teardown.
-        internal const int HeartbeatDrainTimeoutMs = 1_000;
-
-        // How long we wait for the previous heartbeat to clear when Start is called twice.
-        internal const int StartDrainTimeoutMs = 500;
-
         private readonly TrackDelegate _track;
         private readonly Func<DateTime> _getUtcNow;
         private readonly int _heartbeatIntervalMs;
@@ -57,7 +46,7 @@ internal string? SessionId
         internal Session(
             TrackDelegate track,
             Func<DateTime>? getUtcNow = null,
-            int heartbeatIntervalMs = HeartbeatIntervalMs)
+            int heartbeatIntervalMs = Constants.SessionHeartbeatIntervalMs)
         {
             _track = track ?? throw new ArgumentNullException(nameof(track));
             _getUtcNow = getUtcNow ?? (() => DateTime.UtcNow);
@@ -83,8 +72,8 @@ internal void Start()
                 }
             }
 
-            // Double-Start is a misuse path; StartDrainTimeoutMs caps the wait.
-            TimerDisposal.DisposeAndWait(oldTimer, TimeSpan.FromMilliseconds(StartDrainTimeoutMs));
+            // Cap the wait so a misuse Start-twice path doesn't hang.
+            TimerDisposal.DisposeAndWait(oldTimer, TimeSpan.FromMilliseconds(Constants.SessionStartDrainTimeoutMs));
 
             // Phase 2: populate new state. Re-check _disposed (may have flipped during drain).
             string sessionId;
@@ -139,7 +128,7 @@ internal void Resume()
                 // Clamp: wall-clock rewind (NTP) would otherwise over-credit engagement.
                 if (pauseDuration < TimeSpan.Zero) pauseDuration = TimeSpan.Zero;
 
-                extended = pauseDuration.TotalMilliseconds > PauseTimeoutMs;
+                extended = pauseDuration.TotalMilliseconds > Constants.SessionPauseTimeoutMs;
 
                 // Credit in both paths. End (and then Start) reset the accumulator
                 // on the extended-pause rollover so there is no double-count.
@@ -270,8 +259,7 @@ private void SafeTrack(string eventName, Dictionary<string, object> properties)
         }
 
         // Stops the timer and waits for the in-flight callback. Runs outside
-        // _lock (OnHeartbeat re-enters). HeartbeatDrainTimeoutMs caps the
-        // wait so quits don't hang. Warns on timeout.
+        // Cap the wait so quits don't hang on a re-entrant heartbeat.
         private void DrainHeartbeatTimer()
         {
             Timer? timer;
@@ -282,7 +270,7 @@ private void DrainHeartbeatTimer()
             }
             if (timer == null) return;
 
-            if (!TimerDisposal.DisposeAndWait(timer, TimeSpan.FromMilliseconds(HeartbeatDrainTimeoutMs)))
+            if (!TimerDisposal.DisposeAndWait(timer, TimeSpan.FromMilliseconds(Constants.SessionHeartbeatDrainTimeoutMs)))
             {
                 Log.Warn(AudienceLogs.SessionHeartbeatTimeout);
             }

src/Packages/Audience/Runtime/ImmutableAudience.cs

@@ -27,12 +27,6 @@ public static class ImmutableAudience
         // teardown (Session.Dispose, timer drain, queue shutdown, transport
         // flush, disposes). This keeps the hold time to nanoseconds so a caller
         // arriving on a different thread is not stranded behind those budgets.
-        // How many times we retry the consent-sync PUT after a 429.
-        internal const int ConsentSyncMaxAttempts = 4;
-
-        // How long we wait before the first consent-sync retry. Doubles each time.
-        internal const int ConsentSyncBaseRetryMs = 1_000;
-
         private static AudienceConfig? _config;
         private static DiskStore? _store;
         private static EventQueue? _queue;
@@ -631,9 +625,8 @@ private static void SyncConsentToBackend(AudienceConfig config, ConsentLevel lev
 
             Task.Run(async () =>
             {
-                // 429 retried up to ConsentSyncMaxAttempts attempts (1s/2s/4s
-                // or Retry-After). Other non-2xx fail fast.
-                const int maxAttempts = ConsentSyncMaxAttempts;
+                // 429 retries up to Constants.ConsentSyncMaxAttempts; other non-2xx fail fast.
+                const int maxAttempts = Constants.ConsentSyncMaxAttempts;
                 var attempt = 0;
                 try
                 {
@@ -650,7 +643,7 @@ private static void SyncConsentToBackend(AudienceConfig config, ConsentLevel lev
                         if (response.StatusCode == HttpStatusCode.TooManyRequests && attempt < maxAttempts)
                         {
                             var delay = HttpRetry.ParseRetryAfter(response)
-                                ?? TimeSpan.FromMilliseconds(ConsentSyncBaseRetryMs * (1 << (attempt - 1)));
+                                ?? TimeSpan.FromMilliseconds(Constants.ConsentSyncBaseRetryMs * (1 << (attempt - 1)));
                             await Task.Delay(delay, cancellationToken).ConfigureAwait(false);
                             continue;
                         }

src/Packages/Audience/Runtime/Transport/HttpTransport.cs

@@ -15,17 +15,6 @@ namespace Immutable.Audience
     // Sends queued events from DiskStore to the Audience backend.
     internal sealed class HttpTransport : IDisposable
     {
-        // How long we wait for one POST before giving up.
-        // Without this, one stuck request can block everything else.
-        internal const int RequestTimeoutSeconds = 30;
-
-        // How long we wait before retrying after a failed POST. Doubles each time.
-        internal const int Backoff1stMs = 5_000;
-        internal const int Backoff2ndMs = 10_000;
-        internal const int Backoff3rdMs = 20_000;
-        internal const int Backoff4thMs = 40_000;
-        internal const int BackoffCapMs = 60_000;
-
         private readonly DiskStore _store;
         private readonly string _url;
         private readonly string _publishableKey;
@@ -59,7 +48,7 @@ internal HttpTransport(
             _client = handler != null
                 ? new HttpClient(handler, disposeHandler: false)
                 : new HttpClient();
-            _client.Timeout = TimeSpan.FromSeconds(RequestTimeoutSeconds);
+            _client.Timeout = TimeSpan.FromSeconds(Constants.MessagesRequestTimeoutSeconds);
             _getUtcNow = getUtcNow ?? (() => DateTime.UtcNow);
         }
 
@@ -193,11 +182,11 @@ internal int BackoffMs
         private int BackoffMsLocked() => _consecutiveFailures switch
         {
             <= 0 => 0,
-            1 => Backoff1stMs,
-            2 => Backoff2ndMs,
-            3 => Backoff3rdMs,
-            4 => Backoff4thMs,
-            _ => BackoffCapMs,
+            1 => Constants.HttpBackoff1stMs,
+            2 => Constants.HttpBackoff2ndMs,
+            3 => Constants.HttpBackoff3rdMs,
+            4 => Constants.HttpBackoff4thMs,
+            _ => Constants.HttpBackoffCapMs,
         };
 
         // Earliest UTC time at which the next attempt may run.

src/Packages/Audience/Tests/Runtime/Core/SessionTests.cs

@@ -158,11 +158,11 @@ public void Pause_ThenResume_LongPause_StartsNewSession()
             var id1 = session.SessionId;
 
             session.Pause();
-            now = now.AddMilliseconds(Session.PauseTimeoutMs + 1000);
+            now = now.AddMilliseconds(Constants.SessionPauseTimeoutMs + 1000);
             session.Resume();
 
             Assert.AreNotEqual(id1, session.SessionId,
-                "pause longer than PauseTimeoutMs should end the old session and start a new one");
+                "pause longer than SessionPauseTimeoutMs should end the old session and start a new one");
             Assert.IsTrue(_events.Any(e => e.name == EventNames.SessionEnd),
                 "old session should have fired session_end");
             Assert.AreEqual(2, _events.Count(e => e.name == EventNames.SessionStart),