Release health integration & Event-listener

CHANGELOG.md

@@ -6,6 +6,7 @@
 
 - Sentry config is now a scriptable object ([#220](https://github.com/getsentry/sentry-unity/pull/220))
 - Unity protocol ([#234](https://github.com/getsentry/sentry-unity/pull/234))
+- Release health integration & Event-listener ([#225](https://github.com/getsentry/sentry-unity/pull/225))
 
 ### Fixes
 

samples/Directory.Build.targets

@@ -0,0 +1,3 @@
+<Project>
+  <!-- Stops msbuild from looking on the part directory. Can't deal with the properties set such as C# 9 -->
+</Project>

src/Sentry.Unity/ApplicationPauseListener.cs

@@ -0,0 +1,86 @@
+using System;
+using UnityEngine;
+
+namespace Sentry.Unity
+{
+    /// <summary>
+    ///  A MonoBehavior used to forward application focus events to subscribers.
+    /// </summary>
+    [DefaultExecutionOrder(-900)]
+    internal class ApplicationPauseListener : MonoBehaviour
+    {
+        /// <summary>
+        /// Hook to receive an event when the application gains focus.
+        /// <remarks>
+        /// Listens to OnApplicationFocus for all platforms except Android, where we listen to OnApplicationPause.
+        /// </remarks>
+        /// </summary>
+        public event Action? ApplicationResuming;
+
+        /// <summary>
+        /// Hook to receive an event when the application loses focus.
+        /// <remarks>
+        /// Listens to OnApplicationFocus for all platforms except Android, where we listen to OnApplicationPause.
+        /// </remarks>
+        /// </summary>
+        public event Action? ApplicationPausing;
+
+        // Keeping internal track of running state because OnApplicationPause and OnApplicationFocus get called during startup and would fire false resume events
+        private bool _isRunning = true;
+
+        /// <summary>
+        /// To receive Leaving/Resuming events on Android.
+        /// <remarks>
+        /// On Android, when the on-screen keyboard is enabled, it causes a OnApplicationFocus(false) event.
+        /// Additionally, if you press "Home" at the moment the keyboard is enabled, the OnApplicationFocus() event is
+        /// not called, but OnApplicationPause() is called instead.
+        /// </remarks>
+        /// <seealso href="https://docs.unity3d.com/2019.4/Documentation/ScriptReference/MonoBehaviour.OnApplicationPause.html"/>
+        /// </summary>
+        private void OnApplicationPause(bool pauseStatus)
+        {
+            if (Application.platform != RuntimePlatform.Android)
+            {
+                return;
+            }
+
+            if (pauseStatus && _isRunning)
+            {
+                _isRunning = false;
+                ApplicationPausing?.Invoke();
+            }
+            else if (!pauseStatus && !_isRunning)
+            {
+                _isRunning = true;
+                ApplicationResuming?.Invoke();
+            }
+        }
+
+        /// <summary>
+        /// To receive Leaving/Resuming events on all platforms except Android.
+        /// </summary>
+        /// <param name="hasFocus"></param>
+        private void OnApplicationFocus(bool hasFocus)
+        {
+            // To avoid event duplication on Android since the pause event will be handled via OnApplicationPause
+            if (Application.platform == RuntimePlatform.Android)
+            {
+                return;
+            }
+
+            if (hasFocus && !_isRunning)
+            {
+                _isRunning = true;
+                ApplicationResuming?.Invoke();
+            }
+            else if (!hasFocus && _isRunning)
+            {
+                _isRunning = false;
+                ApplicationPausing?.Invoke();
+            }
+        }
+
+        // The GameObject has to destroy itself since it was created with HideFlags.HideAndDontSave
+        private void OnApplicationQuit() => Destroy(gameObject);
+    }
+}

src/Sentry.Unity/Integrations/SessionIntegration.cs

@@ -0,0 +1,33 @@
+using Sentry.Extensibility;
+using Sentry.Integrations;
+using UnityEngine;
+
+namespace Sentry.Unity.Integrations
+{
+    public class SessionIntegration : ISdkIntegration
+    {
+        public void Register(IHub hub, SentryOptions options)
+        {
+            if (!options.AutoSessionTracking)
+            {
+                return;
+            }
+
+            options.DiagnosticLogger?.LogDebug("Registering Session integration.");
+
+            // HideFlags.HideAndDontSave hides the GameObject in the hierarchy and prevents changing of scenes from destroying it
+            var gameListenerObject = new GameObject("SentryListener") {hideFlags = HideFlags.HideAndDontSave};
+            var gameListener = gameListenerObject.AddComponent<ApplicationPauseListener>();
+            gameListener.ApplicationResuming += () =>
+            {
+                options.DiagnosticLogger?.LogDebug("Resuming session.");
+                hub.ResumeSession();
+            };
+            gameListener.ApplicationPausing += () =>
+            {
+                options.DiagnosticLogger?.LogDebug("Pausing session.");
+                hub.PauseSession();
+            };
+        }
+    }
+}

src/Sentry.Unity/Integrations/UnityApplicationLoggingIntegration.cs

@@ -80,6 +80,7 @@ private void OnQuitting()
             // Note: On Windows Store Apps and Windows Phone 8.1 there is no application quit event. Consider using OnApplicationFocus event when focusStatus equals false.
             // Note: On WebGL it is not possible to implement OnApplicationQuit due to nature of the browser tabs closing.
             _application.LogMessageReceived -= OnLogMessageReceived;
+            _hub?.EndSession();
             _hub?.FlushAsync(_sentryOptions?.ShutdownTimeout ?? TimeSpan.FromSeconds(1)).GetAwaiter().GetResult();
         }
 

src/Sentry.Unity/SentryOptionsUtility.cs

@@ -1,6 +1,5 @@
-using Sentry.Extensibility;
+using System;
 using Sentry.Unity.Integrations;
-using UnityEngine;
 
 namespace Sentry.Unity
 {
@@ -12,6 +11,7 @@ public static void SetDefaults(SentryUnityOptions options, IApplication? applica
 
             options.Enabled = true;
             options.Dsn = null;
+            options.AutoSessionTracking = true;
             options.CaptureInEditor = true;
             options.RequestBodyCompressionLevel = CompressionLevelWithAuto.NoCompression;
             options.AttachStacktrace = false;
@@ -26,7 +26,7 @@ public static void SetDefaults(SentryUnityOptions options, IApplication? applica
             options.CacheDirectoryPath = application.PersistentDataPath;
 
             options.Debug = true;
-            options.DebugOnlyInEditor = true;
+            options.DebugOnlyInEditor = false;
             options.DiagnosticLevel = SentryLevel.Warning;
 
             TryAttachLogger(options, application);
@@ -46,7 +46,7 @@ public static void SetDefaults(ScriptableSentryUnityOptions options)
             options.EnableOfflineCaching = true;
 
             options.Debug = true;
-            options.DebugOnlyInEditor = true;
+            options.DebugOnlyInEditor = false;
             options.DiagnosticLevel = SentryLevel.Warning;
         }
 

src/Sentry.Unity/SentryUnity.cs

@@ -1,7 +1,6 @@
 using System;
 using System.ComponentModel;
 using Sentry.Extensibility;
-using UnityEngine;
 
 namespace Sentry.Unity
 {

src/Sentry.Unity/SentryUnityOptions.cs

@@ -76,6 +76,7 @@ public SentryUnityOptions()
             this.AddIntegration(new UnityApplicationLoggingIntegration());
             this.AddIntegration(new UnityBeforeSceneLoadIntegration());
             this.AddIntegration(new SceneManagerIntegration());
+            this.AddIntegration(new SessionIntegration());
         }
 
         public override string ToString()

test/Sentry.Unity.Tests/Stubs/TestHub.cs

@@ -35,20 +35,16 @@ public void CaptureTransaction(Transaction transaction)
 
         public void CaptureSession(SessionUpdate sessionUpdate)
         {
-            throw new NotImplementedException();
         }
 
         public Task FlushAsync(TimeSpan timeout)
         {
-            throw new NotImplementedException();
+            return Task.CompletedTask;
         }
 
         public void ConfigureScope(Action<Scope> configureScope) => _configureScopeCalls.Add(configureScope);
 
-        public Task ConfigureScopeAsync(Func<Scope, Task> configureScope)
-        {
-            throw new NotImplementedException();
-        }
+        public Task ConfigureScopeAsync(Func<Scope, Task> configureScope) => Task.CompletedTask;
 
         public void BindClient(ISentryClient client)
         {
@@ -93,12 +89,22 @@ public void BindException(Exception exception, ISpan span)
 
         public void StartSession()
         {
-            throw new NotImplementedException();
+            // TODO: test sessions
+        }
+
+        public void PauseSession()
+        {
+            // TODO: test sessions
+        }
+
+        public void ResumeSession()
+        {
+            // TODO: test sessions
         }
 
         public void EndSession(SessionEndStatus status = SessionEndStatus.Exited)
         {
-            throw new NotImplementedException();
+            // TODO: test sessions
         }
     }
 }