Merge pull request #728 from bugsnag/removeDateTimeNowUsage

Backport Release v6.3.4

CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+
+## 6.3.4 (2023-07-06)
+
+## Bug Fixes
+
+- Remove unnecessary usages of DateTimeOffset.Now to prevent iOS app hangs resulting from Unity native code accessing non-thread safe methods. [#725](https://github.com/bugsnag/bugsnag-unity/pull/725)
+
+
 ## 6.3.3 (2023-06-13)
 
 ## Bug Fixes

build.cake

@@ -5,7 +5,7 @@ var target = Argument("target", "Default");
 var solution = File("./BugsnagUnity.sln");
 var configuration = Argument("configuration", "Release");
 var project = File("./src/BugsnagUnity/BugsnagUnity.csproj");
-var version = "6.3.3";
+var version = "6.3.4";
 
 Task("Restore-NuGet-Packages")
     .Does(() => NuGetRestore(solution));

src/BugsnagUnity/MaximumLogTypeCounter.cs

@@ -10,19 +10,24 @@ public class MaximumLogTypeCounter
 
         private Dictionary<LogType, int> CurrentCounts { get; }
 
-        private DateTimeOffset FlushAt { get; set; }
+        private double FlushAt { get; set; }
 
-        private TimeSpan MaximumLogsTimePeriod => Configuration.MaximumLogsTimePeriod;
+        private double MaximumLogsTimePeriod => Configuration.MaximumLogsTimePeriod.TotalSeconds;
 
         private Dictionary<LogType, int> MaximumTypePerTimePeriod => Configuration.MaximumTypePerTimePeriod;
 
         private readonly object _lock = new object();
 
+        private void SetFlushTime()
+        {
+            FlushAt = Time.ElapsedSeconds + MaximumLogsTimePeriod;
+        }
+
         public MaximumLogTypeCounter(Configuration configuration)
         {
             Configuration = configuration;
             CurrentCounts = new Dictionary<LogType, int>();
-            FlushAt = DateTimeOffset.Now.Add(Configuration.MaximumLogsTimePeriod);
+            SetFlushTime();
         }
 
         public bool ShouldSend(UnityLogMessage unityLogMessage)
@@ -47,7 +52,7 @@ public bool ShouldSend(UnityLogMessage unityLogMessage)
                         if (unityLogMessage.CreatedAt > FlushAt)
                         {
                             CurrentCounts.Clear();
-                            FlushAt = DateTimeOffset.Now.Add(MaximumLogsTimePeriod);
+                            SetFlushTime();
                             return true;
                         }
                         return false;

src/BugsnagUnity/Payload/AppWithState.cs

@@ -56,7 +56,7 @@ internal AppWithState(Dictionary<string, object> cachedData) : base(cachedData){
 
         internal AppWithState(Configuration configuration) : base(configuration)
         {
-            Duration = TimeSpan.FromSeconds(Time.realtimeSinceStartup);
+            Duration = TimeSpan.FromSeconds(UnityEngine.Time.realtimeSinceStartup);
         }
 
     }

src/BugsnagUnity/Time.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Diagnostics;
+
+namespace BugsnagUnity
+{
+    // A simple timer used internally to avoid thread complications when using the unity Time API
+    internal class Time
+    {
+
+        private static object _swLock = new object();
+
+        private static Stopwatch _sw;
+
+        internal static Stopwatch Timer
+        {
+            get
+            {
+                if (_sw == null)
+                {
+                    lock (_swLock)
+                    {
+                        if (_sw == null)
+                        {
+                            _sw = Stopwatch.StartNew();
+                        }
+                    }
+                }
+                return _sw;
+            }
+        }
+
+        internal static double ElapsedSeconds => Timer.Elapsed.TotalSeconds;
+
+    }
+}
+

src/BugsnagUnity/UniqueLogThrottle.cs

@@ -18,20 +18,25 @@ public class UniqueLogThrottle
         /// <summary>
         /// Used to track when the counter should be flushed next
         /// </summary>
-        private DateTime FlushAt { get; set; }
+        private double FlushAt { get; set; }
 
         /// <summary>
         /// The configuration for unique log counts and times
         /// </summary>
         private Configuration Configuration { get; }
 
-        private TimeSpan UniqueLogsTimePeriod => Configuration.SecondsPerUniqueLog;
+        private double UniqueLogsTimePeriod => Configuration.SecondsPerUniqueLog.TotalSeconds;
+
+        private void SetFlushTime()
+        {
+            FlushAt = Time.ElapsedSeconds + UniqueLogsTimePeriod;
+        }
 
         public UniqueLogThrottle(Configuration configuration)
         {
             Configuration = configuration;
             Counter = new Dictionary<UnityLogMessage, int>(new UnityLogMessageEqualityComparer());
-            FlushAt = DateTime.UtcNow.Add(Configuration.SecondsPerUniqueLog);
+            SetFlushTime();
         }
 
         /// <summary>
@@ -43,7 +48,6 @@ public UniqueLogThrottle(Configuration configuration)
         public bool ShouldSend(UnityLogMessage unityLogMessage)
         {
             bool shouldSend;
-
             lock (_lock)
             {
                 shouldSend = !Counter.ContainsKey(unityLogMessage);
@@ -57,7 +61,7 @@ public bool ShouldSend(UnityLogMessage unityLogMessage)
                     if (unityLogMessage.CreatedAt > FlushAt)
                     {
                         Counter.Clear();
-                        FlushAt = DateTime.UtcNow.Add(UniqueLogsTimePeriod);
+                        SetFlushTime();
                         shouldSend = true;
                     }
                 }

src/BugsnagUnity/UnityLogMessage.cs

@@ -10,18 +10,29 @@ public class UnityLogMessage
     {
         public UnityLogMessage(string condition, string stackTrace, LogType type)
         {
-            CreatedAt = DateTime.UtcNow;
+            CreatedAt = Time.ElapsedSeconds;
             Condition = condition;
             StackTrace = stackTrace;
             Type = type;
         }
 
+
+        public UnityLogMessage(Exception exception)
+        {
+            CreatedAt = Time.ElapsedSeconds;
+            Condition = exception.Message == null ? string.Empty : exception.Message;
+            StackTrace = exception.StackTrace == null ? string.Empty : exception.StackTrace;
+            Type = LogType.Exception;
+        }
+
         public string Condition { get; }
 
         public string StackTrace { get; }
 
         public LogType Type { get; }
 
-        public DateTime CreatedAt { get; }
+        public double CreatedAt { get; }
+
+
     }
 }

tests/UnityEngine/Time.cs

@@ -1,10 +1,9 @@
-using System;
-namespace UnityEngine
+namespace UnityEngine
 {
     public class Time
     {
 
         public static float realtimeSinceStartup { get; set; }
-       
+
     }
-}
+}