/// <summary> /// Send a report to Backtrace API /// </summary> /// <param name="report">Report to send</param> /// <param name="sendCallback">Send report callback</param> public void Send(BacktraceReport report, Action <BacktraceResult> sendCallback = null) { if (Enabled == false) { Debug.LogWarning("Please enable BacktraceClient first - Please validate Backtrace client initializaiton in Unity IDE."); return; } //check rate limiting bool limitHit = _reportLimitWatcher.WatchReport(report); if (!limitHit) { if (_onClientReportLimitReached != null) { _onClientReportLimitReached.Invoke(report); } if (sendCallback != null) { sendCallback.Invoke(BacktraceResult.OnLimitReached(report)); } _reportLimitWatcher.DisplayReportLimitHitMessage(); return; } SendReport(report, sendCallback); }
private BacktraceResult Send(Guid requestId, string json, List <string> attachments, BacktraceReport report, int deduplication = 0) { var requestUrl = _serverurl.ToString(); if (deduplication > 0) { requestUrl += $"&_mod_duplicate={deduplication}"; } var formData = FormDataHelper.GetFormData(json, attachments, requestId); string contentType = FormDataHelper.GetContentTypeWithBoundary(requestId); var request = WebRequest.Create(requestUrl) as HttpWebRequest; //Set up the request properties. request.Method = "POST"; request.ContentType = contentType; request.ContentLength = formData.Length; try { using (Stream requestStream = request.GetRequestStream()) { requestStream.Write(formData, 0, formData.Length); requestStream.Close(); } return(ReadServerResponse(request, report)); } catch (Exception exception) { OnServerError?.Invoke(exception); return(BacktraceResult.OnError(report, exception)); } #endif }
/// <summary> /// Sending a diagnostic report data to server API. /// </summary> /// <param name="data">Diagnostic data</param> /// <returns>Server response</returns> public IEnumerator Send(BacktraceData data, Action <BacktraceResult> callback = null) { //check rate limiting bool watcherValidation = reportLimitWatcher.WatchReport(data.Report); if (!watcherValidation) { yield return(BacktraceResult.OnLimitReached(data.Report)); } if (data == null) { yield return(new BacktraceResult() { Status = Types.BacktraceResultStatus.LimitReached }); } string json = data.ToJson(); if (string.IsNullOrEmpty(json)) { yield return(BacktraceResult.OnLimitReached(data.Report)); } yield return(Send(json, data.Attachments, data.Report, callback)); }
private IEnumerator Send(string json, List <string> attachments, BacktraceReport report, Action <BacktraceResult> callback) { using (var request = new UnityWebRequest(_serverurl, "POST")) { AppendBodyToFile(json); byte[] bodyRaw = Encoding.UTF8.GetBytes(json); request.uploadHandler = (UploadHandler) new UploadHandlerRaw(bodyRaw); request.downloadHandler = (DownloadHandler) new DownloadHandlerBuffer(); request.SetRequestHeader("Content-Type", "application/json"); yield return(request.SendWebRequest()); BacktraceResult result; if (request.responseCode == 200) { result = new BacktraceResult(); OnServerResponse?.Invoke(result); var response = BacktraceResult.FromJson(request.downloadHandler.text); if (attachments != null && attachments.Count > 0) { var stack = new Stack <string>(attachments); yield return(SendAttachment(response.Object, stack)); } } else { PrintLog(request); var exception = new Exception(request.error); result = BacktraceResult.OnError(report, exception); OnServerError?.Invoke(exception); } callback?.Invoke(result); yield return(result); } }
private async Task <BacktraceResult> HandleAggregateException(BacktraceReport report) { var aggregateException = report.Exception as AggregateException; BacktraceResult result = null; foreach (var ex in aggregateException.InnerExceptions) { var innerReport = new BacktraceReport( exception: ex, attributes: report.Attributes, attachmentPaths: report.AttachmentPaths, reflectionMethodName: report._reflectionMethodName) { Factor = report.Factor, Fingerprint = report.Fingerprint }; if (result == null) { result = await SendAsync(innerReport); } else { result.AddInnerResult(await SendAsync(innerReport)); } } return(result ?? new BacktraceResult() { Status = BacktraceResultStatus.Empty, BacktraceReport = report }); }
public void Setup() { //mock file context var mockFileContext = new Mock <IBacktraceDatabaseFileContext>(); mockFileContext.Setup(n => n.GetRecords()) .Returns(new List <FileInfo>()); mockFileContext.Setup(n => n.Clear()); ////mock api var mockApi = new Mock <IBacktraceApi>(); mockApi.Setup(n => n.Send(It.IsAny <BacktraceData>())) .Returns(BacktraceResult.OnError(It.IsAny <BacktraceReport>(), new Exception("error"))); var backtraceDatabaseSettings = new BacktraceDatabaseSettings(_projectDirectory) { RetryLimit = _batchLimit, RetryBehavior = Types.RetryBehavior.NoRetry, AutoSendMode = false, DeduplicationStrategy = DeduplicationStrategy.LibraryName | DeduplicationStrategy.Classifier | DeduplicationStrategy.Message }; _backtraceDatabase = new BacktraceDatabase(backtraceDatabaseSettings) { BacktraceApi = mockApi.Object, BacktraceDatabaseFileContext = mockFileContext.Object }; _backtraceDatabase.Start(); }
/// <summary> /// Send minidump to Backtrace /// </summary> /// <param name="minidumpPath">Path to minidump</param> /// <param name="attachments">List of attachments</param> /// <param name="callback">Callback</param> /// <returns>Server response</returns> public IEnumerator SendMinidump(string minidumpPath, IEnumerable <string> attachments, Action <BacktraceResult> callback = null) { if (attachments == null) { attachments = new List <string>(); } var stopWatch = EnablePerformanceStatistics ? System.Diagnostics.Stopwatch.StartNew() : new System.Diagnostics.Stopwatch(); List <IMultipartFormSection> formData = new List <IMultipartFormSection> { new MultipartFormFileSection("upload_file", File.ReadAllBytes(minidumpPath)) }; foreach (var file in attachments) { if (File.Exists(file) && new FileInfo(file).Length < 10000000) { formData.Add(new MultipartFormFileSection( string.Format("attachment__{0}", Path.GetFileName(file)), File.ReadAllBytes(file))); } } yield return(new WaitForEndOfFrame()); var boundaryId = string.Format("----------{0:N}", Guid.NewGuid()); var boundaryIdBytes = Encoding.ASCII.GetBytes(boundaryId); using (var request = UnityWebRequest.Post(_minidumpUrl, formData, boundaryIdBytes)) { request.SetRequestHeader("Content-Type", "multipart/form-data; boundary=" + boundaryId); request.timeout = 15000; yield return(request.SendWebRequest()); var result = request.isNetworkError || request.isHttpError ? new BacktraceResult() { Message = request.error, Status = Types.BacktraceResultStatus.ServerError } : BacktraceResult.FromJson(request.downloadHandler.text); if (callback != null) { callback.Invoke(result); } if (EnablePerformanceStatistics) { stopWatch.Stop(); Debug.Log(string.Format("Backtrace - minidump send time: {0}μs", stopWatch.GetMicroseconds())); } yield return(result); } }
private IEnumerator Send(string json, List <string> attachments, BacktraceReport report, int deduplication, Action <BacktraceResult> callback) { var requestUrl = _serverurl.ToString(); if (deduplication > 0) { var startingChar = string.IsNullOrEmpty(_serverurl.Query) ? "?" : "&"; requestUrl += string.Format("{0}_mod_duplicate={1}", startingChar, deduplication); } using (var request = new UnityWebRequest(requestUrl, "POST")) { #if UNITY_2018_4_OR_NEWER if (_ignoreSslValidation) { request.certificateHandler = new BacktraceSelfSSLCertificateHandler(); } #endif byte[] bodyRaw = Encoding.UTF8.GetBytes(json); request.uploadHandler = (UploadHandler) new UploadHandlerRaw(bodyRaw); request.downloadHandler = (DownloadHandler) new DownloadHandlerBuffer(); request.SetRequestHeader("Content-Type", "application/json"); yield return(request.SendWebRequest()); BacktraceResult result; if (request.responseCode == 200) { result = new BacktraceResult(); if (OnServerResponse != null) { OnServerResponse.Invoke(result); } var response = BacktraceResult.FromJson(request.downloadHandler.text); if (attachments != null && attachments.Count > 0) { var stack = new Stack <string>(attachments); yield return(SendAttachment(response.RxId, stack)); } } else { PrintLog(request); var exception = new Exception(request.error); result = BacktraceResult.OnError(report, exception); if (OnServerError != null) { OnServerError.Invoke(exception); } } if (callback != null) { callback.Invoke(result); } yield return(result); } }
internal async Task <BacktraceResult> SendAsync(Guid requestId, string json, List <string> attachments, BacktraceReport report, int deduplication = 0) { string contentType = FormDataHelper.GetContentTypeWithBoundary(requestId); string boundary = FormDataHelper.GetBoundary(requestId); using (var content = new MultipartFormDataContent(boundary)) { var requestUrl = _serverurl.ToString(); if (deduplication > 0) { requestUrl += $"&_mod_duplicate={deduplication}"; } var request = new HttpRequestMessage(HttpMethod.Post, requestUrl); content.AddJson("upload_file.json", json); content.AddFiles(attachments); //// clear and add content type with boundary tag content.Headers.Remove("Content-Type"); content.Headers.TryAddWithoutValidation("Content-Type", contentType); request.Content = content; try { using (var response = await HttpClient.SendAsync(request)) { var fullResponse = await response.Content.ReadAsStringAsync(); if (response.StatusCode != HttpStatusCode.OK) { var err = new WebException(response.ReasonPhrase); System.Diagnostics.Trace.WriteLine(fullResponse); OnServerError?.Invoke(err); return(BacktraceResult.OnError(report, err)); } var result = JsonConvert.DeserializeObject <BacktraceResult>(fullResponse); result.BacktraceReport = report; OnServerResponse?.Invoke(result); return(result); } } catch (Exception exception) { System.Diagnostics.Trace.WriteLine($"Backtrace - Server error: {exception.ToString()}"); OnServerError?.Invoke(exception); return(BacktraceResult.OnError(report, exception)); } } }
/// <summary> /// Send minidump to Backtrace /// </summary> /// <param name="minidumpPath">Path to minidump</param> /// <param name="attachments">List of attachments</param> /// <param name="callback">Callback</param> /// <returns>Server response</returns> public IEnumerator SendMinidump(string minidumpPath, IEnumerable <string> attachments, IDictionary <string, string> queryAttributes, Action <BacktraceResult> callback = null) { if (attachments == null) { attachments = new HashSet <string>(); } var stopWatch = EnablePerformanceStatistics ? System.Diagnostics.Stopwatch.StartNew() : new System.Diagnostics.Stopwatch(); var minidumpBytes = File.ReadAllBytes(minidumpPath); if (minidumpBytes == null || minidumpBytes.Length == 0) { yield break; } var requestUrl = queryAttributes != null ? GetParametrizedQuery(_minidumpUrl, queryAttributes) : _minidumpUrl; using (var request = _httpClient.Post(requestUrl, minidumpBytes, attachments)) { yield return(request.SendWebRequest()); var result = request.ReceivedNetworkError() ? new BacktraceResult() { Message = request.error, Status = Types.BacktraceResultStatus.ServerError } : BacktraceResult.FromJson(request.downloadHandler.text); if (callback != null) { callback.Invoke(result); } if (EnablePerformanceStatistics) { stopWatch.Stop(); Debug.Log(string.Format("Backtrace - minidump send time: {0}μs", stopWatch.GetMicroseconds())); } yield return(result); } }
public async Task <BacktraceResult> SendAsync(BacktraceData data) { //check rate limiting bool watcherValidation = reportLimitWatcher.WatchReport(data.Report); if (!watcherValidation) { return(BacktraceResult.OnLimitReached(data.Report)); } // execute user custom request handler if (RequestHandler != null) { return(RequestHandler?.Invoke(_serverurl.ToString(), FormDataHelper.GetContentTypeWithBoundary(Guid.NewGuid()), data)); } //get a json from diagnostic object var json = JsonConvert.SerializeObject(data, JsonSerializerSettings); return(await SendAsync(Guid.NewGuid(), json, data.Attachments, data.Report, data.Deduplication)); }
/// <summary> /// Sending a diagnostic report data to server API. /// </summary> /// <param name="data">Diagnostic data</param> /// <returns>Server response</returns> public BacktraceResult Send(BacktraceData data) { #if !NET35 return(Task.Run(() => SendAsync(data)).Result); #else //check rate limiting bool watcherValidation = reportLimitWatcher.WatchReport(data.Report); if (!watcherValidation) { return(BacktraceResult.OnLimitReached(data.Report)); } // execute user custom request handler if (RequestHandler != null) { return(RequestHandler?.Invoke(_serverurl.ToString(), FormDataHelper.GetContentTypeWithBoundary(Guid.NewGuid()), data)); } //set submission data string json = JsonConvert.SerializeObject(data); return(Send(Guid.NewGuid(), json, data.Report?.AttachmentPaths ?? new List <string>(), data.Report, data.Deduplication)); }
/// <summary> /// Sending diagnostic report to Backtrace /// </summary> /// <param name="json">diagnostic data JSON</param> /// <param name="attachments">List of report attachments</param> /// <param name="queryAttributes">Query string attributes</param> /// <param name="callback">coroutine callback</param> /// <returns>Server response</returns> public IEnumerator Send(string json, List <string> attachments, Dictionary <string, string> queryAttributes, Action <BacktraceResult> callback) { var stopWatch = EnablePerformanceStatistics ? System.Diagnostics.Stopwatch.StartNew() : new System.Diagnostics.Stopwatch(); var requestUrl = queryAttributes != null ? GetParametrizedQuery(_serverUrl.ToString(), queryAttributes) : ServerUrl; List <IMultipartFormSection> formData = new List <IMultipartFormSection> { new MultipartFormFileSection("upload_file", Encoding.UTF8.GetBytes(json), "upload_file.json", "application/json") }; foreach (var file in attachments) { if (File.Exists(file) && new FileInfo(file).Length < 10000000) { formData.Add(new MultipartFormFileSection( string.Format("attachment__{0}", Path.GetFileName(file)), File.ReadAllBytes(file))); } } var boundaryIdBytes = UnityWebRequest.GenerateBoundary(); using (var request = UnityWebRequest.Post(requestUrl, formData, boundaryIdBytes)) { #if UNITY_2018_4_OR_NEWER if (_ignoreSslValidation) { request.certificateHandler = new BacktraceSelfSSLCertificateHandler(); } #endif request.SetRequestHeader("Content-Type", "multipart/form-data; boundary=" + Encoding.UTF8.GetString(boundaryIdBytes)); request.timeout = 15000; yield return(request.SendWebRequest()); BacktraceResult result; if (request.responseCode == 429) { result = new BacktraceResult() { Message = "Server report limit reached", Status = Types.BacktraceResultStatus.LimitReached }; if (OnServerResponse != null) { OnServerResponse.Invoke(result); } } else if (request.responseCode == 200 && (!request.isNetworkError || !request.isHttpError)) { result = BacktraceResult.FromJson(request.downloadHandler.text); _shouldDisplayFailureMessage = true; if (OnServerResponse != null) { OnServerResponse.Invoke(result); } } else { PrintLog(request); var exception = new Exception(request.error); result = BacktraceResult.OnNetworkError(exception); if (OnServerError != null) { OnServerError.Invoke(exception); } } if (callback != null) { callback.Invoke(result); } if (EnablePerformanceStatistics) { stopWatch.Stop(); Debug.Log(string.Format("Backtrace - JSON send time: {0}μs", stopWatch.GetMicroseconds())); } yield return(result); } }
/// <summary> /// Send minidump to Backtrace /// </summary> /// <param name="minidumpPath">Path to minidump</param> /// <param name="attachments">List of attachments</param> /// <param name="callback">Callback</param> /// <returns>Server response</returns> public IEnumerator SendMinidump(string minidumpPath, IEnumerable <string> attachments, Action <BacktraceResult> callback = null) { if (attachments == null) { attachments = new List <string>(); } var stopWatch = EnablePerformanceStatistics ? System.Diagnostics.Stopwatch.StartNew() : new System.Diagnostics.Stopwatch(); var minidumpBytes = File.ReadAllBytes(minidumpPath); if (minidumpBytes == null || minidumpBytes.Length == 0) { yield break; } List <IMultipartFormSection> formData = new List <IMultipartFormSection> { new MultipartFormFileSection("upload_file", minidumpBytes) }; foreach (var file in attachments) { if (File.Exists(file) && new FileInfo(file).Length < 10000000) { formData.Add(new MultipartFormFileSection( string.Format("attachment__{0}", Path.GetFileName(file)), File.ReadAllBytes(file))); } } yield return(new WaitForEndOfFrame()); var boundaryIdBytes = UnityWebRequest.GenerateBoundary(); using (var request = UnityWebRequest.Post(_minidumpUrl, formData, boundaryIdBytes)) { #if UNITY_2018_4_OR_NEWER if (_ignoreSslValidation) { request.certificateHandler = new BacktraceSelfSSLCertificateHandler(); } #endif request.SetRequestHeader("Content-Type", string.Format("multipart/form-data; boundary={0}", Encoding.UTF8.GetString(boundaryIdBytes))); request.timeout = 15000; yield return(request.SendWebRequest()); var result = request.isNetworkError || request.isHttpError ? new BacktraceResult() { Message = request.error, Status = Types.BacktraceResultStatus.ServerError } : BacktraceResult.FromJson(request.downloadHandler.text); if (callback != null) { callback.Invoke(result); } if (EnablePerformanceStatistics) { stopWatch.Stop(); Debug.Log(string.Format("Backtrace - minidump send time: {0}μs", stopWatch.GetMicroseconds())); } yield return(result); } }
/// <summary> /// Sending diagnostic report to Backtrace /// </summary> /// <param name="json">diagnostic data JSON</param> /// <param name="attachments">List of report attachments</param> /// <param name="queryAttributes">Query string attributes</param> /// <param name="callback">coroutine callback</param> /// <returns>Server response</returns> public IEnumerator Send(string json, List <string> attachments, Dictionary <string, string> queryAttributes, Action <BacktraceResult> callback) { var stopWatch = EnablePerformanceStatistics ? System.Diagnostics.Stopwatch.StartNew() : new System.Diagnostics.Stopwatch(); var requestUrl = queryAttributes != null ? GetParametrizedQuery(_serverUrl.ToString(), queryAttributes) : ServerUrl; using (var request = new UnityWebRequest(requestUrl, "POST")) { #if UNITY_2018_4_OR_NEWER if (_ignoreSslValidation) { request.certificateHandler = new BacktraceSelfSSLCertificateHandler(); } #endif request.timeout = 15000; byte[] bodyRaw = Encoding.UTF8.GetBytes(json); request.uploadHandler = (UploadHandler) new UploadHandlerRaw(bodyRaw); request.downloadHandler = (DownloadHandler) new DownloadHandlerBuffer(); request.SetRequestHeader("Content-Type", "application/json"); yield return(request.SendWebRequest()); BacktraceResult result; if (request.responseCode == 200) { result = BacktraceResult.FromJson(request.downloadHandler.text); if (OnServerResponse != null) { OnServerResponse.Invoke(result); } if (attachments != null && attachments.Count > 0) { var stack = new Stack <string>(attachments); yield return(SendAttachment(result.RxId, stack)); } } else { PrintLog(request); var exception = new Exception(request.error); result = BacktraceResult.OnError(exception); if (OnServerError != null) { OnServerError.Invoke(exception); } } if (callback != null) { callback.Invoke(result); } if (EnablePerformanceStatistics) { stopWatch.Stop(); Debug.Log(string.Format("Backtrace - JSON send time: {0}μs", stopWatch.GetMicroseconds())); } yield return(result); } }
/// <summary> /// Sending diagnostic report to Backtrace /// </summary> /// <param name="json">diagnostic data JSON</param> /// <param name="attachments">List of report attachments</param> /// <param name="queryAttributes">Query string attributes</param> /// <param name="callback">coroutine callback</param> /// <returns>Server response</returns> public IEnumerator Send(string json, IEnumerable <string> attachments, Dictionary <string, string> queryAttributes, Action <BacktraceResult> callback) { var stopWatch = EnablePerformanceStatistics ? System.Diagnostics.Stopwatch.StartNew() : new System.Diagnostics.Stopwatch(); var requestUrl = queryAttributes != null ? GetParametrizedQuery(_serverUrl.ToString(), queryAttributes) : ServerUrl; using (var request = _httpClient.Post(requestUrl, json, attachments)) { yield return(request.SendWebRequest()); BacktraceResult result; if (request.responseCode == 429) { result = new BacktraceResult() { Message = "Server report limit reached", Status = Types.BacktraceResultStatus.LimitReached }; if (OnServerResponse != null) { OnServerResponse.Invoke(result); } } else if (request.responseCode == 200 && request.ReceivedNetworkError() != true) { result = BacktraceResult.FromJson(request.downloadHandler.text); _shouldDisplayFailureMessage = true; if (OnServerResponse != null) { OnServerResponse.Invoke(result); } } else { PrintLog(request); var exception = new Exception(request.error); result = BacktraceResult.OnNetworkError(exception); if (OnServerError != null) { OnServerError.Invoke(exception); } } if (callback != null) { callback.Invoke(result); } if (EnablePerformanceStatistics) { stopWatch.Stop(); Debug.Assert(EnablePerformanceStatistics, string.Format("Backtrace - JSON send time: {0}μs", stopWatch.GetMicroseconds())); } yield return(result); } }