test(audience-sample): capture player-side profile on Linux PlayMode runs

Adds PlayerProfilerLogger gated on UNITY_STANDALONE_LINUX and the
AUDIENCE_PLAYER_PROFILE_PATH env var. At BeforeSceneLoad inside the
test player process, points UnityEngine.Profiling.Profiler at the
configured path and starts a binary log of every captured frame.

PR #764 captured a deep profile of the editor process. The actual test
loop runs in a separate PlayerWithTests subprocess that the editor
launches and waits on. The editor profile only showed roughly 86 sec
of editor activity over a 27 min cell, the rest being editor idle
waiting on the player. This hook plugs that gap.

Wires the env var through the playmode-linux job's docker run and
adds player-profile.raw to the upload-artifact path so the capture is
downloadable for offline analysis in Unity Editor.

Note: enables regular profiling, not deep. Deep profiling on the
player would need -deepprofiling on the player command line, which
Unity Test Framework does not expose for editor-launched test
players. Regular profiling still surfaces per-frame CPU and the
function hot list, which is what we need to identify what is eating
roughly 37 sec per test.

Author: ImmutableJeffrey

.github/workflows/test-audience-sample-app.yml

@@ -468,6 +468,7 @@ jobs:
           AUDIENCE_SCRIPTING_BACKEND: ${{ matrix.backend }}
           UNITY_VERSION: ${{ matrix.unity }}
           AUDIENCE_LINUX_GLCORE_ONLY: "1"
+          AUDIENCE_PLAYER_PROFILE_PATH: "/github/workspace/artifacts/player-profile.raw"
         run: |
           set -uo pipefail
           mkdir -p artifacts
@@ -484,6 +485,7 @@ jobs:
             --env AUDIENCE_TEST_PUBLISHABLE_KEY --env AUDIENCE_SCRIPTING_BACKEND \
             --env AUDIENCE_TEST_RUN_ID --env AUDIENCE_TEST_CELL_ID \
             --env AUDIENCE_LINUX_GLCORE_ONLY \
+            --env AUDIENCE_PLAYER_PROFILE_PATH \
             --volume "$PWD":/github/workspace:z \
             --cpus=8 --memory=30487m \
             "$image" \
@@ -737,6 +739,7 @@ jobs:
             artifacts/playmode.log
             artifacts/activation.log
             artifacts/Player-*.log
+            artifacts/player-profile.raw
             examples/audience/Logs/**
 
   # Mobile IL2CPP build validation — runs on GitHub-hosted Ubuntu via GameCI Docker

examples/audience/Assets/SampleApp/Tests/Runtime/PlayerProfilerLogger.cs

@@ -0,0 +1,65 @@
+#nullable enable
+
+#if UNITY_STANDALONE_LINUX
+using System;
+using System.IO;
+using UnityEngine;
+using UnityEngine.Profiling;
+
+namespace Immutable.Audience.Samples.SampleApp.Tests
+{
+    // Linux PlayMode test player profiler hook.
+    //
+    // The editor profile we captured on PR #764 only covered the editor
+    // process. The actual test loop runs in a separate PlayerWithTests
+    // subprocess, which never had a profiler attached. This hook plugs
+    // that gap from inside the player itself.
+    //
+    // Behaviour: at BeforeSceneLoad, reads AUDIENCE_PLAYER_PROFILE_PATH
+    // from the player process env. When set, points
+    // UnityEngine.Profiling.Profiler at that path and starts a binary
+    // log of every captured frame. Output can be loaded into Unity
+    // Editor: Window > Analysis > Profiler > Load Profile.
+    //
+    // Engages only on StandaloneLinux64 builds (gated by the #if) and
+    // only when the env var is set (gated at runtime). Local dev builds
+    // and other-platform CI runs are unaffected.
+    //
+    // Note: this enables regular profiling, not deep profiling. Deep
+    // profiling is set at editor build time via the -deepprofiling
+    // command line flag and cannot be toggled from runtime code. Regular
+    // profiling still surfaces per-frame CPU breakdowns and the function
+    // hot list, which is what we need to identify the per-frame UI
+    // Toolkit cost (or whatever else is eating ~37 sec per test).
+    public static class PlayerProfilerLogger
+    {
+        private const string PathEnvVar = "AUDIENCE_PLAYER_PROFILE_PATH";
+
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
+        public static void Init()
+        {
+            var path = Environment.GetEnvironmentVariable(PathEnvVar);
+            if (string.IsNullOrEmpty(path)) return;
+
+            try
+            {
+                var dir = Path.GetDirectoryName(path);
+                if (!string.IsNullOrEmpty(dir))
+                {
+                    Directory.CreateDirectory(dir);
+                }
+
+                Profiler.logFile = path;
+                Profiler.enableBinaryLog = true;
+                Profiler.enabled = true;
+
+                Debug.Log($"[PlayerProfilerLogger] Profiler binary log enabled. Output: {path}");
+            }
+            catch (Exception ex)
+            {
+                Debug.LogWarning($"[PlayerProfilerLogger] Failed to enable profiler at {path}: {ex.Message}");
+            }
+        }
+    }
+}
+#endif