Source code integration

Author: konraddysput

Runtime/Model/BacktraceData.cs

@@ -67,6 +67,12 @@ public class BacktraceData
         [JsonProperty(PropertyName = "classifiers", NullValueHandling = NullValueHandling.Ignore)]
         public string[] Classifier;
 
+        /// <summary>
+        /// Source code information - right now we support source code only for BacktraceUnhandledException exceptions.
+        /// </summary>
+        [JsonProperty(PropertyName = "sourceCode ")]
+        internal BacktraceSourceCode SourceCode;
+
         /// <summary>
         /// Get a path to report attachments
         /// </summary>
@@ -132,7 +138,8 @@ public string ToJson()
                 {"classifiers", new JArray(Classifier)},
                 {"attributes", Attributes.ToJson()},
                 {"annotations", Annotation.ToJson()},
-                {"threads", ThreadData == null ? null : ThreadData.ToJson()}
+                {"threads", ThreadData == null ? null : ThreadData.ToJson()},
+                {"sourceCode", SourceCode == null ? null : SourceCode.ToJson()}
             };
             return json.ToString();
         }
@@ -157,7 +164,8 @@ public static BacktraceData Deserialize(string json)
                 Classifier = classfiers,
                 Annotation = Annotations.Deserialize(@object["annotations"]),
                 Attributes = BacktraceAttributes.Deserialize(@object["attributes"]),
-                ThreadData = ThreadData.DeserializeThreadInformation(@object["threads"])
+                ThreadData = ThreadData.DeserializeThreadInformation(@object["threads"]),
+                SourceCode = BacktraceSourceCode.Deserialize(@object["sourceCode"]),
             };
         }
 
@@ -169,6 +177,10 @@ private void SetThreadInformations()
             ThreadData = new ThreadData(Report.DiagnosticStack);
             ThreadInformations = ThreadData.ThreadInformations;
             MainThread = ThreadData.MainThread;
+            if (Report.Exception is BacktraceUnhandledException)
+            {
+                SourceCode = (Report.Exception as BacktraceUnhandledException).SourceCode;
+            }
         }
 
         /// <summary>

Runtime/Model/BacktraceSourceCode.cs

@@ -0,0 +1,56 @@
+using Backtrace.Newtonsoft.Linq;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Backtrace.Unity.Model
+{
+    public class BacktraceSourceCode
+    {
+        public string Id = Guid.NewGuid().ToString();
+        public string Type { get; set; } = "Text";
+        public string Title { get; set; } = "Log File";
+
+        public bool HighlightLine = false;
+        public string Text { get; set; }
+
+        internal BacktraceJObject ToJson()
+        {
+            var json = new BacktraceJObject();
+            json[Id.ToString()] = new BacktraceJObject()
+            {
+                ["id"] = Id,
+                ["type"] = Type,
+                ["title"] = Title,
+                ["highlightLine"] = HighlightLine,
+                ["text"] = Text,
+            };
+
+            return json;
+        }
+
+        internal static BacktraceSourceCode Deserialize(JToken token)
+        {
+            if (token == null)
+            {
+                return null;
+            }
+            var data = token.FirstOrDefault();
+            if (data == null)
+            {
+                return null;
+            }
+            var rawSourceCode = data.FirstOrDefault();
+            var sourceCode = new BacktraceSourceCode()
+            {
+                Id = rawSourceCode.Value<string>("id"),
+                Text = rawSourceCode.Value<string>("text"),
+                Title = rawSourceCode.Value<string>("title"),
+                Type = rawSourceCode.Value<string>("type")
+            };
+            return sourceCode;
+        }
+    }
+}

Runtime/Model/BacktraceSourceCode.cs.meta

@@ -61,14 +61,27 @@ public BacktraceJObject ToJson()
             var stackFrame = new BacktraceJObject
             {
                 {"funcName", FunctionName},
-                {"line", Line},
                 {"il", Il},
                 {"metadata_token", MemberInfo},
-                {"column", Column},
+                
                 {"address", ILOffset},
                 {"library", Library}
             };
-            //todo: source code information
+
+            if(Column != 0)
+            {
+                stackFrame["column"] = Column;
+            }
+
+            if (Line != 0)
+            {
+                stackFrame["line"] = Line;
+            }
+
+            if (!string.IsNullOrEmpty(SourceCode))
+            {
+                stackFrame["sourceCode"] = SourceCode;
+            }
 
             return stackFrame;
         }

Runtime/Model/BacktraceStackFrame.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Linq;
 
 namespace Backtrace.Unity.Model
 {
@@ -38,12 +39,31 @@ public override string StackTrace
         }
 
         public List<BacktraceStackFrame> StackFrames = new List<BacktraceStackFrame>();
+        public BacktraceSourceCode SourceCode = null;
 
         public BacktraceUnhandledException(string message, string stacktrace) : base(message)
         {
             _stacktrace = stacktrace;
             _message = message;
             ConvertStackFrames();
+            CreateUnhandledExceptionLogInformation();
+        }
+
+        /// <summary>
+        /// Assign source code information to first stack frame of unhandled exception report
+        /// </summary>
+        private void CreateUnhandledExceptionLogInformation()
+        {
+            SourceCode = new BacktraceSourceCode()
+            {
+                Text = string.Format("Unity Exception:\n{0}\n{1}", _message, _stacktrace)
+            };
+            // assign log information to first stack frame
+            if (StackFrames.Count == 0)
+            {
+                return;
+            }
+            StackFrames.First().SourceCode = SourceCode.Id.ToString();
         }
 
         private void ConvertStackFrames()

Runtime/Model/BacktraceUnhandledException.cs

@@ -72,10 +72,35 @@ public IEnumerator TestReportValues_ShouldAssignCorrectExceptionInformation_Exce
             Assert.AreEqual(reportAttributes["test_attribute"], report.Attributes["test_attribute"]);
             Assert.AreEqual(reportAttributes["temporary_attribute"], report.Attributes["temporary_attribute"]);
             Assert.AreEqual(reportAttributes["temporary_attribute_bool"], report.Attributes["temporary_attribute_bool"]);
-            
+
             yield return null;
         }
 
+        [Test]
+        public void TestReportSourceCode_UnhandledExceptionSourceCode_ExceptionShouldHaveSourceCode()
+        {
+            var message = "message";
+            var stackTrace = "Startup.DoSomethingElse ()";
+            var unhandledExceptionReport = new BacktraceUnhandledException(message, stackTrace);
+            var report = new BacktraceReport(unhandledExceptionReport);
+            var data = report.ToBacktraceData(null);
+            Assert.IsNotNull(data.SourceCode);
+            Assert.AreEqual("Text", data.SourceCode.Type);
+            Assert.AreEqual("Log File", data.SourceCode.Title);
+            // test unhandled exception text - based on unhandled exception text algorithm
+            Assert.AreEqual(string.Format("Unity Exception:\n{0}\n{1}", message, stackTrace), data.SourceCode.Text);
+        }
+
+        [Test]
+        public void TestReportSourceCode_HandledExceptionSourceCode_ReportShouldntHaveReportSourceCode()
+        {
+            var message = "message";
+            var unhandledExceptionReport = new Exception(message);
+            var report = new BacktraceReport(unhandledExceptionReport);
+            var data = report.ToBacktraceData(null);
+            Assert.IsNull(data.SourceCode);
+        }
+
         private IEnumerator TestSerialization(BacktraceReport report)
         {
             var json = report.ToJson();