Attachment support

Editor/BacktraceConfigurationEditor.cs

@@ -64,7 +64,6 @@ public override void OnInspectorGUI()
                  serializedObject.FindProperty("SendUnhandledGameCrashesOnGameStartup"),
                  new GUIContent(BacktraceConfigurationLabels.LABEL_SEND_UNHANDLED_GAME_CRASHES_ON_STARTUP));
 #endif
-
                 EditorGUILayout.PropertyField(
                        serializedObject.FindProperty("ReportFilterType"),
                        new GUIContent(BacktraceConfigurationLabels.LABEL_REPORT_FILTER));
@@ -93,6 +92,13 @@ public override void OnInspectorGUI()
                     EditorGUILayout.HelpBox("Please insert value greater or equal -1", MessageType.Error);
                 }
             }
+
+#if UNITY_ANDROID || UNITY_IOS
+            EditorGUILayout.PropertyField(
+                serializedObject.FindProperty("AttachmentPaths"),
+                new GUIContent(BacktraceConfigurationLabels.LABEL_REPORT_ATTACHMENTS));
+#endif
+
 #if !UNITY_SWITCH
             SerializedProperty enabled = serializedObject.FindProperty("Enabled");
             EditorGUILayout.PropertyField(enabled, new GUIContent(BacktraceConfigurationLabels.LABEL_ENABLE_DATABASE));

Editor/BacktraceConfigurationLabels.cs

@@ -18,6 +18,7 @@ internal static class BacktraceConfigurationLabels
             "(Early access) Send Out of memory exceptions to Backtrace";
 #endif
 #endif
+        internal static string LABEL_REPORT_ATTACHMENTS = "Report attachment paths";
         internal static string CAPTURE_NATIVE_CRASHES = "Capture native crashes";
         internal static string LABEL_REPORT_FILTER = "Filter reports";
         internal static string LABEL_NUMBER_OF_LOGS = "Collect last n game logs";

Runtime/BacktraceClient.cs

@@ -31,6 +31,11 @@ public class BacktraceClient : MonoBehaviour, IBacktraceClient
 
         internal readonly Stack<BacktraceReport> BackgroundExceptions = new Stack<BacktraceReport>();
 
+        /// <summary>
+        /// Client report attachments
+        /// </summary>
+        private List<string> _clientReportAttachments;
+
         /// <summary>
         /// Attribute object accessor
         /// </summary>
@@ -50,6 +55,26 @@ public string this[string index]
             }
         }
 
+        /// <summary>
+        /// Add attachment to managed reports.
+        /// Note: this option won't add attachment to your native reports. You can add attachments to
+        /// native reports only on BacktraceClient initialization.
+        /// </summary>
+        /// <param name="pathToAttachment">Path to attachment</param>
+        public void AddAttachment(string pathToAttachment)
+        {
+            _clientReportAttachments.Add(pathToAttachment);
+        }
+
+        /// <summary>
+        /// Returns list of defined path to attachments stored by Backtrace client.
+        /// </summary>
+        /// <returns>List of client attachments</returns>
+        public List<string> GetAttachments()
+        {
+            return _clientReportAttachments;
+        }
+
         /// <summary>
         /// Set client attributes that will be included in every report
         /// </summary>
@@ -271,6 +296,7 @@ internal ReportLimitWatcher ReportLimitWatcher
         /// </summary>
         /// <param name="configuration">Backtrace configuration scriptable object</param>
         /// <param name="attributes">Client side attributes</param>
+        /// param name="attachments">List of attachments </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")
@@ -313,9 +339,24 @@ public static BacktraceClient Initialize(BacktraceConfiguration configuration, D
         /// <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")
+        {
+            return Initialize(url, databasePath, attributes, null, gameObjectName);
+        }
+
+        /// <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="attachments">Paths to attachments that Backtrace client will include in managed/native reports</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[] attachments = null, string gameObjectName = "BacktraceClient")
         {
             var configuration = ScriptableObject.CreateInstance<BacktraceConfiguration>();
             configuration.ServerUrl = url;
+            configuration.AttachmentPaths = attachments;
             configuration.Enabled = true;
             configuration.DatabasePath = databasePath;
             configuration.CreateDatabase = true;
@@ -330,9 +371,23 @@ public static BacktraceClient Initialize(string url, string databasePath, Dictio
         /// <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")
+        {
+            return Initialize(url, attributes, new string[0], gameObjectName);
+        }
+
+        /// <summary>
+        /// Initialize new Backtrace integration
+        /// </summary>
+        /// <param name="url">Server url</param>
+        /// <param name="attributes">Client side attributes</param>
+        /// <param name="attachments">Paths to attachments that Backtrace client will include in managed/native reports</param>
+        /// <param name="gameObjectName">game object name</param>
+        /// <returns>Backtrace client</returns>
+        public static BacktraceClient Initialize(string url, Dictionary<string, string> attributes = null, string[] attachments = null, string gameObjectName = "BacktraceClient")
         {
             var configuration = ScriptableObject.CreateInstance<BacktraceConfiguration>();
             configuration.ServerUrl = url;
+            configuration.AttachmentPaths = attachments;
             configuration.Enabled = false;
             return Initialize(configuration, attributes, gameObjectName);
         }
@@ -358,7 +413,7 @@ public void Refresh()
             _current = Thread.CurrentThread;
             CaptureUnityMessages();
             _reportLimitWatcher = new ReportLimitWatcher(Convert.ToUInt32(Configuration.ReportPerMin));
-
+            _clientReportAttachments = Configuration.GetAttachmentPaths();
 
             BacktraceApi = new BacktraceApi(
                 credentials: new BacktraceCredentials(Configuration.GetValidServerUrl()),
@@ -668,6 +723,7 @@ private BacktraceData SetupBacktraceData(BacktraceReport report)
                 : _backtraceLogManager.ToSourceCode();
 
             report.AssignSourceCodeToReport(sourceCode);
+            report.AttachmentPaths.AddRange(_clientReportAttachments);
 
             // pass copy of dictionary to prevent overriding client attributes
             var result = report.ToBacktraceData(null, GameObjectDepth);

Runtime/Common/ClientPathHelper.cs

@@ -0,0 +1,66 @@
+using System;
+using System.IO;
+using UnityEngine;
+
+[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("Backtrace.Unity.Tests.Runtime")]
+namespace Backtrace.Unity.Common
+{
+    internal static class ClientPathHelper
+    {
+        /// <summary>
+        /// Parse Backtrace client path string to full path
+        /// </summary>
+        /// <param name="path">Backtrace path with interpolated string and other Backtrace's improvements</param>
+        /// <returns>Full path to Backtrace file/directory</returns>
+        internal static string GetFulLPath(string path)
+        {
+            if (string.IsNullOrEmpty(path))
+            {
+                return string.Empty;
+            }
+
+            return path.ParseInterpolatedString().GetFullPath();
+        }
+
+        private static string ParseInterpolatedString(this string path)
+        {
+            // check if string has any interpolated substring 
+            var interpolationStart = path.IndexOf("${");
+            if (interpolationStart == -1)
+            {
+                return path;
+            }
+            var interpolationEnd = path.IndexOf('}', interpolationStart);
+            if (interpolationEnd == -1)
+            {
+                return path;
+            }
+            var interpolationValue = path.Substring(interpolationStart, interpolationEnd - interpolationStart + 1);
+            if (string.IsNullOrEmpty(interpolationValue))
+            {
+                return path;
+            }
+
+            switch (interpolationValue.ToLower())
+            {
+                case "${application.persistentdatapath}":
+                    return path.Replace(interpolationValue, Application.persistentDataPath);
+                case "${application.datapath}":
+                    return path.Replace(interpolationValue, Application.dataPath);
+                default:
+                    return path;
+            }
+
+        }
+
+        private static string GetFullPath(this string path)
+        {
+            if (!Path.IsPathRooted(path))
+            {
+                path = Path.Combine(Application.persistentDataPath, path);
+            }
+            return Path.GetFullPath(path);
+
+        }
+    }
+}

Runtime/Model/BacktraceConfiguration.cs

@@ -1,6 +1,7 @@
 using Backtrace.Unity.Common;
 using Backtrace.Unity.Types;
 using System;
+using System.Collections.Generic;
 using System.IO;
 using UnityEngine;
 
@@ -161,7 +162,13 @@ public class BacktraceConfiguration : ScriptableObject
         /// Generate game screen shot when exception happen
         /// </summary>
         [Tooltip("Generate and attach screenshot of frame as exception occurs")]
-        public bool GenerateScreenshotOnException = false;
+        public bool GenerateScreenshotOnException = false;
+
+        /// <summary>
+        /// List of path to attachments that Backtrace client will include in the native and managed reports.
+        /// </summary>
+        [Tooltip("List of path to attachments that Backtrace client will include in the native and managed reports.")]
+        public string[] AttachmentPaths;
 
         /// <summary>
         /// Directory path where reports and minidumps are stored
@@ -213,7 +220,7 @@ public class BacktraceConfiguration : ScriptableObject
 
         /// <summary>
         /// Maximum number of retries
-        [Tooltip("If the database is unable to send its record, this setting specifies the maximum number of retries before the system gives up")]
+        [Tooltip("If the database is unable to send its record, this setting specifies the maximum number of retries before the system gives up.")]
         public int RetryLimit = 3;
 
         /// <summary>
@@ -222,9 +229,28 @@ public class BacktraceConfiguration : ScriptableObject
         [Tooltip("This specifies in which order records are sent to the Backtrace server.")]
         public RetryOrder RetryOrder;
 
+        /// <summary>
+        /// Get full paths to attachments added by client
+        /// </summary>
+        /// <returns>List of absolute path to attachments</returns>
+        public List<string> GetAttachmentPaths()
+        {
+            var result = new List<string>();
+            if (AttachmentPaths == null || AttachmentPaths.Length == 0)
+            {
+                return result;
+            }
+
+            foreach (var path in AttachmentPaths)
+            {
+                result.Add(ClientPathHelper.GetFulLPath(path));
+            }
+            return result;
+        }
+
         public string GetFullDatabasePath()
         {
-            return DatabasePathHelper.GetFullDatabasePath(DatabasePath);
+            return ClientPathHelper.GetFulLPath(DatabasePath);
         }
         public string CrashpadDatabasePath
         {

Runtime/Native/Android/NativeClient.cs

@@ -34,13 +34,13 @@ internal class NativeClient : INativeClient
         private Thread _anrThread;
 
         [DllImport("backtrace-native")]
-        private static extern bool Initialize(IntPtr submissionUrl, IntPtr databasePath, IntPtr handlerPath, IntPtr keys, IntPtr values);
+        private static extern bool Initialize(IntPtr submissionUrl, IntPtr databasePath, IntPtr handlerPath, IntPtr keys, IntPtr values, IntPtr attachments);
 
         [DllImport("backtrace-native")]
         private static extern bool AddAttribute(IntPtr key, IntPtr value);
 
         [DllImport("backtrace-native", EntryPoint = "DumpWithoutCrash")]
-        private static extern bool NativeReport(IntPtr message);
+        private static extern bool NativeReport(IntPtr message, bool setMainThreadAsFaultingThread);
 
         /// <summary>
         /// Native client built-in specific attributes
@@ -206,9 +206,10 @@ private void HandleNativeCrashes()
                 return;
             }
             // get default built-in Backtrace-Unity attributes
-            var backtraceAttributes = new BacktraceAttributes(null, null, true);
+            var backtraceAttributes = new BacktraceAttributes(null, null, true).Attributes;
 
             var minidumpUrl = new BacktraceCredentials(_configuration.GetValidServerUrl()).GetMinidumpSubmissionUrl().ToString();
+            var attachments = _configuration.GetAttachmentPaths().ToArray();
 
             // reassign to captureNativeCrashes
             // to avoid doing anything on crashpad binary, when crashpad
@@ -217,12 +218,14 @@ private void HandleNativeCrashes()
                 AndroidJNI.NewStringUTF(minidumpUrl),
                 AndroidJNI.NewStringUTF(databasePath),
                 AndroidJNI.NewStringUTF(crashpadHandlerPath),
-                AndroidJNIHelper.ConvertToJNIArray(backtraceAttributes.Attributes.Keys.ToArray()),
-                AndroidJNIHelper.ConvertToJNIArray(backtraceAttributes.Attributes.Values.ToArray()));
+                AndroidJNIHelper.ConvertToJNIArray(backtraceAttributes.Keys.ToArray()),
+                AndroidJNIHelper.ConvertToJNIArray(backtraceAttributes.Values.ToArray()),
+                AndroidJNIHelper.ConvertToJNIArray(attachments));
             if (!_captureNativeCrashes)
             {
                 Debug.LogWarning("Backtrace native integration status: Cannot initialize Crashpad client");
             }
+
             // add exception type to crashes handled by crashpad - all exception handled by crashpad 
             // by default we setting this option here, to set error.type when unexpected crash happen (so attribute will present)
             // otherwise in other methods - ANR detection, OOM handler, we're overriding it and setting it back to "crash"
@@ -335,7 +338,7 @@ public void HandleAnr(string gameObjectName, string callbackName)
                                         AndroidJNI.NewStringUTF("error.type"),
                                         AndroidJNI.NewStringUTF("Hang"));
 
-                                    NativeReport(AndroidJNI.NewStringUTF("ANRException: Blocked thread detected."));
+                                    NativeReport(AndroidJNI.NewStringUTF("ANRException: Blocked thread detected."), true);
                                     // update error.type attribute in case when crash happen 
                                     SetAttribute("error.type", "Crash");
                                 }