//public IActionResult Index() //{ // throw new Exception("Yikes an Error!!!"); // //return View(); //} public async Task <IActionResult> Index() { try { throw new Exception("Yikes an Error!!!"); //return View(); } catch (Exception ex) { var msg = new RaygunMessage(); msg.Details = new RaygunMessageDetails { User = RayGunUtils.BuildRayGunIdentifierMessage(HttpContext.User), Error = RaygunErrorMessageBuilder.Build(ex), Request = await RaygunAspNetCoreRequestMessageBuilder.Build(HttpContext, new RaygunRequestMessageOptions()) }; var rgClient = _rgProvider.GetClient(new RaygunSettings(), HttpContext); await rgClient.SendInBackground(msg); return(View()); //return new JsonResult(new ExceptionResponse //{ // ErrorId = Guid.NewGuid(), // Message = ex.Message //}); ; } }
/// <summary> /// Posts a RaygunMessage to the Raygun.io api endpoint. /// </summary> /// <param name="raygunMessage">The RaygunMessage to send. This needs its OccurredOn property /// set to a valid DateTime and as much of the Details property as is available.</param> public override void Send(RaygunMessage raygunMessage) { try { bool canSend = OnSendingMessage(raygunMessage) && CanSend(raygunMessage); if (canSend) { var message = SimpleJson.SerializeObject(raygunMessage); WebClientHelper.Send(message, _apiKey, ProxyCredentials); } } catch (Exception ex) { try { System.Diagnostics.Trace.WriteLine(string.Format("Error Logging Exception to Raygun.io {0}", ex.Message)); } catch { // ignored } if (RaygunSettings.Settings.ThrowOnError) { throw; } } }
public void SetTimeStamp() { DateTime time = new DateTime(2015, 2, 16); RaygunMessage message = _builder.SetTimeStamp(time).Build(); Assert.AreEqual(time, message.OccurredOn); }
protected override void Append(LoggingEvent loggingEvent) { LogLog.Debug(DeclaringType, string.Format("RaygunAppender: Received Logging Event with Logging Level '{0}'", loggingEvent.Level)); Exception exception = ResolveLoggedExceptionObject(loggingEvent); if (exception != null || !OnlySendExceptions) { if (Retries > 0) { LogLog.Debug(DeclaringType, "RaygunAppender: Retries are enabled, checking that throw on errors has been enabled, or can be overridden"); RaygunThrowOnErrorsMustBeEnabled(); } RaygunMessage raygunMessage = BuildRaygunMessageToSend(exception, loggingEvent); if (raygunMessage == null) { LogLog.Warn(DeclaringType, "RaygunAppender: Failed to send due to an invalid RaygunMessage object"); } else { if (SendInBackground) { SendErrorToRaygunInBackground(raygunMessage); } else { SendErrorToRaygun(raygunMessage); } } } }
public void SetVersion_Null() { _builder.SetVersion(null); RaygunMessage message = _builder.Build(); Assert.AreEqual("Not supplied", message.Details.Version); }
public void MessageWithUserInfoFromBuild() { RaygunMessage message = _client.ExposeBuildMessage(_exception, null, null, new RaygunIdentifierMessage("Robbie Robot")); Assert.AreEqual("Robbie Robot", message.Details.User.Identifier); Assert.IsFalse(message.Details.User.IsAnonymous); }
/// <summary> /// Posts a RaygunMessage to the Raygun api endpoint. /// </summary> /// <param name="raygunMessage">The RaygunMessage to send. This needs its OccurredOn property /// set to a valid DateTime and as much of the Details property as is available.</param> public void Send(RaygunMessage raygunMessage) { if (ValidateApiKey()) { bool canSend = OnSendingMessage(raygunMessage); if (canSend) { string message = null; try { message = SimpleJson.SerializeObject(raygunMessage); } catch (Exception ex) { RaygunClient.Log(string.Format("Error serializing raygun message: {0}", ex.Message)); } if (message != null) { SendMessage(message); } } } }
private RaygunMessage BuildRaygunMessageToSend(Exception exception, LoggingEvent loggingEvent) { LogLog.Debug(DeclaringType, "RaygunAppender: Building UserCustomData dictionary"); var userCustomData = _userCustomDataBuilder.Build(loggingEvent); LogLog.Debug(DeclaringType, "RaygunAppender: Building Raygun message"); var exceptionFilter = ActivateInstanceOfMessageFilter(ExceptionFilter); var renderedMessageFilter = ActivateInstanceOfMessageFilter(RenderedMessageFilter); var ignoredFieldSettings = new IgnoredDataSettings(IgnoredFormNames, IgnoredHeaderNames, IgnoredCookieNames, IgnoredServerVariableNames, IgnoredQueryParameterNames, IgnoredSensitiveFieldNames, IsRawDataIgnored); RaygunMessage raygunMessage = null; try { raygunMessage = _raygunMessageBuilder.BuildMessage(exception, loggingEvent, userCustomData, exceptionFilter, renderedMessageFilter, ignoredFieldSettings, ApplicationVersion); } catch (Exception ex) { LogLog.Error(DeclaringType, "RaygunAppender: Failed to build RaygunMessage", ex); } return(raygunMessage); }
public void Initialize(RaygunMessage raygunMessage) { if (raygunMessage.Details.UserCustomData == null) { raygunMessage.Details.UserCustomData = new Dictionary <string, object>(); } raygunMessage.Details.UserCustomData["initializerTestData"] = "true"; }
public void MessageWithUser() { _client.User = "******"; RaygunMessage message = _client.ExposeBuildMessage(_exception); Assert.AreEqual("Robbie Robot", message.Details.User.Identifier); }
protected override void Append(LoggingEvent loggingEvent) { if (IsErrorOrGreaterWithExceptionObject(loggingEvent)) { RaygunMessage message = _messageBuilderFactory.CreateBuilder().SetException(loggingEvent.ExceptionObject).SetLog4NetInfo(loggingEvent).Build(); _clientExecutor.Execute(client => client.SendInBackground(message)); } }
protected override bool CanSend(RaygunMessage message) { if (message != null && message.Details != null && message.Details.Response != null) { return(!GetSettings().ExcludedStatusCodes.Contains(message.Details.Response.StatusCode)); } return(true); }
public void StripHttpUnhandledExceptionByDefault() { HttpUnhandledException wrapper = new HttpUnhandledException("Something went wrong", _exception); RaygunMessage message = _client.ExposeBuildMessage(wrapper); Assert.AreEqual("System.NullReferenceException", message.Details.Error.ClassName); }
public void StripTargetInvocationExceptionByDefault() { TargetInvocationException wrapper = new TargetInvocationException(_exception); RaygunMessage message = _client.ExposeBuildMessage(wrapper); Assert.AreEqual("System.NullReferenceException", message.Details.Error.ClassName); }
public void SetCustomApplicationVersion() { _client.ApplicationVersion = "Custom Version"; RaygunMessage message = _client.ExposeBuildMessage(_exception); Assert.AreEqual("Custom Version", message.Details.Version); }
/// <summary> /// Emit the provided log event to the sink. /// </summary> /// <param name="logEvent">The log event to write.</param> public void Emit(LogEvent logEvent) { //Include the log level as a tag. var tags = _tags.Concat(new [] { logEvent.Level.ToString() }).ToList(); var properties = logEvent.Properties .Select(pv => new { Name = pv.Key, Value = RaygunPropertyFormatter.Simplify(pv.Value) }) .ToDictionary(a => a.Name, b => b.Value); // Add the message properties.Add("RenderedLogMessage", logEvent.RenderMessage(_formatProvider)); properties.Add("LogMessageTemplate", logEvent.MessageTemplate.Text); // Create new message var raygunMessage = new RaygunMessage { OccurredOn = logEvent.Timestamp.UtcDateTime }; // Add exception when available if (logEvent.Exception != null) { raygunMessage.Details.Error = RaygunErrorMessageBuilder.Build(logEvent.Exception); } // Add user when requested if (!String.IsNullOrWhiteSpace(_userNameProperty) && logEvent.Properties.ContainsKey(_userNameProperty) && logEvent.Properties[_userNameProperty] != null) { raygunMessage.Details.User = new RaygunIdentifierMessage(logEvent.Properties[_userNameProperty].ToString()); } // Add version when requested if (!String.IsNullOrWhiteSpace(_applicationVersionProperty) && logEvent.Properties.ContainsKey(_applicationVersionProperty) && logEvent.Properties[_applicationVersionProperty] != null) { raygunMessage.Details.Version = logEvent.Properties[_applicationVersionProperty].ToString(); } // Build up the rest of the message raygunMessage.Details.Environment = new RaygunEnvironmentMessage(); raygunMessage.Details.Tags = tags; raygunMessage.Details.UserCustomData = properties; raygunMessage.Details.MachineName = Environment.MachineName; if (HttpContext.Current != null) { // Request message is built here instead of raygunClient.Send so RequestMessageOptions have to be constructed here var requestMessageOptions = new RaygunRequestMessageOptions(_ignoredFormFieldNames, Enumerable.Empty <string>(), Enumerable.Empty <string>(), Enumerable.Empty <string>()); raygunMessage.Details.Request = RaygunRequestMessageBuilder.Build(HttpContext.Current.Request, requestMessageOptions); } // Submit //_client.SendInBackground(raygunMessage); _client.Send(raygunMessage); }
public void StripMultipleWrapperExceptions() { HttpUnhandledException wrapper = new HttpUnhandledException("Something went wrong", _exception); TargetInvocationException wrapper2 = new TargetInvocationException(wrapper); RaygunMessage message = _client.ExposeBuildMessage(wrapper2); Assert.AreEqual("System.NullReferenceException", message.Details.Error.ClassName); }
public void ResponseIsNullForNonWebExceptions() { NullReferenceException exception = new NullReferenceException("The thing is null"); _builder.SetExceptionDetails(exception); RaygunMessage message = _builder.Build(); Assert.IsNull(message.Details.Response); }
public void DontStripIfNoInnerException() { TargetInvocationException wrapper = new TargetInvocationException(null); RaygunMessage message = _client.ExposeBuildMessage(wrapper); Assert.AreEqual("System.Reflection.TargetInvocationException", message.Details.Error.ClassName); Assert.IsNull(message.Details.Error.InnerError); }
protected bool CanSend(RaygunMessage message) { if (message?.Details?.Response != null) { return(!RaygunSettings.Settings.ExcludedStatusCodes.Contains(message.Details.Response.StatusCode)); } return(true); }
public void DontStripIfNoInnerException() { HttpUnhandledException wrapper = new HttpUnhandledException(); RaygunMessage message = _client.ExposeBuildMessage(wrapper); Assert.AreEqual("System.Web.HttpUnhandledException", message.Details.Error.ClassName); Assert.IsNull(message.Details.Error.InnerError); }
/// <summary> /// Emit the provided log event to the sink. /// </summary> /// <param name="logEvent">The log event to write.</param> public void Emit(LogEvent logEvent) { var tags = new List <String> { logEvent.Level.ToString() }; var properties = logEvent.Properties .Select(pv => new { Name = pv.Key, Value = RaygunPropertyFormatter.Simplify(pv.Value) }) .ToDictionary(a => a.Name, b => b.Value); // Add the message properties.Add("Message", logEvent.RenderMessage(_formatProvider)); properties.Add("MessageTemplate", logEvent.MessageTemplate.Text); // Create new message var raygunMessage = new RaygunMessage { OccurredOn = logEvent.Timestamp.UtcDateTime }; // Add exception when available if (logEvent.Exception != null) { raygunMessage.Details.Error = new RaygunErrorMessage(logEvent.Exception); } // Add user when requested if (!String.IsNullOrWhiteSpace(_userNameProperty) && logEvent.Properties.ContainsKey(_userNameProperty) && logEvent.Properties[_userNameProperty] != null) { raygunMessage.Details.User = new RaygunIdentifierMessage(logEvent.Properties[_userNameProperty].ToString()); } // Add version when requested if (!String.IsNullOrWhiteSpace(_applicationVersionProperty) && logEvent.Properties.ContainsKey(_applicationVersionProperty) && logEvent.Properties[_applicationVersionProperty] != null) { raygunMessage.Details.Version = logEvent.Properties[_applicationVersionProperty].ToString(); } // Build up the rest of the message raygunMessage.Details.Environment = new RaygunEnvironmentMessage(); raygunMessage.Details.Tags = tags; raygunMessage.Details.UserCustomData = properties; raygunMessage.Details.MachineName = Environment.MachineName; if (HttpContext.Current != null) { raygunMessage.Details.Request = new RaygunRequestMessage(HttpContext.Current.Request, null); } // Submit _client.SendInBackground(raygunMessage); }
public void SetVersion() { IRaygunMessageBuilder builder = _builder.SetVersion("Custom Version"); Assert.AreEqual(_builder, builder); RaygunMessage message = _builder.Build(); Assert.AreEqual("Custom Version", message.Details.Version); }
public void StripSpecifiedWrapperException() { _client.AddWrapperExceptions(new Type[] { typeof(WrapperException) }); WrapperException wrapper = new WrapperException(_exception); RaygunMessage message = _client.ExposeBuildMessage(wrapper); Assert.AreEqual("System.NullReferenceException", message.Details.Error.ClassName); }
public void RemoveWrapperExceptions() { _client.RemoveWrapperExceptions(typeof(TargetInvocationException)); TargetInvocationException wrapper = new TargetInvocationException(_exception); RaygunMessage message = _client.ExposeBuildMessage(wrapper); Assert.AreEqual("System.Reflection.TargetInvocationException", message.Details.Error.ClassName); }
public void HandleUnknownStatusCodeFromHttpException() { HttpException exception = new HttpException(1, "?"); _builder.SetExceptionDetails(exception); RaygunMessage message = _builder.Build(); Assert.IsNotNull(message.Details.Response); Assert.AreEqual(1, message.Details.Response.StatusCode); Assert.IsNull(message.Details.Response.StatusDescription); }
public void IsAnonymousDefault() { RaygunIdentifierMessage user = new RaygunIdentifierMessage("Robbie Robot"); Assert.IsFalse(user.IsAnonymous); _client.User = "******"; RaygunMessage message = _client.ExposeBuildMessage(_exception); Assert.IsFalse(message.Details.User.IsAnonymous); }
public void GetStatusCodeFromHttpException() { HttpException exception = new HttpException(404, "the file is gone"); _builder.SetExceptionDetails(exception); RaygunMessage message = _builder.Build(); Assert.IsNotNull(message.Details.Response); Assert.AreEqual(404, message.Details.Response.StatusCode); Assert.AreEqual("NotFound", message.Details.Response.StatusDescription); }
/// <summary> /// Posts a RaygunMessage to the Raygun.io api endpoint. /// </summary> /// <param name="raygunMessage">The RaygunMessage to send. This needs its OccurredOn property /// set to a valid DateTime and as much of the Details property as is available.</param> public override void Send(RaygunMessage raygunMessage) { if (ValidateApiKey()) { bool canSend = OnSendingMessage(raygunMessage) && CanSend(raygunMessage); if (canSend) { using (var client = new WebClient()) { client.Headers.Add("X-ApiKey", _apiKey); client.Headers.Add("content-type", "application/json; charset=utf-8"); client.Encoding = System.Text.Encoding.UTF8; if (WebRequest.DefaultWebProxy != null) { Uri proxyUri = WebRequest.DefaultWebProxy.GetProxy(new Uri(RaygunSettings.Settings.ApiEndpoint.ToString())); if (proxyUri != null && proxyUri.AbsoluteUri != RaygunSettings.Settings.ApiEndpoint.ToString()) { client.Proxy = new WebProxy(proxyUri, false); if (ProxyCredentials == null) { client.UseDefaultCredentials = true; client.Proxy.Credentials = CredentialCache.DefaultCredentials; } else { client.UseDefaultCredentials = false; client.Proxy.Credentials = ProxyCredentials; } } } try { var message = SimpleJson.SerializeObject(raygunMessage); client.UploadString(RaygunSettings.Settings.ApiEndpoint, message); } catch (Exception ex) { System.Diagnostics.Trace.WriteLine(string.Format("Error Logging Exception to Raygun.io {0}", ex.Message)); if (RaygunSettings.Settings.ThrowOnError) { throw; } } } } } }
// Returns true if the message can be sent, false if the sending is canceled. protected bool OnSendingMessage(RaygunMessage raygunMessage) { bool result = true; EventHandler <RaygunSendingMessageEventArgs> handler = SendingMessage; if (handler != null) { RaygunSendingMessageEventArgs args = new RaygunSendingMessageEventArgs(raygunMessage); handler(this, args); result = !args.Cancel; } return(result); }
public void Send(RaygunMessage raygunMessage) { ThreadPool.QueueUserWorkItem(c => { using (var client = new WebClient()) { client.Headers.Add("X-ApiKey", _apiKey); client.Encoding = Encoding.UTF8; try { var builder = new StringBuilder(); Json.Json.Serialize(raygunMessage, builder); client.UploadString(RaygunSettings.Settings.ApiEndpoint, builder.ToString()); } catch (Exception ex) { Trace.WriteLine(string.Format("Error Logging Exception to Raygun.io {0}", ex.Message)); } } }); }
private RaygunMessageBuilder() { _raygunMessage = new RaygunMessage(); }