Version 3.2.6 - Sampling improvements (#55)

* Apply sampling only to errors type error - not exception

* Don't add the same key twice

* Correct classifier name -UnhandledException

* Changelog update + unhandled classifier name update

* Labels update

* classifier rename

Author: konraddysput

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Backtrace Unity Release Notes
 
+## Version 3.2.6
+- `BacktraceClient` will apply sampling only to errors lacking exception information.
+- Fixed annotations nullable value.
+- Renamed `BacktraceUnhandledException` classifier to `error`.
+- Fixed nullable environment annotation value.
+
 ## 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.

Editor/BacktraceConfigurationLabels.cs

@@ -8,7 +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_SAMPLING = "Log random sampling rate";
         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";

README.md

@@ -139,7 +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. 
+- Log random sampling rate - Enables a new random sampling mechanism for error message - **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 error messages 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.

Runtime/BacktraceClient.cs

@@ -20,7 +20,7 @@ public class BacktraceClient : MonoBehaviour, IBacktraceClient
     {
         public BacktraceConfiguration Configuration;
 
-        public const string VERSION = "3.2.5";
+        public const string VERSION = "3.2.6";
         public bool Enabled { get; private set; }
 
         /// <summary>
@@ -682,10 +682,37 @@ internal void HandleUnityMessage(string message, string stackTrace, LogType type
             }
             var unityMessage = new BacktraceUnityMessage(message, stackTrace, type);
             _backtraceLogManager.Enqueue(unityMessage);
-            if (Configuration.HandleUnhandledExceptions && unityMessage.IsUnhandledException() && !SamplingShouldSkip())
+            if (Configuration.HandleUnhandledExceptions && unityMessage.IsUnhandledException())
             {
-                var exception = new BacktraceUnhandledException(unityMessage.Message, unityMessage.StackTrace);
-                SendUnhandledException(exception);
+                BacktraceUnhandledException exception = null;
+                var invokeSkipApi = true;
+
+                // detect sampling flow
+                // we should apply sampling only to unhandled exceptions that are type LogType == Error
+                // log type error won't provide full exception information
+                if (type == LogType.Error && SamplingShouldSkip())
+                {
+                    if (SkipReport != null || Configuration.ReportFilterType.HasFlag(ReportFilterType.UnhandledException))
+                    {
+                        exception = new BacktraceUnhandledException(unityMessage.Message, unityMessage.StackTrace);
+                        if (ShouldSkipReport(ReportFilterType.UnhandledException, exception, string.Empty))
+                        {
+                            return;
+                        }
+                        invokeSkipApi = false;
+                    }
+                    else
+                    {
+                        return;
+                    }
+                }
+
+                if (exception == null)
+                {
+                    exception = new BacktraceUnhandledException(unityMessage.Message, unityMessage.StackTrace);
+                }
+
+                SendUnhandledException(exception, invokeSkipApi);
             }
         }
 
@@ -708,19 +735,19 @@ private bool SamplingShouldSkip()
 #endif
         }
 
-        private void SendUnhandledException(BacktraceUnhandledException exception)
+        private void SendUnhandledException(BacktraceUnhandledException exception, bool invokeSkipApi = true)
         {
             if (OnUnhandledApplicationException != null)
             {
                 OnUnhandledApplicationException.Invoke(exception);
             }
-            if (ShouldSendReport(exception, null, null))
+            if (ShouldSendReport(exception, null, null, invokeSkipApi))
             {
                 SendReport(new BacktraceReport(exception));
             }
         }
 
-        private bool ShouldSendReport(Exception exception, List<string> attachmentPaths, Dictionary<string, string> attributes)
+        private bool ShouldSendReport(Exception exception, List<string> attachmentPaths, Dictionary<string, string> attributes, bool invokeSkipApi = true)
         {
             if (!Enabled)
             {
@@ -736,7 +763,7 @@ private bool ShouldSendReport(Exception exception, List<string> attachmentPaths,
             }
 
 
-            if (ShouldSkipReport(filterType, exception, string.Empty))
+            if (invokeSkipApi && ShouldSkipReport(filterType, exception, string.Empty))
             {
                 return false;
             }

Runtime/Model/BacktraceConfiguration.cs

@@ -49,7 +49,7 @@ public class BacktraceConfiguration : ScriptableObject
         /// <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" +
+        [Tooltip("Log random sampling rate - 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.")]

Runtime/Model/BacktraceUnhandledException.cs

@@ -365,7 +365,7 @@ private BacktraceStackFrame SetDefaultStackTraceInformation(string frameString)
         /// </summary>
         private void TrySetClassifier()
         {
-            Classifier = "BacktraceUnhandledException";
+            Classifier = "error";
             if (string.IsNullOrEmpty(_message))
             {
                 return;

Runtime/Model/JsonData/Annotations.cs

@@ -40,7 +40,12 @@ private static Dictionary<string, string> SetEnvironmentVariables()
             var environmentVariables = new Dictionary<string, string>();
             foreach (DictionaryEntry variable in Environment.GetEnvironmentVariables())
             {
-                environmentVariables.Add(variable.Key.ToString(), Regex.Escape(variable.Value.ToString() ?? "NULL"));
+                if (variable.Key == null)
+                {
+                    continue;
+                }
+                var value = variable.Value == null ? "NULL" : variable.Value.ToString();
+                environmentVariables.Add(variable.Key.ToString(), value);
             }
             return environmentVariables;
         }

Tests/Runtime/BacktraceStackTraceTests.cs

@@ -396,7 +396,7 @@ public void TestClassifierSetter_DontSetClassifierIfClassifierIsNotAvailable_Sho
             // should guess classifier based on first stack frame
             string message = string.Empty;
             var exception = new BacktraceUnhandledException(message, stackTrace);
-            Assert.AreEqual("BacktraceUnhandledException", exception.Classifier);
+            Assert.AreEqual("error", exception.Classifier);
         }
 
 

package.json

@@ -1,7 +1,7 @@
 {
   "name": "io.backtrace.unity",
   "displayName": "Backtrace",
-  "version": "3.2.5",
+  "version": "3.2.6",
   "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": [