Version 2.1.2 (#18)

- `BacktraceReport` will generate report fingerprint for exceptions without stack trace.
- Changed game object depth default property value.
- Added Exception information to the Annotation object.

Author: konraddysput

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Backtrace Unity Release Notes
 
+## Version 2.1.2
+
+- `BacktraceReport` will generate report fingerprint for exceptions without stack trace.
+- Changed game object depth default property value.
+- Added Exception information to the Annotation object.
+
 ## Version 2.1.1
 
 - UPM modifications - fixed editor assembly definition,

README.md

@@ -59,7 +59,7 @@ Watch this 1 minute silent video to see the Integration and Configuration in act
 
 ## 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 would like to include all game objects, please select 0. If you would like to specify game object depth size to n, please insert n in Backtrace configuration text box.
+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.
 
 ## Backtrace Client and Offline Database Settings
 

Runtime/BacktraceClient.cs

@@ -201,7 +201,10 @@ public void Refresh()
 
 #endif
 
-            Annotations.GameObjectDepth = Configuration.GameObjectDepth;
+            // set maximum game object depth
+            Annotations.GameObjectDepth = Configuration.GameObjectDepth == 0
+                ? 16 // default maximum game object size
+                : Configuration.GameObjectDepth;
             HandleUnhandledExceptions();
             _reportLimitWatcher = new ReportLimitWatcher(Convert.ToUInt32(Configuration.ReportPerMin));
 
@@ -422,7 +425,7 @@ public void HandleUnhandledExceptions()
         /// </summary>
         /// <param name="message">Log message</param>
         /// <param name="stackTrace">Log stack trace</param>
-        /// <param name="type">log type</param>
+        /// <param name="type">log type</param> 
         private void HandleException(string message, string stackTrace, LogType type)
         {
             if ((type == LogType.Exception || type == LogType.Error)

Runtime/Common/StackFrameHelper.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Text;
+
+[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("Backtrace.Unity.Tests.Runtime")]
+namespace Backtrace.Unity.Extensions
+{
+    internal static class StringHelper
+    {
+        /// <summary>
+        /// Remove all characters from string that aren't letter.
+        /// </summary>
+        internal static string OnlyLetters(this string source)
+        {
+            if (string.IsNullOrEmpty(source))
+            {
+                return string.Empty;
+            }
+            return string.Concat(source.Where(n => char.IsLetter(n)));
+        }
+
+        /// <summary>
+        /// Create sha256 from string builder value
+        /// </summary>
+        /// <param name="value">string value</param>
+        /// <returns>sha256 string</returns>
+        internal static string GetSha(this StringBuilder source)
+        {
+            if (source == null)
+            {
+                return string.Empty;
+            }
+            return GetSha(source.ToString());
+        }
+
+        /// <summary>
+        /// Create sha256 from string value
+        /// </summary>
+        /// <param name="value">string value</param>
+        /// <returns>sha256 string</returns>
+        internal static string GetSha(this string source)
+        {
+            // generate empty sha which represents fingerprint in Backtrace 
+            // for empty string
+            if (string.IsNullOrEmpty(source))
+            {
+                return "0000000000000000000000000000000000000000000000000000000000000000";
+            }
+            using (var sha256Hash = SHA256.Create())
+            {
+                var bytes = sha256Hash.ComputeHash(Encoding.ASCII.GetBytes(source));
+                return Convert.ToBase64String(bytes);
+            }
+        }
+    }
+}

Runtime/Extensions/StringExtensions.cs

@@ -5,7 +5,7 @@ namespace Backtrace.Unity.Extensions
     /// <summary>
     /// All extensions available for Thread class
     /// </summary>
-    public static class ThreadExtensions
+    internal static class ThreadExtensions
     {
         /// <summary>
         /// Generate a valid thread name for passed thread

Runtime/Common/StackFrameHelper.cs.meta renamed to Runtime/Extensions/StringExtensions.cs.meta

@@ -194,7 +194,7 @@ private void SetReportInformation()
             LangVersion = "Mono";
 #endif
 
-            AgentVersion = "2.1.1";
+            AgentVersion = "2.1.2";
             Classifier = Report.ExceptionTypeReport ? new[] { Report.Classifier } : null;
         }
     }

Runtime/Extensions/ThreadExtensions.cs

@@ -1,6 +1,7 @@
 using Backtrace.Newtonsoft;
 using Backtrace.Newtonsoft.Linq;
 using Backtrace.Unity.Common;
+using Backtrace.Unity.Extensions;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -190,6 +191,7 @@ public BacktraceReport(
             if (ExceptionTypeReport)
             {
                 Message = exception.Message;
+                SetReportFingerPrintForEmptyStackTrace();
             }
             Classifier = ExceptionTypeReport ? exception.GetType().Name : string.Empty;
             SetStacktraceInformation();
@@ -209,6 +211,20 @@ internal void SetMinidumpPath(string minidumpPath)
             AttachmentPaths.Add(minidumpPath);
         }
 
+        /// <summary>
+        /// Override default fingerprint for reports without faulting stack trace.
+        /// </summary>
+        internal void SetReportFingerPrintForEmptyStackTrace()
+        {
+            if (string.IsNullOrEmpty(Exception.StackTrace))
+            {
+                // set attributes instead of fingerprint to still allow our user to define customer
+                // fingerprints for reports without stack trace and apply deduplication rules in report flow.
+                Attributes["_mod_fingerprint"] = Exception.Message.OnlyLetters().GetSha();
+            }
+
+        }
+
         internal BacktraceData ToBacktraceData(Dictionary<string, object> clientAttributes)
         {
             return new BacktraceData(this, clientAttributes);

Runtime/Model/BacktraceData.cs

@@ -34,7 +34,7 @@ private void Initialize()
                 if (_exception is BacktraceUnhandledException)
                 {
                     var current = _exception as BacktraceUnhandledException;
-                    StackFrames.InsertRange(0,current.StackFrames);
+                    StackFrames.InsertRange(0, current.StackFrames);
                 }
                 else
                 {
@@ -56,7 +56,7 @@ private void Initialize()
 
         private void SetStacktraceInformation(StackFrame[] frames, bool generatedByException = false)
         {
-            if (frames == null)
+            if (frames == null || frames.Length == 0)
             {
                 return;
             }
@@ -73,7 +73,7 @@ private void SetStacktraceInformation(StackFrame[] frames, bool generatedByExcep
                 {
                     continue;
                 }
-                var backtraceFrame = new BacktraceStackFrame(frame, generatedByException);          
+                var backtraceFrame = new BacktraceStackFrame(frame, generatedByException);
                 StackFrames.Insert(startingIndex, backtraceFrame);
                 startingIndex++;
             }