JIT stack trace parser (#39)

* JIT stack trace parser

* Version  + changelog update

Author: konraddysput

CHANGELOG.md

@@ -29,7 +29,7 @@ For example, to only get error reporting for hangs or crashes then only return f
   * Database add operation time (`performance.database`),
   * Database single send method time (`performance.send`),
   * Database single flush method time (`performance.flush`)
-  
+- Improvements to JIT stack frame parsing.
 
 ## Version 3.0.2
 - `BacktraceDatabase` now provides a new `Send` method. This method will try to send all objects from the database respecting the client side deduplication and retry setting. This can be used as an alternative to the `Flush` method which will try to send all objects from the database ignoring any client side deduplication and retry settings.

Runtime/Model/BacktraceData.cs

@@ -45,7 +45,7 @@ public class BacktraceData
         /// <summary>
         /// Version of the C# library
         /// </summary>
-        public const string AgentVersion = "3.0.2";
+        public const string AgentVersion = "3.0.3";
 
         /// <summary>
         /// Application thread details

Runtime/Model/BacktraceUnhandledException.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.CompilerServices;
 
 namespace Backtrace.Unity.Model
 {
@@ -116,6 +117,10 @@ private void ConvertStackFrames()
                 {
                     stackFrame = SetNativeStackTraceInformation(frameString);
                 }
+                else if (frameString.StartsWith("#"))
+                {
+                    stackFrame = SetJITStackTraceInformation(frameString);
+                }
                 else if (frameString.IndexOf('(', methodNameEndIndex + 1) > -1)
                 {
                     stackFrame = SetDefaultStackTraceInformation(frameString);
@@ -140,6 +145,56 @@ private void ConvertStackFrames()
             }
         }
 
+        /// <summary>
+        /// Try to convert JIT stack trace
+        /// </summary>
+        /// <param name="frameString">JIT stack frame</param>
+        /// <returns>Backtrace stack frame</returns>
+        private BacktraceStackFrame SetJITStackTraceInformation(string frameString)
+        {
+
+            var stackFrame = new BacktraceStackFrame();
+            if (!frameString.StartsWith("#"))
+            {
+                //handle sitaution when we detected jit stack trace
+                // but jit stack trace doesn't start with #
+                stackFrame.FunctionName = frameString;
+                return stackFrame;
+            }
+
+            frameString = frameString.Substring(frameString.IndexOf(' ')).Trim();
+            const string monoJitPrefix = "(Mono JIT Code)";
+            var monoPrefixIndex = frameString.IndexOf(monoJitPrefix);
+            if (monoPrefixIndex != -1)
+            {
+                frameString = frameString.Substring(monoPrefixIndex + monoJitPrefix.Length).Trim();
+            }
+
+            const string managedWraperPrefix = "(wrapper managed-to-native)";
+            var managedWraperIndex = frameString.IndexOf(managedWraperPrefix);
+            if (managedWraperIndex != -1)
+            {
+                frameString = frameString.Substring(managedWraperIndex + managedWraperPrefix.Length).Trim();
+            }
+
+            // right now we outfiltered all known prefixes 
+            // we should have only function name with parameters
+
+            // filter parameters, if we can't use full frameString as function name
+            var parametersStart = frameString.IndexOf('(');
+            var parametersEnd = frameString.IndexOf(')');
+            if (parametersStart != -1 && parametersEnd != -1 && parametersEnd > parametersStart)
+            {
+                stackFrame.FunctionName = frameString.Substring(0, parametersStart).Trim();
+            }
+            else
+            {
+                stackFrame.FunctionName = frameString;
+            }
+            return stackFrame;
+
+        }
+
         /// <summary>
         /// Try to convert native stack frame
         /// </summary>
@@ -237,6 +292,11 @@ private BacktraceStackFrame SetAndroidStackTraceInformation(string frameString)
         /// <returns></returns>
         private BacktraceStackFrame SetDefaultStackTraceInformation(string frameString)
         {
+            const string wrapperPrefix = "(wrapper remoting-invoke-with-check)";
+            if (frameString.StartsWith(wrapperPrefix))
+            {
+                frameString = frameString.Replace(wrapperPrefix, string.Empty);
+            }
             // find method parameters
             int methodNameEndIndex = frameString.IndexOf(')');
 

Tests/Runtime/BacktraceBaseTest.cs

@@ -61,6 +61,8 @@ protected virtual BacktraceConfiguration GenerateDefaultConfiguration()
         [OneTimeTearDown]
         public void Cleanup()
         {
+            BacktraceClient.BeforeSend = null;
+            BacktraceClient.RequestHandler = null;
             Object.DestroyImmediate(GameObject);
         }
     }

Tests/Runtime/BacktraceClientTests.cs

@@ -17,6 +17,7 @@ public void Setup()
             BeforeSetup();
             AfterSetup(false);
         }
+
 
         [UnityTest]
         public IEnumerator TestClientCreation_ValidBacktraceConfiguration_ValidClientCreation()

Tests/Runtime/BacktraceStackTraceTests.cs

@@ -468,6 +468,34 @@ public void ExceptionStackTrace_ShouldGenerateEnvStackTraceIfExStackTraceIsEmpty
             Assert.IsTrue(error.StackFrames.Any());
         }
 
+        [Test]
+        public void JITStackTrace_ShouldParseCorrectlyJITStackTrace_StackTraceObjectIsGeneratedCorrectly()
+        {
+
+            var simpleFunctionName = "GetStacktrace";
+            var functionNameWithWrappedManagedPrefix = "UnityEngine.DebugLogHandler:Internal_Log";
+            var functioNamewithMonoJitCodePrefix = "ServerGameManager:SendInitialiseNetObjectToClient";
+            var jitStackTrace = string.Format(@"#0 {0} (int)
+                 #1 DebugStringToFile(DebugStringToFileData const&)
+                 #2 DebugLogHandler_CUSTOM_Internal_Log(LogType, LogOption, ScriptingBackendNativeStringPtrOpaque*, ScriptingBackendNativeObjectPtrOpaque*)
+                 #3  (Mono JIT Code) (wrapper managed-to-native) {1} (UnityEngine.LogType,UnityEngine.LogOption,string,UnityEngine.Object)
+                 #4  (Mono JIT Code) {2} (FG.Common.GameConnection,FG.Common.NetObjectSpawnData)
+                 #5  (Mono JIT Code) ServerGameManager:SpawnAlreadySpawnedObjectsForClient (FG.Common.GameConnection)
+                 #6  (Mono JIT Code) ServerGameManager:ProcessLevelLoaded (FG.Common.GameConnection)
+                 #7  (Mono JIT Code) ServerGameManager:ProcessClientReady (FG.Common.GameConnection,FG.Common.PlayerReadinessState)
+                 #8  (Mono JIT Code) FG.Common.UnityNetworkMessageHandler:HandleAndFreeInboundGameMessage (FG.Common.MessageEnvelope)
+                 #9  (Mono JIT Code) FG.Common.UnityNetworkMessageHandler:PeekAndHandleMessage (UnityEngine.Networking.NetworkMessage,FG.Common.GameConnection)
+                 #10  (Mono JIT Code) FG.Common.FG_UnityInternetNetworkManager:ServerHandleMessageReceived (UnityEngine.Networking.NetworkMessage)",
+                 simpleFunctionName, functionNameWithWrappedManagedPrefix, functioNamewithMonoJitCodePrefix);
+
+
+            var backtraceUnhandledException = new BacktraceUnhandledException("foo", jitStackTrace);
+
+            Assert.AreEqual(11, backtraceUnhandledException.StackFrames.Count);
+            Assert.AreEqual(backtraceUnhandledException.StackFrames[0].FunctionName, simpleFunctionName);
+            Assert.AreEqual(backtraceUnhandledException.StackFrames[3].FunctionName, functionNameWithWrappedManagedPrefix);
+            Assert.AreEqual(backtraceUnhandledException.StackFrames[4].FunctionName, functioNamewithMonoJitCodePrefix);
+        }
 
         internal string ConvertStackTraceToString(List<SampleStackFrame> data)
         {

Tests/Runtime/ClientSendTests.cs

@@ -24,6 +24,12 @@ public void Setup()
             client.Refresh();
         }
 
+        [TearDown]
+        public void Cleanup()
+        {
+            client.RequestHandler = null;
+        }
+
         [UnityTest]
         public IEnumerator SendReport_ExceptionReport_ValidSend()
         {

package.json

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