.NET 3.5 backward compatibility (#93)

konraddysput · web-flow · commit 288badc424a8 · 2021-07-15T15:37:50.000+02:00
* Backward compatibility

* Annotations test isolation

* Removed not used anymore variable

* Version bump

* iOS Support

* Safe enum comparision x64 vs x86

* variable name improvements

* Version bump
diff --git a/Runtime/BacktraceClient.cs b/Runtime/BacktraceClient.cs
@@ -24,7 +24,7 @@ namespace Backtrace.Unity
     /// </summary>
     public class BacktraceClient : MonoBehaviour, IBacktraceClient
     {
-        public const string VERSION = "3.5.0";
+        public const string VERSION = "3.5.1-preview.1";
 
         public BacktraceConfiguration Configuration;
 
@@ -656,7 +656,10 @@ private void OnDestroy()
             Application.logMessageReceivedThreaded -= HandleUnityBackgroundException;
 #if UNITY_ANDROID || UNITY_IOS
             Application.lowMemory -= HandleLowMemory;
-            _nativeClient?.Disable();
+            if (_nativeClient != null)
+            {
+                _nativeClient.Disable();
+            }
 #endif
         }
 
diff --git a/Runtime/BacktraceDatabase.cs b/Runtime/BacktraceDatabase.cs
@@ -729,7 +729,7 @@ public bool EnableBreadcrumbsSupport()
             {
                 return false;
             }
-            return Breadcrumbs.EnableBreadcrumbs(Configuration.BacktraceBreadcrumbsLevel, Configuration.LogLevel);
+            return _breadcrumbs.EnableBreadcrumbs(Configuration.BacktraceBreadcrumbsLevel, Configuration.LogLevel);
         }
     }
 }
diff --git a/Runtime/Extensions/EnumExtensions.cs b/Runtime/Extensions/EnumExtensions.cs
@@ -12,12 +12,21 @@ internal static bool HasFlag(this Enum variable, Enum value)
             {
                 throw new ArgumentException("The checked flag is not from the same type as the checked variable.");
             }
+            // Get the type code of the enumeration
+            var typeCode = variable.GetTypeCode();
 
-            Convert.ToUInt64(value);
-            ulong num = Convert.ToUInt64(value);
-            ulong num2 = Convert.ToUInt64(variable);
+            // If the underlying type of the flag is signed
+            if (typeCode == TypeCode.SByte || typeCode == TypeCode.Int16 || typeCode == TypeCode.Int32 || typeCode == TypeCode.Int64)
+            {
+                return (Convert.ToInt64(variable) & Convert.ToInt64(value)) != 0;
+            }
 
-            return (num2 & num) == num;
+            // If the underlying type of the flag is unsigned
+            if (typeCode == TypeCode.Byte || typeCode == TypeCode.UInt16 || typeCode == TypeCode.UInt32 || typeCode == TypeCode.UInt64)
+            {
+                return (Convert.ToUInt64(variable) & Convert.ToUInt64(value)) != 0;
+            }
+            return false;
         }
 #endif
     }
diff --git a/Runtime/Extensions/StreamExtensions.cs b/Runtime/Extensions/StreamExtensions.cs
@@ -6,6 +6,11 @@ namespace Backtrace.Unity.Extensions
     internal static class StreamExtensions
     {
 #if !(NET_STANDARD_2_0 && NET_4_6)
+        // We pick a value that is the largest multiple of 4096 that is still smaller than the large object heap threshold (85K).
+        // The CopyTo/CopyToAsync buffer is short-lived and is likely to be collected at Gen0, and it offers a significant
+        // improvement in Copy performance.
+        private const int _DefaultCopyBufferSize = 81920;
+
         public static void CopyTo(this Stream original, Stream destination)
         {
             if (destination == null)
@@ -29,7 +34,7 @@ public static void CopyTo(this Stream original, Stream destination)
                 throw new NotSupportedException("NotSupportedException destination");
             }
 
-            byte[] array = new byte[4096];
+            byte[] array = new byte[_DefaultCopyBufferSize];
             int count;
             while ((count = original.Read(array, 0, array.Length)) != 0)
             {
diff --git a/Runtime/Model/JsonData/Annotations.cs b/Runtime/Model/JsonData/Annotations.cs
@@ -5,6 +5,8 @@
 using System.Globalization;
 using UnityEngine;
 using UnityEngine.SceneManagement;
+
+[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("Backtrace.Unity.Tests.Runtime")]
 namespace Backtrace.Unity.Model.JsonData
 {
     /// <summary>
@@ -15,14 +17,24 @@ public class Annotations
         /// <summary>
         /// Backward compatibility helper
         /// </summary>
-        private static Dictionary<string, string> _environmentVariablesCache;
+        internal static Dictionary<string, string> _environmentVariablesCache;
+
+        /// <summary>
+        /// Determinate if static helper should load environment variables or not.
+        /// </summary>
+        internal static bool VariablesLoaded;
+
+        /// <summary>
+        /// Loaded environment variables
+        /// </summary>
         public static Dictionary<string, string> EnvironmentVariablesCache
         {
             get
             {
-                if (_environmentVariablesCache == null)
+                if (VariablesLoaded == false)
                 {
                     _environmentVariablesCache = SetEnvironmentVariables();
+                    VariablesLoaded = true;
                 }
                 return _environmentVariablesCache;
             }
@@ -31,24 +43,19 @@ public static Dictionary<string, string> EnvironmentVariablesCache
                 _environmentVariablesCache = value;
             }
         }
+
         /// <summary>
-        /// Backward compatibility helper
+        /// Backward compatibility - local reference to environment variables
         /// </summary>
-        private Dictionary<string, string> _environmentVariables;
-
         public Dictionary<string, string> EnvironmentVariables
         {
             get
             {
-                if (_environmentVariables == null)
-                {
-                    _environmentVariables = EnvironmentVariablesCache;
-                }
-                return _environmentVariables;
+                return EnvironmentVariablesCache;
             }
             set
             {
-                _environmentVariables = value;
+                EnvironmentVariablesCache = value;
             }
         }
         /// <summary>
diff --git a/Runtime/Native/Android/NativeClient.cs b/Runtime/Native/Android/NativeClient.cs
@@ -109,7 +109,9 @@ private void SetDefaultAttributeMaps()
         /// <summary>
         /// Anr watcher object
         /// </summary>
+#pragma warning disable IDE0052 // Remove unread private members
         private AndroidJavaObject _anrWatcher;
+#pragma warning restore IDE0052 // Remove unread private members
 
         private bool _captureNativeCrashes = false;
         private readonly bool _handlerANR = false;
diff --git a/Runtime/Native/iOS/NativeClient.cs b/Runtime/Native/iOS/NativeClient.cs
@@ -125,15 +125,26 @@ public void GetAttributes(IDictionary<string, string> result)
             {
                 return;
             }
-            GetNativeAttributes(out IntPtr pUnmanagedArray, out int keysCount);
+            IntPtr pUnmanagedArray;
+            int keysCount;
+            GetNativeAttributes(out pUnmanagedArray, out keysCount);
 
             // calculate struct size for current OS.
             // We multiply by 2 because Entry struct has two pointers
             var structSize = IntPtr.Size * 2;
+            const int x86StructSize = 4;
             for (int i = 0; i < keysCount; i++)
             {
-                var address = pUnmanagedArray + i * structSize;
-                Entry entry = Marshal.PtrToStructure<Entry>(address);
+                IntPtr address;
+                if (structSize == x86StructSize)
+                {
+                    address = new IntPtr(pUnmanagedArray.ToInt32() + i * structSize);
+                }
+                else
+                {
+                    address = new IntPtr(pUnmanagedArray.ToInt64() + i + structSize);
+                }
+                Entry entry = (Entry)Marshal.PtrToStructure(address, typeof(Entry));
                 result[entry.Key] = entry.Value;
             }
 
diff --git a/Runtime/Services/BacktraceDatabaseContext.cs b/Runtime/Services/BacktraceDatabaseContext.cs
@@ -275,7 +275,6 @@ public void Dispose()
         /// </summary>
         public void Clear()
         {
-            var records = BatchRetry.SelectMany(n => n.Value);
             TotalRecords = 0;
             TotalSize = 0;
             //clear all existing batches
diff --git a/Runtime/Services/BacktraceDatabaseFileContext.cs b/Runtime/Services/BacktraceDatabaseFileContext.cs
@@ -167,15 +167,10 @@ public void RemoveOrphaned(IEnumerable<BacktraceDatabaseRecord> existingRecords)
                         file.Delete();
                     }
                 }
-#pragma warning disable CS0168
                 catch (Exception e)
                 {
-#if DEBUG
-                    Debug.Log(e.ToString());
-#endif
-                    Debug.LogWarning(string.Format("Cannot remove file in path: {0}", file.FullName));
+                    Debug.LogWarning(string.Format("Cannot remove file in path: {0}. Reason: {1}", file.FullName, e.Message));
                 }
-#pragma warning restore CS0168
             }
         }
 
diff --git a/Tests/Runtime/ClientSendTests.cs b/Tests/Runtime/ClientSendTests.cs
@@ -29,6 +29,7 @@ public void Setup()
         public void Cleanup()
         {
             client.RequestHandler = null;
+            Annotations.VariablesLoaded = false;
         }
 
         [UnityTest]
@@ -73,31 +74,6 @@ public IEnumerator SendReport_MessageReport_ValidSend()
             yield return null;
         }
 
-        [UnityTest]
-        public IEnumerator PiiTests_ShouldRemoveEnvironmentVariables_AnnotationsShouldntBeAvailable()
-        {
-            var trigger = false;
-            var exception = new Exception("custom exception message");
-            client.BeforeSend = (BacktraceData data) =>
-             {
-                 Assert.IsNotNull(data.Annotation.EnvironmentVariables);
-                 data.Annotation.EnvironmentVariables = null;
-                 return data;
-             };
-
-            client.RequestHandler = (string url, BacktraceData data) =>
-            {
-                trigger = true;
-                Assert.IsNull(data.Annotation.EnvironmentVariables);
-                return new BacktraceResult();
-            };
-            client.Send(exception);
-
-            yield return new WaitForEndOfFrame();
-            Assert.IsTrue(trigger);
-            yield return null;
-        }
-
         [UnityTest]
         public IEnumerator PiiTests_ShouldChangeApplicationDataPath_ApplicationDataPathDoesntHaveUserNameAnymore()
         {
@@ -178,5 +154,30 @@ public IEnumerator PiiTests_ShouldRemoveEnvironmentVariableValue_IntegrationShou
             Assert.IsTrue(trigger);
             yield return null;
         }
+
+        [UnityTest]
+        public IEnumerator PiiTests_ShouldRemoveEnvironmentVariables_AnnotationsShouldntBeAvailable()
+        {
+            var trigger = false;
+            var exception = new Exception("custom exception message");
+            client.BeforeSend = (BacktraceData data) =>
+            {
+                Assert.IsNotNull(data.Annotation.EnvironmentVariables);
+                data.Annotation.EnvironmentVariables = null;
+                return data;
+            };
+
+            client.RequestHandler = (string url, BacktraceData data) =>
+            {
+                trigger = true;
+                Assert.IsNull(data.Annotation.EnvironmentVariables);
+                return new BacktraceResult();
+            };
+            client.Send(exception);
+
+            yield return new WaitForEndOfFrame();
+            Assert.IsTrue(trigger);
+            yield return null;
+        }
     }
 }
diff --git a/Tests/Runtime/Mocks/BacktraceDatabaseContextMock.cs b/Tests/Runtime/Mocks/BacktraceDatabaseContextMock.cs
diff --git a/Tests/Runtime/Mocks/BacktraceDatabaseContextMock.cs.meta b/Tests/Runtime/Mocks/BacktraceDatabaseContextMock.cs.meta
diff --git a/Tests/Runtime/RateLimit/BacktraceClientRateLimitTests.cs b/Tests/Runtime/RateLimit/BacktraceClientRateLimitTests.cs
@@ -20,7 +20,9 @@ public void Setup()
             AfterSetup();
         }
 
-        private static int[] _rateLimitTest = new int[] { 5, 10, 20 };
+#pragma warning disable IDE0052 // This parameter is used by TestReportLimit_ShouldntHitRateLimit_AllReportsShouldBeInBacktrace test (as a parameter)
+        private static readonly int[] _rateLimitTest = new int[] { 5, 10, 20 };
+#pragma warning restore IDE0052 
 
         [UnityTest]
         public IEnumerator TestReportLimit_ShouldntHitRateLimit_AllReportsShouldBeInBacktrace([ValueSource("_rateLimitTest")] int reportPerMin)
diff --git a/package.json b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "io.backtrace.unity",
   "displayName": "Backtrace",
-  "version": "3.5.0",
+  "version": "3.5.1-preview.1",
   "unity": "2017.1",
   "description": "Backtrace's integration with Unity games allows customers to capture and report handled and unhandled Unity exceptions to their Backtrace instance, instantly offering the ability to prioritize and debug software errors.",
   "keywords": [

Original file line number	Diff line number	Diff line change
`@@ -729,7 +729,7 @@ public bool EnableBreadcrumbsSupport()`
`729`	`729`	`{`
`730`	`730`	`return false;`
`731`	`731`	`}`
`732`		`- return Breadcrumbs.EnableBreadcrumbs(Configuration.BacktraceBreadcrumbsLevel, Configuration.LogLevel);`
	`732`	`+ return _breadcrumbs.EnableBreadcrumbs(Configuration.BacktraceBreadcrumbsLevel, Configuration.LogLevel);`
`733`	`733`	`}`
`734`	`734`	`}`
`735`	`735`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,12 +12,21 @@ internal static bool HasFlag(this Enum variable, Enum value)`
`12`	`12`	`{`
`13`	`13`	`throw new ArgumentException("The checked flag is not from the same type as the checked variable.");`
`14`	`14`	`}`
	`15`	`+ // Get the type code of the enumeration`
	`16`	`+ var typeCode = variable.GetTypeCode();`
`15`	`17`
`16`		`- Convert.ToUInt64(value);`
`17`		`- ulong num = Convert.ToUInt64(value);`
`18`		`- ulong num2 = Convert.ToUInt64(variable);`
	`18`	`+ // If the underlying type of the flag is signed`
	`19`	`+ if (typeCode == TypeCode.SByte \|\| typeCode == TypeCode.Int16 \|\| typeCode == TypeCode.Int32 \|\| typeCode == TypeCode.Int64)`
	`20`	`+ {`
	`21`	`+ return (Convert.ToInt64(variable) & Convert.ToInt64(value)) != 0;`
	`22`	`+ }`
`19`	`23`
`20`		`- return (num2 & num) == num;`
	`24`	`+ // If the underlying type of the flag is unsigned`
	`25`	`+ if (typeCode == TypeCode.Byte \|\| typeCode == TypeCode.UInt16 \|\| typeCode == TypeCode.UInt32 \|\| typeCode == TypeCode.UInt64)`
	`26`	`+ {`
	`27`	`+ return (Convert.ToUInt64(variable) & Convert.ToUInt64(value)) != 0;`
	`28`	`+ }`
	`29`	`+ return false;`
`21`	`30`	`}`
`22`	`31`	`#endif`
`23`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,11 @@ namespace Backtrace.Unity.Extensions`
`6`	`6`	`internal static class StreamExtensions`
`7`	`7`	`{`
`8`	`8`	`#if !(NET_STANDARD_2_0 && NET_4_6)`
	`9`	`+ // We pick a value that is the largest multiple of 4096 that is still smaller than the large object heap threshold (85K).`
	`10`	`+ // The CopyTo/CopyToAsync buffer is short-lived and is likely to be collected at Gen0, and it offers a significant`
	`11`	`+ // improvement in Copy performance.`
	`12`	`+ private const int _DefaultCopyBufferSize = 81920;`
	`13`	`+`
`9`	`14`	`public static void CopyTo(this Stream original, Stream destination)`
`10`	`15`	`{`
`11`	`16`	`if (destination == null)`
`@@ -29,7 +34,7 @@ public static void CopyTo(this Stream original, Stream destination)`
`29`	`34`	`throw new NotSupportedException("NotSupportedException destination");`
`30`	`35`	`}`
`31`	`36`
`32`		`- byte[] array = new byte[4096];`
	`37`	`+ byte[] array = new byte[_DefaultCopyBufferSize];`
`33`	`38`	`int count;`
`34`	`39`	`while ((count = original.Read(array, 0, array.Length)) != 0)`
`35`	`40`	`{`
Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,8 @@`
`5`	`5`	`using System.Globalization;`
`6`	`6`	`using UnityEngine;`
`7`	`7`	`using UnityEngine.SceneManagement;`
	`8`	`+`
	`9`	`+[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("Backtrace.Unity.Tests.Runtime")]`
`8`	`10`	`namespace Backtrace.Unity.Model.JsonData`
`9`	`11`	`{`
`10`	`12`	`/// <summary>`
`@@ -15,14 +17,24 @@ public class Annotations`
`15`	`17`	`/// <summary>`
`16`	`18`	`/// Backward compatibility helper`
`17`	`19`	`/// </summary>`
`18`		`- private static Dictionary<string, string> _environmentVariablesCache;`
	`20`	`+ internal static Dictionary<string, string> _environmentVariablesCache;`
	`21`	`+`
	`22`	`+ /// <summary>`
	`23`	`+ /// Determinate if static helper should load environment variables or not.`
	`24`	`+ /// </summary>`
	`25`	`+ internal static bool VariablesLoaded;`
	`26`	`+`
	`27`	`+ /// <summary>`
	`28`	`+ /// Loaded environment variables`
	`29`	`+ /// </summary>`
`19`	`30`	`public static Dictionary<string, string> EnvironmentVariablesCache`
`20`	`31`	`{`
`21`	`32`	`get`
`22`	`33`	`{`
`23`		`- if (_environmentVariablesCache == null)`
	`34`	`+ if (VariablesLoaded == false)`
`24`	`35`	`{`
`25`	`36`	`_environmentVariablesCache = SetEnvironmentVariables();`
	`37`	`+ VariablesLoaded = true;`
`26`	`38`	`}`
`27`	`39`	`return _environmentVariablesCache;`
`28`	`40`	`}`
`@@ -31,24 +43,19 @@ public static Dictionary<string, string> EnvironmentVariablesCache`
`31`	`43`	`_environmentVariablesCache = value;`
`32`	`44`	`}`
`33`	`45`	`}`
	`46`	`+`
`34`	`47`	`/// <summary>`
`35`		`- /// Backward compatibility helper`
	`48`	`+ /// Backward compatibility - local reference to environment variables`
`36`	`49`	`/// </summary>`
`37`		`- private Dictionary<string, string> _environmentVariables;`
`38`		`-`
`39`	`50`	`public Dictionary<string, string> EnvironmentVariables`
`40`	`51`	`{`
`41`	`52`	`get`
`42`	`53`	`{`
`43`		`- if (_environmentVariables == null)`
`44`		`- {`
`45`		`- _environmentVariables = EnvironmentVariablesCache;`
`46`		`- }`
`47`		`- return _environmentVariables;`
	`54`	`+ return EnvironmentVariablesCache;`
`48`	`55`	`}`
`49`	`56`	`set`
`50`	`57`	`{`
`51`		`- _environmentVariables = value;`
	`58`	`+ EnvironmentVariablesCache = value;`
`52`	`59`	`}`
`53`	`60`	`}`
`54`	`61`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -275,7 +275,6 @@ public void Dispose()`
`275`	`275`	`/// </summary>`
`276`	`276`	`public void Clear()`
`277`	`277`	`{`
`278`		`- var records = BatchRetry.SelectMany(n => n.Value);`
`279`	`278`	`TotalRecords = 0;`
`280`	`279`	`TotalSize = 0;`
`281`	`280`	`//clear all existing batches`
Original file line number	Diff line number	Diff line change
`@@ -167,15 +167,10 @@ public void RemoveOrphaned(IEnumerable<BacktraceDatabaseRecord> existingRecords)`
`167`	`167`	`file.Delete();`
`168`	`168`	`}`
`169`	`169`	`}`
`170`		`-#pragma warning disable CS0168`
`171`	`170`	`catch (Exception e)`
`172`	`171`	`{`
`173`		`-#if DEBUG`
`174`		`- Debug.Log(e.ToString());`
`175`		`-#endif`
`176`		`- Debug.LogWarning(string.Format("Cannot remove file in path: {0}", file.FullName));`
	`172`	`+ Debug.LogWarning(string.Format("Cannot remove file in path: {0}. Reason: {1}", file.FullName, e.Message));`
`177`	`173`	`}`
`178`		`-#pragma warning restore CS0168`
`179`	`174`	`}`
`180`	`175`	`}`
`181`	`176`