refactor(audience-sdk): centralise log message text in AudienceLogs (SDK-272)

ImmutableJeffrey · claude · ImmutableJeffrey · commit f3121cb7a20d · 2026-05-01T16:16:17.000+10:00
Adds an internal AudienceLogs class in Runtime/Utility/Log.cs as the
single source of truth for runtime log message strings. Runtime
callers in ImmutableAudience.cs, Session.cs, and HttpTransport.cs now
read from AudienceLogs constants and methods instead of inline
literals, and the test assertions read from the same place so
wording changes touch one file.

- Every Log.Warn / Log.Debug call site across ImmutableAudience,
  Session, and HttpTransport migrated.
- Test assertions in ImmutableAudienceTests, PublishableKeyPrefixTests,
  and SessionTests now reference AudienceLogs constants directly.
- HttpTransport.NotifyError and ImmutableAudience.NotifyErrorCallback
  now share the OnErrorThrew template; HttpTransport's prior wording
  carried an incidental underscore (_onError) from the field name and
  is dropped during the migration. Both situations are "the
  consumer's error handler threw inside our notify path" so they read
  from one constant.
- Three negative-path tests in PublishableKeyPrefixTests previously
  asserted that no key-mismatch warning fired by checking lines for
  the substring "BaseUrl". The substring is incidental to the message
  wording; an unrelated future log line that mentions "BaseUrl" would
  silently trip the test. Switched to assert against the actual
  AudienceLogs.TestKeyAgainstProduction and
  AudienceLogs.NonTestKeyAgainstSandbox constants.

The class lives alongside Log in Log.cs (rather than its own file)
to keep the Audience runtime package's asset import surface
unchanged, since adding a fresh .cs/.meta pair triggered a Win64 +
Unity 6 PlayMode timing flake during sample-app UI Toolkit init on
this PR.

No code behaviour changes; wire format and OnError contract are
untouched. dotnet test passes.

Co-Authored-By: Claude Opus 4.7 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/src/Packages/Audience/Runtime/Core/Session.cs b/src/Packages/Audience/Runtime/Core/Session.cs
@@ -112,7 +112,7 @@ internal void Pause()
                 // when End fires while paused), over-crediting engagement.
                 if (_pausedAt.HasValue)
                 {
-                    Log.Debug("Session: Pause while already paused. Ignoring.");
+                    Log.Debug(AudienceLogs.SessionPauseAlreadyPaused);
                     return;
                 }
                 _pausedAt = _getUtcNow();
@@ -259,7 +259,7 @@ private void SafeTrack(string eventName, Dictionary<string, object> properties)
             }
             catch (Exception ex)
             {
-                Log.Warn($"Session: {eventName} track callback threw {ex.GetType().Name}. Event dropped.");
+                Log.Warn(AudienceLogs.SessionTrackCallbackThrew(eventName, ex));
             }
         }
 
@@ -277,8 +277,7 @@ private void DrainHeartbeatTimer()
 
             if (!TimerDisposal.DisposeAndWait(timer, TimeSpan.FromSeconds(1)))
             {
-                Log.Warn("Session: heartbeat callback did not complete within 1s on timer stop. " +
-                         "A trailing session_heartbeat may race with the next session lifecycle event.");
+                Log.Warn(AudienceLogs.SessionHeartbeatTimeout);
             }
         }
 
diff --git a/src/Packages/Audience/Runtime/ImmutableAudience.cs b/src/Packages/Audience/Runtime/ImmutableAudience.cs
@@ -159,8 +159,7 @@ public static void Init(AudienceConfig config)
             {
                 if (_initialized)
                 {
-                    Log.Warn("Init called more than once. Ignoring; original config retained. " +
-                             "Call Shutdown() first if reconfiguring is intended.");
+                    Log.Warn(AudienceLogs.InitCalledTwice);
                     return;
                 }
 
@@ -237,7 +236,7 @@ public static void Track(IEvent evt)
             if (!_initialized || !state.Level.CanTrack()) return;
             if (evt == null)
             {
-                Log.Warn("Track(IEvent) called with null event. Dropping.");
+                Log.Warn(AudienceLogs.TrackIEventNull);
                 return;
             }
 
@@ -254,13 +253,13 @@ public static void Track(IEvent evt)
             }
             catch (Exception ex)
             {
-                Log.Warn($"Track(IEvent): {evt.GetType().Name}.ToProperties()/EventName threw {ex.GetType().Name}: {ex.Message}. Dropping.");
+                Log.Warn(AudienceLogs.TrackIEventThrew(evt.GetType().Name, ex));
                 return;
             }
 
             if (string.IsNullOrEmpty(eventName))
             {
-                Log.Warn($"Track(IEvent): {evt.GetType().Name}.EventName returned null or empty. Dropping.");
+                Log.Warn(AudienceLogs.TrackIEventEmptyName(evt.GetType().Name));
                 return;
             }
 
@@ -284,7 +283,7 @@ public static void Track(string eventName, Dictionary<string, object>? propertie
             if (!_initialized || !state.Level.CanTrack()) return;
             if (string.IsNullOrEmpty(eventName))
             {
-                Log.Warn("Track(string) called with null or empty event name. Dropping.");
+                Log.Warn(AudienceLogs.TrackStringEmptyName);
                 return;
             }
 
@@ -315,7 +314,7 @@ public static void Identify(string userId, IdentityType identityType, Dictionary
             // Validate inputs before consent so null-arg callers get the right warning.
             if (string.IsNullOrEmpty(userId))
             {
-                Log.Warn("Identify called with null or empty userId. Dropping.");
+                Log.Warn(AudienceLogs.IdentifyEmptyUserId);
                 return;
             }
 
@@ -330,7 +329,7 @@ public static void Identify(string userId, IdentityType identityType, Dictionary
                 level = current.Level;
                 if (!level.CanIdentify())
                 {
-                    Log.Warn($"Identify discarded. Requires Full consent, current is {level}.");
+                    Log.Warn(AudienceLogs.IdentifyDiscarded(level));
                     return;
                 }
                 config = _config;
@@ -357,13 +356,13 @@ public static void Alias(string fromId, IdentityType fromType, string toId, Iden
 
             if (string.IsNullOrEmpty(fromId) || string.IsNullOrEmpty(toId))
             {
-                Log.Warn("Alias called with null or empty fromId/toId. Dropping.");
+                Log.Warn(AudienceLogs.AliasEmptyIds);
                 return;
             }
             var state = _state;
             if (!state.Level.CanIdentify())
             {
-                Log.Warn($"Alias discarded. Requires Full consent, current is {state.Level}.");
+                Log.Warn(AudienceLogs.AliasDiscarded(state.Level));
                 return;
             }
 
@@ -486,7 +485,7 @@ private static void NotifyErrorCallback(Action<AudienceError>? onError, Audience
             }
             catch (Exception ex)
             {
-                Log.Warn($"onError threw {ex.GetType().Name}: {ex.Message}");
+                Log.Warn(AudienceLogs.OnErrorThrew(ex));
             }
         }
 
@@ -579,8 +578,7 @@ public static void SetConsent(ConsentLevel level)
             }
             catch (Exception ex) when (ex is IOException || ex is UnauthorizedAccessException)
             {
-                Log.Warn($"SetConsent: failed to persist consent level. {ex.GetType().Name}: {ex.Message}. " +
-                         "In-memory level is updated but will revert on next launch.");
+                Log.Warn(AudienceLogs.ConsentPersistFailed(ex));
                 NotifyErrorCallback(config.OnError, AudienceErrorCode.ConsentPersistFailed,
                     $"Consent persist failed: {ex.Message}");
             }
@@ -802,13 +800,12 @@ public static void Shutdown()
                     var send = transport.SendBatchAsync();
                     if (!send.Wait(timeoutMs))
                     {
-                        Log.Warn($"Shutdown flush exceeded {timeoutMs}ms. Abandoning. " +
-                                 "Queued events remain on disk and will retry on next startup.");
+                        Log.Warn(AudienceLogs.ShutdownFlushExceeded(timeoutMs));
                     }
                 }
                 catch (Exception ex)
                 {
-                    Log.Warn($"Shutdown flush threw: {ex.GetType().Name}: {ex.Message}");
+                    Log.Warn(AudienceLogs.ShutdownFlushThrew(ex));
                 }
             }
 
@@ -870,17 +867,11 @@ private static void WarnIfKeyEnvironmentMismatch(string publishableKey, string?
 
             if (isTestKey && trimmed == Constants.ProductionBaseUrl)
             {
-                Log.Warn(
-                    $"Publishable key has the test prefix ({Constants.TestKeyPrefix}) but BaseUrl points to production. " +
-                    "The backend will reject events with 401. Either remove the BaseUrl override (test keys " +
-                    "default to sandbox) or use a non-test publishable key.");
+                Log.Warn(AudienceLogs.TestKeyAgainstProduction);
             }
             else if (!isTestKey && trimmed == Constants.SandboxBaseUrl)
             {
-                Log.Warn(
-                    "Publishable key is not a test key but BaseUrl points to sandbox. " +
-                    "The backend will reject events with 401. Either remove the BaseUrl override (non-test " +
-                    $"keys default to production) or use a test publishable key ({Constants.TestKeyPrefix}).");
+                Log.Warn(AudienceLogs.NonTestKeyAgainstSandbox);
             }
         }
 
@@ -922,8 +913,7 @@ private static void MergeUnityContext(Dictionary<string, object>? msg)
             }
             catch (Exception ex)
             {
-                Log.Warn($"ContextProvider threw {ex.GetType().Name}: {ex.Message}. " +
-                         "Event ships with base context only.");
+                Log.Warn(AudienceLogs.ContextProviderThrew(ex));
                 return;
             }
             if (extra == null) return;
@@ -959,7 +949,7 @@ private static void SendBatch()
                     catch (Exception ex)
                     {
                         // Timer-thread callback; no caller above to catch.
-                        Log.Warn($"SendBatch unexpected exception: {ex.GetType().Name}: {ex.Message}");
+                        Log.Warn(AudienceLogs.SendBatchUnexpected(ex));
                     }
                 }
 
@@ -1007,8 +997,7 @@ private static void FireGameLaunch(AudienceConfig config, ConsentLevel consentAt
                 try { unityContext = provider(); }
                 catch (Exception ex)
                 {
-                    Log.Warn($"LaunchContextProvider threw {ex.GetType().Name}: {ex.Message}. " +
-                             "game_launch will ship without auto-detected Unity context.");
+                    Log.Warn(AudienceLogs.LaunchContextProviderThrew(ex));
                 }
 
                 if (unityContext != null)
diff --git a/src/Packages/Audience/Runtime/Transport/HttpTransport.cs b/src/Packages/Audience/Runtime/Transport/HttpTransport.cs
@@ -288,7 +288,7 @@ private static async Task<int> ParseRejectedCount(HttpResponseMessage response,
             }
             catch (Exception ex)
             {
-                Log.Warn($"ParseRejectedCount threw {ex.GetType().Name}: {ex.Message}");
+                Log.Warn(AudienceLogs.ParseRejectedCountThrew(ex));
                 return 0;
             }
             if (string.IsNullOrEmpty(body)) return 0;
@@ -339,7 +339,7 @@ private void NotifyError(AudienceErrorCode code, string message)
             }
             catch (Exception ex)
             {
-                Log.Warn($"_onError threw {ex.GetType().Name}: {ex.Message}");
+                Log.Warn(AudienceLogs.OnErrorThrew(ex));
             }
         }
     }
diff --git a/src/Packages/Audience/Runtime/Utility/Log.cs b/src/Packages/Audience/Runtime/Utility/Log.cs
@@ -42,4 +42,99 @@ private static void Emit(string line)
             }
         }
     }
+
+    internal static class AudienceLogs
+    {
+        // ---- Init / config validation ----
+
+        internal const string InitCalledTwice =
+            "Init called more than once. Ignoring; original config retained. " +
+            "Call Shutdown() first if reconfiguring is intended.";
+
+        internal static readonly string TestKeyAgainstProduction =
+            $"Publishable key has the test prefix ({Constants.TestKeyPrefix}) but BaseUrl points to production. " +
+            "The backend will reject events with 401. Either remove the BaseUrl override (test keys " +
+            "default to sandbox) or use a non-test publishable key.";
+
+        internal static readonly string NonTestKeyAgainstSandbox =
+            "Publishable key is not a test key but BaseUrl points to sandbox. " +
+            "The backend will reject events with 401. Either remove the BaseUrl override (non-test " +
+            $"keys default to production) or use a test publishable key ({Constants.TestKeyPrefix}).";
+
+        // ---- Track ----
+
+        internal const string TrackIEventNull =
+            "Track(IEvent) called with null event. Dropping.";
+
+        internal const string TrackStringEmptyName =
+            "Track(string) called with null or empty event name. Dropping.";
+
+        internal static string TrackIEventThrew(string evtTypeName, Exception ex) =>
+            $"Track(IEvent): {evtTypeName}.ToProperties()/EventName threw {ex.GetType().Name}: {ex.Message}. Dropping.";
+
+        internal static string TrackIEventEmptyName(string evtTypeName) =>
+            $"Track(IEvent): {evtTypeName}.EventName returned null or empty. Dropping.";
+
+        // ---- Identify / Alias ----
+
+        internal const string IdentifyEmptyUserId =
+            "Identify called with null or empty userId. Dropping.";
+
+        internal const string AliasEmptyIds =
+            "Alias called with null or empty fromId/toId. Dropping.";
+
+        internal static string IdentifyDiscarded(ConsentLevel current) =>
+            $"Identify discarded. Requires Full consent, current is {current}.";
+
+        internal static string AliasDiscarded(ConsentLevel current) =>
+            $"Alias discarded. Requires Full consent, current is {current}.";
+
+        // ---- Consent / Shutdown ----
+
+        internal static string ConsentPersistFailed(Exception ex) =>
+            $"SetConsent: failed to persist consent level. {ex.GetType().Name}: {ex.Message}. " +
+            "In-memory level is updated but will revert on next launch.";
+
+        internal static string ShutdownFlushExceeded(int timeoutMs) =>
+            $"Shutdown flush exceeded {timeoutMs}ms. Abandoning. " +
+            "Queued events remain on disk and will retry on next startup.";
+
+        internal static string ShutdownFlushThrew(Exception ex) =>
+            $"Shutdown flush threw: {ex.GetType().Name}: {ex.Message}";
+
+        // ---- onError handler swallow ----
+
+        internal static string OnErrorThrew(Exception ex) =>
+            $"onError threw {ex.GetType().Name}: {ex.Message}";
+
+        // ---- Send loop ----
+
+        internal static string SendBatchUnexpected(Exception ex) =>
+            $"SendBatch unexpected exception: {ex.GetType().Name}: {ex.Message}";
+
+        internal static string ParseRejectedCountThrew(Exception ex) =>
+            $"ParseRejectedCount threw {ex.GetType().Name}: {ex.Message}";
+
+        // ---- Session ----
+
+        internal const string SessionPauseAlreadyPaused =
+            "Session: Pause while already paused. Ignoring.";
+
+        internal const string SessionHeartbeatTimeout =
+            "Session: heartbeat callback did not complete within 1s on timer stop. " +
+            "A trailing session_heartbeat may race with the next session lifecycle event.";
+
+        internal static string SessionTrackCallbackThrew(string eventName, Exception ex) =>
+            $"Session: {eventName} track callback threw {ex.GetType().Name}. Event dropped.";
+
+        // ---- Context providers ----
+
+        internal static string ContextProviderThrew(Exception ex) =>
+            $"ContextProvider threw {ex.GetType().Name}: {ex.Message}. " +
+            "Event ships with base context only.";
+
+        internal static string LaunchContextProviderThrew(Exception ex) =>
+            $"LaunchContextProvider threw {ex.GetType().Name}: {ex.Message}. " +
+            "game_launch will ship without auto-detected Unity context.";
+    }
 }
diff --git a/src/Packages/Audience/Tests/Runtime/Core/SessionTests.cs b/src/Packages/Audience/Tests/Runtime/Core/SessionTests.cs
@@ -499,7 +499,7 @@ void Track(string name, Dictionary<string, object> props)
 
                 lock (warnings)
                 {
-                    Assert.IsTrue(warnings.Any(w => w.Contains("heartbeat callback did not complete")),
+                    Assert.IsTrue(warnings.Any(w => w.Contains(AudienceLogs.SessionHeartbeatTimeout)),
                         "End must log the drain-timeout warning when an in-flight heartbeat exceeds 1 s");
                 }
             }
@@ -557,7 +557,8 @@ void ThrowingTrack(string name, Dictionary<string, object> props)
 
                 lock (warnings)
                 {
-                    Assert.IsTrue(warnings.Any(w => w.Contains("session_heartbeat track callback threw")),
+                    var expected = AudienceLogs.SessionTrackCallbackThrew("session_heartbeat", new InvalidOperationException());
+                    Assert.IsTrue(warnings.Any(w => w.Contains(expected)),
                         "SafeTrack must log a warning when the callback throws");
                 }
             }
@@ -590,7 +591,8 @@ void ThrowingTrack(string name, Dictionary<string, object> props)
 
                 lock (warnings)
                 {
-                    Assert.IsTrue(warnings.Any(w => w.Contains("session_start track callback threw")),
+                    var expected = AudienceLogs.SessionTrackCallbackThrew("session_start", new InvalidOperationException());
+                    Assert.IsTrue(warnings.Any(w => w.Contains(expected)),
                         "SafeTrack must log a warning when the Start callback throws");
                 }
             }
@@ -625,7 +627,8 @@ void ThrowingTrack(string name, Dictionary<string, object> props)
 
                 lock (warnings)
                 {
-                    Assert.IsTrue(warnings.Any(w => w.Contains("session_end track callback threw")),
+                    var expected = AudienceLogs.SessionTrackCallbackThrew("session_end", new InvalidOperationException());
+                    Assert.IsTrue(warnings.Any(w => w.Contains(expected)),
                         "SafeTrack must log a warning when the End callback throws");
                 }
             }
diff --git a/src/Packages/Audience/Tests/Runtime/ImmutableAudienceTests.cs b/src/Packages/Audience/Tests/Runtime/ImmutableAudienceTests.cs
@@ -303,7 +303,7 @@ public void Track_NullEvent_DoesNotThrow_AndLogsWarning()
             try
             {
                 Assert.DoesNotThrow(() => ImmutableAudience.Track((IEvent)null));
-                Assert.That(lines, Has.Some.Contains("null event"));
+                Assert.That(lines, Has.Some.Contains(AudienceLogs.TrackIEventNull));
             }
             finally { Log.Writer = null; }
         }
@@ -320,7 +320,9 @@ public void Track_IEventMissingRequiredField_DropsWithWarn()
                 // Purchase with no Value set: ToProperties throws; Track must
                 // catch, warn, and drop rather than ship an incomplete event.
                 Assert.DoesNotThrow(() => ImmutableAudience.Track(new Purchase { Currency = "USD" }));
-                Assert.That(lines, Has.Some.Contains("Purchase"));
+                // Assert the stable parts (event-type name and trailing "Dropping")
+                // so the test survives any change to the exception type or message.
+                Assert.That(lines, Has.Some.Contains(nameof(Purchase)));
                 Assert.That(lines, Has.Some.Contains("Dropping"));
             }
             finally { Log.Writer = null; }
@@ -430,7 +432,7 @@ public void Init_CalledTwice_LogsWarning()
                 ImmutableAudience.Init(MakeConfig());
                 ImmutableAudience.Init(MakeConfig());
 
-                Assert.That(lines, Has.Some.Contains("Init called more than once"),
+                Assert.That(lines, Has.Some.Contains(AudienceLogs.InitCalledTwice),
                     "second Init must surface a warning so a developer notices the silent no-op");
             }
             finally
@@ -467,7 +469,7 @@ public void Init_ConcurrentCalls_OnlyOneSucceeds_OthersWarn()
 
                 foreach (var t in threads) t.Join(TimeSpan.FromSeconds(5));
 
-                var warningCount = lines.Count(l => l.Contains("Init called more than once"));
+                var warningCount = lines.Count(l => l.Contains(AudienceLogs.InitCalledTwice));
                 Assert.AreEqual(threadCount - 1, warningCount,
                     "exactly one thread should initialise; the other (threadCount - 1) should hit the duplicate-call warning branch");
             }
diff --git a/src/Packages/Audience/Tests/Runtime/PublishableKeyPrefixTests.cs b/src/Packages/Audience/Tests/Runtime/PublishableKeyPrefixTests.cs

Original file line number	Diff line number	Diff line change
`@@ -112,7 +112,7 @@ internal void Pause()`
`112`	`112`	`// when End fires while paused), over-crediting engagement.`
`113`	`113`	`if (_pausedAt.HasValue)`
`114`	`114`	`{`
`115`		`- Log.Debug("Session: Pause while already paused. Ignoring.");`
	`115`	`+ Log.Debug(AudienceLogs.SessionPauseAlreadyPaused);`
`116`	`116`	`return;`
`117`	`117`	`}`
`118`	`118`	`_pausedAt = _getUtcNow();`
`@@ -259,7 +259,7 @@ private void SafeTrack(string eventName, Dictionary<string, object> properties)`
`259`	`259`	`}`
`260`	`260`	`catch (Exception ex)`
`261`	`261`	`{`
`262`		`- Log.Warn($"Session: {eventName} track callback threw {ex.GetType().Name}. Event dropped.");`
	`262`	`+ Log.Warn(AudienceLogs.SessionTrackCallbackThrew(eventName, ex));`
`263`	`263`	`}`
`264`	`264`	`}`
`265`	`265`
`@@ -277,8 +277,7 @@ private void DrainHeartbeatTimer()`
`277`	`277`
`278`	`278`	`if (!TimerDisposal.DisposeAndWait(timer, TimeSpan.FromSeconds(1)))`
`279`	`279`	`{`
`280`		`- Log.Warn("Session: heartbeat callback did not complete within 1s on timer stop. " +`
`281`		`- "A trailing session_heartbeat may race with the next session lifecycle event.");`
	`280`	`+ Log.Warn(AudienceLogs.SessionHeartbeatTimeout);`
`282`	`281`	`}`
`283`	`282`	`}`
`284`	`283`
Original file line number	Diff line number	Diff line change
`@@ -159,8 +159,7 @@ public static void Init(AudienceConfig config)`
`159`	`159`	`{`
`160`	`160`	`if (_initialized)`
`161`	`161`	`{`
`162`		`- Log.Warn("Init called more than once. Ignoring; original config retained. " +`
`163`		`- "Call Shutdown() first if reconfiguring is intended.");`
	`162`	`+ Log.Warn(AudienceLogs.InitCalledTwice);`
`164`	`163`	`return;`
`165`	`164`	`}`
`166`	`165`
`@@ -237,7 +236,7 @@ public static void Track(IEvent evt)`
`237`	`236`	`if (!_initialized \|\| !state.Level.CanTrack()) return;`
`238`	`237`	`if (evt == null)`
`239`	`238`	`{`
`240`		`- Log.Warn("Track(IEvent) called with null event. Dropping.");`
	`239`	`+ Log.Warn(AudienceLogs.TrackIEventNull);`
`241`	`240`	`return;`
`242`	`241`	`}`
`243`	`242`
`@@ -254,13 +253,13 @@ public static void Track(IEvent evt)`
`254`	`253`	`}`
`255`	`254`	`catch (Exception ex)`
`256`	`255`	`{`
`257`		`- Log.Warn($"Track(IEvent): {evt.GetType().Name}.ToProperties()/EventName threw {ex.GetType().Name}: {ex.Message}. Dropping.");`
	`256`	`+ Log.Warn(AudienceLogs.TrackIEventThrew(evt.GetType().Name, ex));`
`258`	`257`	`return;`
`259`	`258`	`}`
`260`	`259`
`261`	`260`	`if (string.IsNullOrEmpty(eventName))`
`262`	`261`	`{`
`263`		`- Log.Warn($"Track(IEvent): {evt.GetType().Name}.EventName returned null or empty. Dropping.");`
	`262`	`+ Log.Warn(AudienceLogs.TrackIEventEmptyName(evt.GetType().Name));`
`264`	`263`	`return;`
`265`	`264`	`}`
`266`	`265`
`@@ -284,7 +283,7 @@ public static void Track(string eventName, Dictionary<string, object>? propertie`
`284`	`283`	`if (!_initialized \|\| !state.Level.CanTrack()) return;`
`285`	`284`	`if (string.IsNullOrEmpty(eventName))`
`286`	`285`	`{`
`287`		`- Log.Warn("Track(string) called with null or empty event name. Dropping.");`
	`286`	`+ Log.Warn(AudienceLogs.TrackStringEmptyName);`
`288`	`287`	`return;`
`289`	`288`	`}`
`290`	`289`
`@@ -315,7 +314,7 @@ public static void Identify(string userId, IdentityType identityType, Dictionary`
`315`	`314`	`// Validate inputs before consent so null-arg callers get the right warning.`
`316`	`315`	`if (string.IsNullOrEmpty(userId))`
`317`	`316`	`{`
`318`		`- Log.Warn("Identify called with null or empty userId. Dropping.");`
	`317`	`+ Log.Warn(AudienceLogs.IdentifyEmptyUserId);`
`319`	`318`	`return;`
`320`	`319`	`}`
`321`	`320`
`@@ -330,7 +329,7 @@ public static void Identify(string userId, IdentityType identityType, Dictionary`
`330`	`329`	`level = current.Level;`
`331`	`330`	`if (!level.CanIdentify())`
`332`	`331`	`{`
`333`		`- Log.Warn($"Identify discarded. Requires Full consent, current is {level}.");`
	`332`	`+ Log.Warn(AudienceLogs.IdentifyDiscarded(level));`
`334`	`333`	`return;`
`335`	`334`	`}`
`336`	`335`	`config = _config;`
`@@ -357,13 +356,13 @@ public static void Alias(string fromId, IdentityType fromType, string toId, Iden`
`357`	`356`
`358`	`357`	`if (string.IsNullOrEmpty(fromId) \|\| string.IsNullOrEmpty(toId))`
`359`	`358`	`{`
`360`		`- Log.Warn("Alias called with null or empty fromId/toId. Dropping.");`
	`359`	`+ Log.Warn(AudienceLogs.AliasEmptyIds);`
`361`	`360`	`return;`
`362`	`361`	`}`
`363`	`362`	`var state = _state;`
`364`	`363`	`if (!state.Level.CanIdentify())`
`365`	`364`	`{`
`366`		`- Log.Warn($"Alias discarded. Requires Full consent, current is {state.Level}.");`
	`365`	`+ Log.Warn(AudienceLogs.AliasDiscarded(state.Level));`
`367`	`366`	`return;`
`368`	`367`	`}`
`369`	`368`
`@@ -486,7 +485,7 @@ private static void NotifyErrorCallback(Action<AudienceError>? onError, Audience`
`486`	`485`	`}`
`487`	`486`	`catch (Exception ex)`
`488`	`487`	`{`
`489`		`- Log.Warn($"onError threw {ex.GetType().Name}: {ex.Message}");`
	`488`	`+ Log.Warn(AudienceLogs.OnErrorThrew(ex));`
`490`	`489`	`}`
`491`	`490`	`}`
`492`	`491`
`@@ -579,8 +578,7 @@ public static void SetConsent(ConsentLevel level)`
`579`	`578`	`}`
`580`	`579`	`catch (Exception ex) when (ex is IOException \|\| ex is UnauthorizedAccessException)`
`581`	`580`	`{`
`582`		`- Log.Warn($"SetConsent: failed to persist consent level. {ex.GetType().Name}: {ex.Message}. " +`
`583`		`- "In-memory level is updated but will revert on next launch.");`
	`581`	`+ Log.Warn(AudienceLogs.ConsentPersistFailed(ex));`
`584`	`582`	`NotifyErrorCallback(config.OnError, AudienceErrorCode.ConsentPersistFailed,`
`585`	`583`	`$"Consent persist failed: {ex.Message}");`
`586`	`584`	`}`
`@@ -802,13 +800,12 @@ public static void Shutdown()`
`802`	`800`	`var send = transport.SendBatchAsync();`
`803`	`801`	`if (!send.Wait(timeoutMs))`
`804`	`802`	`{`
`805`		`- Log.Warn($"Shutdown flush exceeded {timeoutMs}ms. Abandoning. " +`
`806`		`- "Queued events remain on disk and will retry on next startup.");`
	`803`	`+ Log.Warn(AudienceLogs.ShutdownFlushExceeded(timeoutMs));`
`807`	`804`	`}`
`808`	`805`	`}`
`809`	`806`	`catch (Exception ex)`
`810`	`807`	`{`
`811`		`- Log.Warn($"Shutdown flush threw: {ex.GetType().Name}: {ex.Message}");`
	`808`	`+ Log.Warn(AudienceLogs.ShutdownFlushThrew(ex));`
`812`	`809`	`}`
`813`	`810`	`}`
`814`	`811`
`@@ -870,17 +867,11 @@ private static void WarnIfKeyEnvironmentMismatch(string publishableKey, string?`
`870`	`867`
`871`	`868`	`if (isTestKey && trimmed == Constants.ProductionBaseUrl)`
`872`	`869`	`{`
`873`		`- Log.Warn(`
`874`		`- $"Publishable key has the test prefix ({Constants.TestKeyPrefix}) but BaseUrl points to production. " +`
`875`		`- "The backend will reject events with 401. Either remove the BaseUrl override (test keys " +`
`876`		`- "default to sandbox) or use a non-test publishable key.");`
	`870`	`+ Log.Warn(AudienceLogs.TestKeyAgainstProduction);`
`877`	`871`	`}`
`878`	`872`	`else if (!isTestKey && trimmed == Constants.SandboxBaseUrl)`
`879`	`873`	`{`
`880`		`- Log.Warn(`
`881`		`- "Publishable key is not a test key but BaseUrl points to sandbox. " +`
`882`		`- "The backend will reject events with 401. Either remove the BaseUrl override (non-test " +`
`883`		`- $"keys default to production) or use a test publishable key ({Constants.TestKeyPrefix}).");`
	`874`	`+ Log.Warn(AudienceLogs.NonTestKeyAgainstSandbox);`
`884`	`875`	`}`
`885`	`876`	`}`
`886`	`877`
`@@ -922,8 +913,7 @@ private static void MergeUnityContext(Dictionary<string, object>? msg)`
`922`	`913`	`}`
`923`	`914`	`catch (Exception ex)`
`924`	`915`	`{`
`925`		`- Log.Warn($"ContextProvider threw {ex.GetType().Name}: {ex.Message}. " +`
`926`		`- "Event ships with base context only.");`
	`916`	`+ Log.Warn(AudienceLogs.ContextProviderThrew(ex));`
`927`	`917`	`return;`
`928`	`918`	`}`
`929`	`919`	`if (extra == null) return;`
`@@ -959,7 +949,7 @@ private static void SendBatch()`
`959`	`949`	`catch (Exception ex)`
`960`	`950`	`{`
`961`	`951`	`// Timer-thread callback; no caller above to catch.`
`962`		`- Log.Warn($"SendBatch unexpected exception: {ex.GetType().Name}: {ex.Message}");`
	`952`	`+ Log.Warn(AudienceLogs.SendBatchUnexpected(ex));`
`963`	`953`	`}`
`964`	`954`	`}`
`965`	`955`
`@@ -1007,8 +997,7 @@ private static void FireGameLaunch(AudienceConfig config, ConsentLevel consentAt`
`1007`	`997`	`try { unityContext = provider(); }`
`1008`	`998`	`catch (Exception ex)`
`1009`	`999`	`{`
`1010`		`- Log.Warn($"LaunchContextProvider threw {ex.GetType().Name}: {ex.Message}. " +`
`1011`		`- "game_launch will ship without auto-detected Unity context.");`
	`1000`	`+ Log.Warn(AudienceLogs.LaunchContextProviderThrew(ex));`
`1012`	`1001`	`}`
`1013`	`1002`
`1014`	`1003`	`if (unityContext != null)`
Original file line number	Diff line number	Diff line change
`@@ -288,7 +288,7 @@ private static async Task<int> ParseRejectedCount(HttpResponseMessage response,`
`288`	`288`	`}`
`289`	`289`	`catch (Exception ex)`
`290`	`290`	`{`
`291`		`- Log.Warn($"ParseRejectedCount threw {ex.GetType().Name}: {ex.Message}");`
	`291`	`+ Log.Warn(AudienceLogs.ParseRejectedCountThrew(ex));`
`292`	`292`	`return 0;`
`293`	`293`	`}`
`294`	`294`	`if (string.IsNullOrEmpty(body)) return 0;`
`@@ -339,7 +339,7 @@ private void NotifyError(AudienceErrorCode code, string message)`
`339`	`339`	`}`
`340`	`340`	`catch (Exception ex)`
`341`	`341`	`{`
`342`		`- Log.Warn($"_onError threw {ex.GetType().Name}: {ex.Message}");`
	`342`	`+ Log.Warn(AudienceLogs.OnErrorThrew(ex));`
`343`	`343`	`}`
`344`	`344`	`}`
`345`	`345`	`}`
Original file line number	Diff line number	Diff line change
`@@ -499,7 +499,7 @@ void Track(string name, Dictionary<string, object> props)`
`499`	`499`
`500`	`500`	`lock (warnings)`
`501`	`501`	`{`
`502`		`- Assert.IsTrue(warnings.Any(w => w.Contains("heartbeat callback did not complete")),`
	`502`	`+ Assert.IsTrue(warnings.Any(w => w.Contains(AudienceLogs.SessionHeartbeatTimeout)),`
`503`	`503`	`"End must log the drain-timeout warning when an in-flight heartbeat exceeds 1 s");`
`504`	`504`	`}`
`505`	`505`	`}`
`@@ -557,7 +557,8 @@ void ThrowingTrack(string name, Dictionary<string, object> props)`
`557`	`557`
`558`	`558`	`lock (warnings)`
`559`	`559`	`{`
`560`		`- Assert.IsTrue(warnings.Any(w => w.Contains("session_heartbeat track callback threw")),`
	`560`	`+ var expected = AudienceLogs.SessionTrackCallbackThrew("session_heartbeat", new InvalidOperationException());`
	`561`	`+ Assert.IsTrue(warnings.Any(w => w.Contains(expected)),`
`561`	`562`	`"SafeTrack must log a warning when the callback throws");`
`562`	`563`	`}`
`563`	`564`	`}`
`@@ -590,7 +591,8 @@ void ThrowingTrack(string name, Dictionary<string, object> props)`
`590`	`591`
`591`	`592`	`lock (warnings)`
`592`	`593`	`{`
`593`		`- Assert.IsTrue(warnings.Any(w => w.Contains("session_start track callback threw")),`
	`594`	`+ var expected = AudienceLogs.SessionTrackCallbackThrew("session_start", new InvalidOperationException());`
	`595`	`+ Assert.IsTrue(warnings.Any(w => w.Contains(expected)),`
`594`	`596`	`"SafeTrack must log a warning when the Start callback throws");`
`595`	`597`	`}`
`596`	`598`	`}`
`@@ -625,7 +627,8 @@ void ThrowingTrack(string name, Dictionary<string, object> props)`
`625`	`627`
`626`	`628`	`lock (warnings)`
`627`	`629`	`{`
`628`		`- Assert.IsTrue(warnings.Any(w => w.Contains("session_end track callback threw")),`
	`630`	`+ var expected = AudienceLogs.SessionTrackCallbackThrew("session_end", new InvalidOperationException());`
	`631`	`+ Assert.IsTrue(warnings.Any(w => w.Contains(expected)),`
`629`	`632`	`"SafeTrack must log a warning when the End callback throws");`
`630`	`633`	`}`
`631`	`634`	`}`
Original file line number	Diff line number	Diff line change
`@@ -303,7 +303,7 @@ public void Track_NullEvent_DoesNotThrow_AndLogsWarning()`
`303`	`303`	`try`
`304`	`304`	`{`
`305`	`305`	`Assert.DoesNotThrow(() => ImmutableAudience.Track((IEvent)null));`
`306`		`- Assert.That(lines, Has.Some.Contains("null event"));`
	`306`	`+ Assert.That(lines, Has.Some.Contains(AudienceLogs.TrackIEventNull));`
`307`	`307`	`}`
`308`	`308`	`finally { Log.Writer = null; }`
`309`	`309`	`}`
`@@ -320,7 +320,9 @@ public void Track_IEventMissingRequiredField_DropsWithWarn()`
`320`	`320`	`// Purchase with no Value set: ToProperties throws; Track must`
`321`	`321`	`// catch, warn, and drop rather than ship an incomplete event.`
`322`	`322`	`Assert.DoesNotThrow(() => ImmutableAudience.Track(new Purchase { Currency = "USD" }));`
`323`		`- Assert.That(lines, Has.Some.Contains("Purchase"));`
	`323`	`+ // Assert the stable parts (event-type name and trailing "Dropping")`
	`324`	`+ // so the test survives any change to the exception type or message.`
	`325`	`+ Assert.That(lines, Has.Some.Contains(nameof(Purchase)));`
`324`	`326`	`Assert.That(lines, Has.Some.Contains("Dropping"));`
`325`	`327`	`}`
`326`	`328`	`finally { Log.Writer = null; }`
`@@ -430,7 +432,7 @@ public void Init_CalledTwice_LogsWarning()`
`430`	`432`	`ImmutableAudience.Init(MakeConfig());`
`431`	`433`	`ImmutableAudience.Init(MakeConfig());`
`432`	`434`
`433`		`- Assert.That(lines, Has.Some.Contains("Init called more than once"),`
	`435`	`+ Assert.That(lines, Has.Some.Contains(AudienceLogs.InitCalledTwice),`
`434`	`436`	`"second Init must surface a warning so a developer notices the silent no-op");`
`435`	`437`	`}`
`436`	`438`	`finally`
`@@ -467,7 +469,7 @@ public void Init_ConcurrentCalls_OnlyOneSucceeds_OthersWarn()`
`467`	`469`
`468`	`470`	`foreach (var t in threads) t.Join(TimeSpan.FromSeconds(5));`
`469`	`471`
`470`		`- var warningCount = lines.Count(l => l.Contains("Init called more than once"));`
	`472`	`+ var warningCount = lines.Count(l => l.Contains(AudienceLogs.InitCalledTwice));`
`471`	`473`	`Assert.AreEqual(threadCount - 1, warningCount,`
`472`	`474`	`"exactly one thread should initialise; the other (threadCount - 1) should hit the duplicate-call warning branch");`
`473`	`475`	`}`