Version 3.2.5 (#53)

* Squashed commit of the following:

commit c4d0f53
Author: konraddysput <konrad.dysput@gmail.com>
Date:   Mon Nov 30 17:29:08 2020 +0100

    typo fixed

commit 3b723e2
Author: konraddysput <konrad.dysput@gmail.com>
Date:   Mon Nov 30 17:27:23 2020 +0100

    Reverted crashpad attributes

commit 8f654b8
Author: konraddysput <konrad.dysput@gmail.com>
Date:   Thu Nov 26 12:47:12 2020 +0100

    Meta fix

* Squashed commit of the following:

commit d2eecc1
Author: konraddysput <konrad.dysput@gmail.com>
Date:   Mon Nov 30 17:22:03 2020 +0100

    Runtime initialization

* Readme/Changelog update

* Sampling support

* Api improvements

* Advanced configuration example

* Code rewview suggestions

* Readme/changelog update

* Clarification in Unity tooltip

Author: konraddysput

Android/lib/x86/libbacktrace-native.so.meta

@@ -1,5 +1,17 @@
 # Backtrace Unity Release Notes
 
+## Version 3.2.5
+- Added `BacktraceClient` Initialization method that allows developer to intialize Backtrace integration without adding game object to game scene.
+- Fixed invalid `meta` file for iOS integration for Unity 2019.2.13f1.
+- HTTP communication messages improvements - right now Backtrace-Unity plugin will print only one error message when network failure happen. Backtrace-Unity will stop printing failures until next successfull report upload.
+- Sampling skip fraction - Enables a new random sampling mechanism for unhandled exceptions - by default sampling is equal to 0.01 - which means only 1% of randomply sampling reports will be send to Backtrace. If you would like to send all unhandled exceptions to Backtrace - please replace 0.01 value with 1. 
+
+**Be aware**
+
+By default Backtrace library will send only 1% of your reports - please change this value if you would like to send more unhandled exceptions to server.
+
+
+
 ## Version 3.2.4
 - Fixed Backtrace-Unity NDK integration database path.
 

CHANGELOG.md

@@ -75,6 +75,10 @@ public override void OnInspectorGUI()
                     serializedObject.FindProperty("DestroyOnLoad"),
                     new GUIContent(BacktraceConfigurationLabels.LABEL_DESTROY_CLIENT_ON_SCENE_LOAD));
 
+                EditorGUILayout.PropertyField(
+                    serializedObject.FindProperty("Sampling"),
+                    new GUIContent(BacktraceConfigurationLabels.LABEL_SAMPLING));
+
                 SerializedProperty gameObjectDepth = serializedObject.FindProperty("GameObjectDepth");
                 EditorGUILayout.PropertyField(gameObjectDepth, new GUIContent(BacktraceConfigurationLabels.LABEL_GAME_OBJECT_DEPTH));
 

Editor/BacktraceConfigurationEditor.cs

@@ -8,6 +8,7 @@ internal static class BacktraceConfigurationLabels
         internal static string LABEL_HANDLE_UNHANDLED_EXCEPTION = "Handle unhandled exceptions";
 
         internal static string LABEL_DESTROY_CLIENT_ON_SCENE_LOAD = "Destroy client on new scene load (false - Backtrace managed)";
+        internal static string LABEL_SAMPLING = "Sampling skip fraction";
         internal static string LABEL_HANDLE_ANR = "Handle ANR (Application not responding)";
         internal static string CAPTURE_NATIVE_CRASHES = "Capture native crashes";
         internal static string LABEL_REPORT_FILTER = "Filter reports";

Editor/BacktraceConfigurationLabels.cs

@@ -97,6 +97,32 @@ List of steps necessary to setup full Backtrace Unity integration.
 - Provide valid Backtrace client configuration and start using library!
   ![Full Backtrace configuration](./Documentation~/images/client-setup.PNG)
 
+## Integrating into your project via code
+
+One of the integration paths require to create game object in your game scene. If you would like to initialize Backtrace integration programatically, we recommend to use `Initialize` method available in `BacktraceClient` class.
+
+```csharp
+  var backtraceClient = BacktraceClient.Initialize(
+      url: serverUrl,
+      databasePath: "${Application.persistentDataPath}/sample/backtrace/path",
+      gameObjectName: "game-object-name",
+      attributes: attributes);
+```
+
+If you need to use more advanced configuration, `Initialize` method accepts a `BacktraceConfiguration` scriptable object. 
+```csharp
+  var configuration = ScriptableObject.CreateInstance<BacktraceConfiguration>();
+  configuration.ServerUrl = serverUrl;
+  configuration.Enabled = true;
+  configuration.DatabasePath = "${Application.persistentDataPath}/sample/backtrace/path";
+  configuration.CreateDatabase = true;
+  configuration.Sampling = 0.002;
+  _backtraceClient = BacktraceClient.Initialize(
+      configuration,
+      gameObjectName: "game-object-name",
+      attributes: attributes);
+```
+
 ## Plugin best practices
 
 Plugin allows you to define maximum depth of game objects. By default its disabled (Game object depth is equal to -1). If you will use 0 as maximum depth of game object we will use default game object limit - 16. If you would like to specify game object depth size to n, please insert n in Backtrace configuration text box. If you require game obejct depth to be above 30, please contact support.
@@ -113,6 +139,7 @@ The following is a reference guide to the Backtrace Client fields:
 - Send unhandled native game crashes on startup: Try to find game native crashes and send them on Game startup.
 - Handle unhandled exceptions: Toggle this on or off to set the library to handle unhandled exceptions that are not captured by try-catch blocks.
 - Symbols upload token - If you want to upload Unity debug symbols for Android NDK Native Crash debugging, enter your Backtrace Symbol upload token here. This option is available only in Android build.
+- Sampling skip fraction - Enables a new random sampling mechanism for unhandled exceptions - **by default** sampling is equal to **0.01** - which means only **1%** of randomply sampling **reports will be send** to Backtrace. If you would like to send all unhandled exceptions to Backtrace - please replace 0.01 value with 1. 
 - Game Object Depth Limit: Allows developer to filter number of game object childrens in Backtrace report.
 - Collect last n game logs: Collect last n number of logs generated by game. 
 - Enabled performance statistics: Allows `BacktraceClient` to measure execution time and include performance information as report attributes.

README.md

@@ -20,7 +20,7 @@ public class BacktraceClient : MonoBehaviour, IBacktraceClient
     {
         public BacktraceConfiguration Configuration;
 
-        public const string VERSION = "3.2.4";
+        public const string VERSION = "3.2.5";
         public bool Enabled { get; private set; }
 
         /// <summary>
@@ -53,6 +53,10 @@ public string this[string index]
         /// <param name="attributes">attributes dictionary</param>
         public void SetAttributes(Dictionary<string, string> attributes)
         {
+            if (attributes == null)
+            {
+                return;
+            }
             foreach (var attribute in attributes)
             {
                 this[attribute.Key] = attribute.Value;
@@ -258,6 +262,76 @@ internal ReportLimitWatcher ReportLimitWatcher
 
         private BacktraceLogManager _backtraceLogManager;
 
+
+        /// <summary>
+        /// Initialize new Backtrace integration
+        /// </summary>
+        /// <param name="configuration">Backtrace configuration scriptable object</param>
+        /// <param name="attributes">Client side attributes</param>
+        /// <param name="gameObjectName">game object name</param>
+        /// <returns>Backtrace client</returns>
+        public static BacktraceClient Initialize(BacktraceConfiguration configuration, Dictionary<string, string> attributes = null, string gameObjectName = "BacktraceClient")
+        {
+            if (string.IsNullOrEmpty(gameObjectName))
+            {
+                throw new ArgumentException("Missing game object name");
+            }
+
+            if (configuration == null || string.IsNullOrEmpty(configuration.ServerUrl))
+            {
+                throw new ArgumentException("Missing valid configuration");
+            }
+
+            if (Instance != null)
+            {
+                return Instance;
+            }
+            var backtrackGameObject = new GameObject(gameObjectName, typeof(BacktraceClient), typeof(BacktraceDatabase));
+            BacktraceClient backtraceClient = backtrackGameObject.GetComponent<BacktraceClient>();
+            BacktraceDatabase backtraceDatabase = backtrackGameObject.GetComponent<BacktraceDatabase>();
+
+            backtraceDatabase.Configuration = configuration;
+            backtraceClient.Configuration = configuration;
+            backtrackGameObject.SetActive(true);
+            backtraceClient.Refresh();
+            backtraceClient.SetAttributes(attributes);
+
+            return backtraceClient;
+        }
+
+        /// <summary>
+        /// Initialize new Backtrace integration with database path. Note - database path will be auto created by Backtrace Unity plugin
+        /// </summary>
+        /// <param name="url">Server url</param>
+        /// <param name="databasePath">Database path</param>
+        /// <param name="attributes">Client side attributes</param>
+        /// <param name="gameObjectName">game object name</param>
+        /// <returns>Backtrace client</returns>
+        public static BacktraceClient Initialize(string url, string databasePath, Dictionary<string, string> attributes = null, string gameObjectName = "BacktraceClient")
+        {
+            var configuration = ScriptableObject.CreateInstance<BacktraceConfiguration>();
+            configuration.ServerUrl = url;
+            configuration.Enabled = true;
+            configuration.DatabasePath = databasePath;
+            configuration.CreateDatabase = true;
+            return Initialize(configuration, attributes, gameObjectName);
+        }
+
+        /// <summary>
+        /// Initialize new Backtrace integration
+        /// </summary>
+        /// <param name="url">Server url</param>
+        /// <param name="attributes">Client side attributes</param>
+        /// <param name="gameObjectName">game object name</param>
+        /// <returns>Backtrace client</returns>
+        public static BacktraceClient Initialize(string url, Dictionary<string, string> attributes = null, string gameObjectName = "BacktraceClient")
+        {
+            var configuration = ScriptableObject.CreateInstance<BacktraceConfiguration>();
+            configuration.ServerUrl = url;
+            configuration.Enabled = false;
+            return Initialize(configuration, attributes, gameObjectName);
+        }
+
         public void OnDisable()
         {
             Enabled = false;
@@ -468,6 +542,7 @@ record = Database.Add(data);
 
                     if (record.Duplicated)
                     {
+                        record.Dispose();
                         yield break;
                     }
                 }
@@ -582,7 +657,7 @@ internal void OnAnrDetected(string stackTrace)
 #endif
 
         /// <summary>
-        /// Handle Untiy unhandled exceptions
+        /// Handle Unity unhandled exceptions
         /// </summary>
         private void CaptureUnityMessages()
         {
@@ -601,15 +676,38 @@ private void CaptureUnityMessages()
         /// <param name="type">log type</param>
         internal void HandleUnityMessage(string message, string stackTrace, LogType type)
         {
+            if (!Enabled)
+            {
+                return;
+            }
             var unityMessage = new BacktraceUnityMessage(message, stackTrace, type);
             _backtraceLogManager.Enqueue(unityMessage);
-            if (Configuration.HandleUnhandledExceptions && unityMessage.IsUnhandledException())
+            if (Configuration.HandleUnhandledExceptions && unityMessage.IsUnhandledException() && !SamplingShouldSkip())
             {
                 var exception = new BacktraceUnhandledException(unityMessage.Message, unityMessage.StackTrace);
                 SendUnhandledException(exception);
             }
         }
 
+        /// <summary>
+        /// Skip sending report when sampling hit. This feature is enabled only for unhandled exception handler
+        /// </summary>
+        /// <returns>True, when client should skip report, otherwise false.</returns>
+        private bool SamplingShouldSkip()
+        {
+            // Sampling won't work in Editor mode - from editor we're allowing to send all type
+            // of possible errors.
+#if UNITY_EDITOR
+            return false;
+#else
+            if (!Configuration || Configuration.Sampling == 1)
+            {
+                return false;
+            }
+            return UnityEngine.Random.Range(0f, 1f) > Configuration.Sampling;
+#endif
+        }
+
         private void SendUnhandledException(BacktraceUnhandledException exception)
         {
             if (OnUnhandledApplicationException != null)

Runtime/BacktraceClient.cs

@@ -399,13 +399,13 @@ private void SendData(BacktraceDatabaseRecord record)
                 StartCoroutine(
                      BacktraceApi.Send(backtraceData, record.Attachments, queryAttributes, (BacktraceResult sendResult) =>
                      {
+                         record.Dispose();
                          if (sendResult.Status != BacktraceResultStatus.ServerError && sendResult.Status != BacktraceResultStatus.NetworkError)
                          {
                              Delete(record);
                          }
                          else
                          {
-                             record.Dispose();
                              BacktraceDatabaseContext.IncrementBatchRetry();
                              return;
                          }
@@ -478,7 +478,7 @@ protected virtual bool InitializeDatabasePaths()
                 databaseDirExists = dirInfo.Exists;
             }
 
-            if(!databaseDirExists)
+            if (!databaseDirExists)
             {
                 Debug.LogWarning(string.Format("Backtrace database path doesn't exist. Database path: {0}", DatabasePath));
 
@@ -534,8 +534,9 @@ private bool ValidateDatabaseSize()
             //check how many records are stored in database
             //remove in case when we want to store one more than expected number
             //If record count == 0 then we ignore this condition
-            if (BacktraceDatabaseContext.Count() + 1 > DatabaseSettings.MaxRecordCount && DatabaseSettings.MaxRecordCount != 0 && !BacktraceDatabaseContext.RemoveLastRecord())
-            {
+            var noMoreSpaceForReport = BacktraceDatabaseContext.Count() + 1 > DatabaseSettings.MaxRecordCount && DatabaseSettings.MaxRecordCount != 0;
+            if (noMoreSpaceForReport)
+            { 
                 return false;
             }
 

Runtime/BacktraceDatabase.cs

@@ -46,6 +46,16 @@ public class BacktraceConfiguration : ScriptableObject
         [Tooltip("Backtrace-client by default will be available on each scene. Once you initialize Backtrace integration, you can fetch Backtrace game object from every scene. In case if you don't want to have Backtrace-unity integration available by default in each scene, please set this value to true.")]
         public bool DestroyOnLoad = false;
 
+        /// <summary>
+        /// Sampling configuration - fractional sampling allows to drop some % of unhandled exception.
+        /// </summary>
+        [Tooltip("Sampling skip fraction - Enables a random sampling mechanism for unhandled exceptions - by default sampling is equal to 0.01 - which means only 1% of randomply sampling reports will be send to Backtrace. \n" +
+            "* 1 - means 100% of unhandled exception reports will be reported by library,\n" +
+            "* 0.1 - means 10% of unhandled exception reports will be reported by library,\n" +
+            "* 0 - means library is going to drop all unhandled exception.")]
+        [Range(0, 1)]
+        public double Sampling = 0.01d;
+
         /// <summary>
         /// Backtrace report filter type
         /// </summary>

Runtime/Model/BacktraceConfiguration.cs

@@ -23,6 +23,11 @@ internal class BacktraceApi : IBacktraceApi
         [Obsolete("RequestHandler is obsolete. BacktraceApi won't be able to provide BacktraceData in every situation")]
         public Func<string, BacktraceData, BacktraceResult> RequestHandler { get; set; }
 
+        /// <summary>
+        /// Determine if BacktraceApi should display failure message on HTTP failure.
+        /// </summary>
+        private bool _shouldDisplayFailureMessage = true;
+
         /// <summary>
         /// Event triggered when server is unvailable
         /// </summary>
@@ -127,6 +132,12 @@ public IEnumerator SendMinidump(string minidumpPath, IEnumerable<string> attachm
             var boundaryIdBytes = UnityWebRequest.GenerateBoundary();
             using (var request = UnityWebRequest.Post(_minidumpUrl, formData, boundaryIdBytes))
             {
+#if UNITY_2018_4_OR_NEWER
+                if (_ignoreSslValidation)
+                {
+                    request.certificateHandler = new BacktraceSelfSSLCertificateHandler();
+                }
+#endif
                 request.SetRequestHeader("Content-Type", string.Format("multipart/form-data; boundary={0}", Encoding.UTF8.GetString(boundaryIdBytes)));
                 request.timeout = 15000;
                 yield return request.SendWebRequest();
@@ -229,6 +240,12 @@ public IEnumerator Send(string json, List<string> attachments, Dictionary<string
             var boundaryIdBytes = UnityWebRequest.GenerateBoundary();
             using (var request = UnityWebRequest.Post(requestUrl, formData, boundaryIdBytes))
             {
+#if UNITY_2018_4_OR_NEWER
+                if (_ignoreSslValidation)
+                {
+                    request.certificateHandler = new BacktraceSelfSSLCertificateHandler();
+                }
+#endif
                 request.SetRequestHeader("Content-Type", "multipart/form-data; boundary=" + Encoding.UTF8.GetString(boundaryIdBytes));
                 request.timeout = 15000;
                 yield return request.SendWebRequest();
@@ -249,6 +266,7 @@ public IEnumerator Send(string json, List<string> attachments, Dictionary<string
                 else if (request.responseCode == 200 && (!request.isNetworkError || !request.isHttpError))
                 {
                     result = BacktraceResult.FromJson(request.downloadHandler.text);
+                    _shouldDisplayFailureMessage = true;
 
                     if (OnServerResponse != null)
                     {
@@ -282,9 +300,14 @@ public IEnumerator Send(string json, List<string> attachments, Dictionary<string
 
         private void PrintLog(UnityWebRequest request)
         {
+            if(!_shouldDisplayFailureMessage)
+            {
+                return;
+            }
+            _shouldDisplayFailureMessage = false;
             Debug.LogWarning(string.Format("{0}{1}", string.Format("[Backtrace]::Reponse code: {0}, Response text: {1}",
                     request.responseCode,
-                    request.downloadHandler.text),
+                    request.error),
                 "\n Please check provided url to Backtrace service or learn more from our integration guide: https://support.backtrace.io/hc/en-us/articles/360040515991-Unity-Integration-Guide"));
         }
 

Runtime/Services/BacktraceApi.cs

@@ -236,7 +236,6 @@ public void Delete(BacktraceDatabaseRecord record)
                         }
                         //decrement total size of database
                         TotalSize -= value.Size;
-                        System.Diagnostics.Debug.WriteLine(string.Format("[Delete] :: Total Size = {0}", TotalSize));
                         return;
                     }
                 }
@@ -261,16 +260,7 @@ public bool RemoveLastRecord()
             var record = LastOrDefault();
             if (record != null)
             {
-                record.Delete();
-                if (record.Count > 0)
-                {
-                    TotalRecords = TotalRecords - record.Count;
-                }
-                else
-                {
-                    TotalRecords--;
-                }
-                TotalSize -= record.Size;
+                Delete(record);
                 return true;
             }
             return false;