public Task <string> ReportMessageAsync(string message)
{
var sentryMessage = new SentryMessage(message);
var sentryEvent = new SentryEvent(sentryMessage);
return(_sentryClient.CaptureAsync(sentryEvent));
}
public async Task <string> CaptureExceptionAsync(Exception exception,
SentryMessage message = null,
ErrorLevel level = ErrorLevel.Error,
IDictionary <string, string> tags = null,
string[] fingerprint = null,
object extra = null)
{
var @event = new SentryEvent(exception)
{
Message = message,
Level = level,
Extra = extra
};
if (tags != null)
{
foreach (var tag in tags)
{
@event.Tags.Add(tag.Key, tag.Value);
}
}
if (fingerprint != null)
{
foreach (var f in fingerprint)
{
@event.Fingerprint.Add(f);
}
}
return(await CaptureAsync(@event));
}
public void NullString_IsImplicitlyConvertedTo_NullMessage()
{
string stringMessage = null;
SentryMessage message = stringMessage;
Assert.That(message, Is.Null);
}
//************************************************************************************
private void buttonSend_Click(object sender, EventArgs e)
{
if (CommentBox.Text.Trim() == "")
{
CommentBox.ShowBalloon(ToolTipIcon.Warning, "", "Empty message?");
return;
}
Cursor.Current = Cursors.WaitCursor;
string message = "";
message += "***************************** MESSAGE *****************************\n";
message += CommentBox.Text + "\n";
message += "****************************** NAME *******************************\n";
message += NameBox.Text + "\n";
message += "****************************** MAIL *******************************\n";
message += MailBox.Text + "\n";
message += "*******************************************************************\n";
var ravenClient = new RavenClient("https://[email protected]/1210500");
SentryMessage msg = new SentryMessage(message);
SentryEvent ev = new SentryEvent(msg);
ravenClient.Capture(ev);
Close();
}
public async Task SendMessageAsync(string message, Exception ex, string errorLevel)
{
if (string.IsNullOrEmpty(message) || ex == null || string.IsNullOrEmpty(errorLevel))
{
return;
}
var sentryMessage = new SentryMessage(string.Format(
"Message: {0} \r\n\r\nException:{1}",
message,
ex.ToString()));
var sentryEvent = new SentryEvent(sentryMessage)
{
Level = ErrorLevel.Error,
Tags = new Dictionary <string, string>()
{
{ "device.model", DeviceInfoHelper.DeviceModel.GetStringForNullOrEmptyProperty("0") },
{ "device.arch", DeviceInfoHelper.SystemArchitecture.GetStringForNullOrEmptyProperty("unknown") },
{ "app.version", DeviceInfoHelper.ApplicationVersion.GetStringForNullOrEmptyProperty("2.7.9.0") },
{ "system.version", DeviceInfoHelper.SystemVersion.GetStringForNullOrEmptyProperty("0") },
{ "system.family", DeviceInfoHelper.SystemFamily.GetStringForNullOrEmptyProperty("unknown") },
}
};
var result = await ravenClient.CaptureAsync(sentryEvent).ConfigureAwait(false);
}
public void ToString_ReturnsMessage()
{
string stringMessage = Guid.NewGuid().ToString("N");
SentryMessage message = new SentryMessage(stringMessage);
Assert.That(message.ToString(), Is.EqualTo(stringMessage));
}
public void NullMessage_IsImplicitlyConvertedTo_NullString()
{
SentryMessage message = null;
string stringMessage = message;
Assert.That(stringMessage, Is.Null);
}
/// <summary>
/// Writes logging event to the log target.
/// </summary>
/// <param name="logEvent">Logging event to be written out.</param>
protected override void Write(LogEventInfo logEvent)
{
try
{
var tags = SendLogEventInfoPropertiesAsTags
? logEvent.Properties.ToDictionary(x => x.Key.ToString(), x => x.Value.ToString())
: null;
var extras = SendLogEventInfoPropertiesAsTags
? null
: logEvent.Properties.ToDictionary(x => x.Key.ToString(), x => x.Value.ToString());
client.Value.Logger = logEvent.LoggerName;
// If the log event did not contain an exception and we're not ignoring
// those kinds of events then we'll send a "Message" to Sentry
if (logEvent.Exception == null && !IgnoreEventsWithNoException)
{
var sentryMessage = new SentryMessage(Layout.Render(logEvent));
client.Value.CaptureMessage(sentryMessage, LoggingLevelMap[logEvent.Level], extra: extras, tags: tags);
}
else if (logEvent.Exception != null)
{
var sentryMessage = new SentryMessage(logEvent.FormattedMessage);
client.Value.CaptureException(logEvent.Exception, extra: extras, level: LoggingLevelMap[logEvent.Level], message: sentryMessage, tags: tags);
}
}
catch (Exception e)
{
InternalLogger.Error("Unable to send Sentry request: {0}", e.Message);
}
}
/// <summary>
/// Writes logging event to the log target.
/// </summary>
/// <param name="logEvent">Logging event to be written out.</param>
protected override void Write(LogEventInfo logEvent)
{
try
{
this.client.Value.Logger = logEvent.LoggerName;
SentryEvent sentryEvent = null;
var sentryMessage = new SentryMessage(this.Layout.Render(logEvent));
// If the log event did not contain an exception and we're not ignoring
// those kinds of events then we'll send a "Message" to Sentry
if (logEvent.Exception == null && !this.IgnoreEventsWithNoException)
{
sentryEvent = new SentryEvent(sentryMessage);
}
else if (logEvent.Exception != null)
{
sentryEvent = new SentryEvent(logEvent.Exception)
{
Message = sentryMessage
};
}
if (sentryEvent != null)
{
sentryEvent.Level = LoggingLevelMap[logEvent.Level];
sentryEvent.Tags = GetTags(logEvent);
this.client.Value.Capture(sentryEvent);
}
}
catch (Exception ex)
{
this.LogException(ex);
}
}
//*************************************************************************************************************
private void buttonSend_Click(object sender, EventArgs e)
{
if (CommentBox.Text.Trim() == "")
{
CommentBox.ShowBalloon(ToolTipIcon.Warning, "", "Empty message?");
return;
}
Cursor.Current = Cursors.WaitCursor;
string message = "";
message += "***************************** MESSAGE *****************************\n";
message += CommentBox.Text + "\n";
message += "****************************** NAME *******************************\n";
message += NameBox.Text + "\n";
message += "****************************** MAIL *******************************\n";
message += MailBox.Text + "\n";
message += "*******************************************************************\n";
var ravenClient = new RavenClient("https://[email protected]/5275199");
SentryMessage msg = new SentryMessage(message);
SentryEvent ev = new SentryEvent(msg);
ravenClient.Capture(ev);
Close();
}
public void ToString_ReturnsFormattedString()
{
Guid arg = Guid.NewGuid();
SentryMessage message = new SentryMessage("Format something {0:N} in here", arg);
Assert.That(message.ToString(), Is.StringContaining(arg.ToString("N")));
}
/// <summary>
/// Captures the message.
/// </summary>
/// <param name="message">The message to capture.</param>
/// <param name="level">The <see cref="ErrorLevel" /> of the captured <paramref name="message" />. Default <see cref="ErrorLevel.Info" />.</param>
/// <param name="tags">The tags to annotate the captured <paramref name="message" /> with.</param>
/// <param name="extra">The extra metadata to send with the captured <paramref name="message" />.</param>
/// <returns>
/// The <see cref="JsonPacket.EventID" /> of the successfully captured <paramref name="message" />, or <c>null</c> if it fails.
/// </returns>
public string CaptureMessage(SentryMessage message,
ErrorLevel level = ErrorLevel.Info,
Dictionary<string, string> tags = null,
object extra = null)
{
JsonPacket packet = this.jsonPacketFactory.Create(CurrentDsn.ProjectID, message, level, tags, extra);
return Send(packet, CurrentDsn);
}
public async Task <string> CaptureMessageAsync(SentryMessage message,
ErrorLevel level = ErrorLevel.Info,
IDictionary <string, string> tags = null,
string[] fingerprint = null,
object extra = null)
{
return(await Task.FromResult(Guid.NewGuid().ToString("n")));
}
public void Message_ReturnsMessage()
{
const string format = "Format something {0:N} in here";
var arg = Guid.NewGuid();
SentryMessage message = new SentryMessage(format, arg);
Assert.That(message.Message, Is.EqualTo(format));
}
public string CaptureMessage(SentryMessage message,
ErrorLevel level = ErrorLevel.Info,
IDictionary <string, string> tags = null,
string[] fingerprint = null,
object extra = null)
{
return(Guid.NewGuid().ToString("n"));
}
public string CaptureException(Exception exception,
SentryMessage message = null,
ErrorLevel level = ErrorLevel.Error,
IDictionary <string, string> tags = null,
string[] fingerprint = null,
object extra = null)
{
return(Guid.NewGuid().ToString("n"));
}
public void Parameters_ReturnsParameters()
{
const string format = "Format something {0:N} in here";
var arg = Guid.NewGuid();
SentryMessage message = new SentryMessage(format, arg);
Assert.That(message.Parameters, Has.Length.EqualTo(1));
Assert.That(message.Parameters[0], Is.EqualTo(arg));
}
protected override void Write(LogEventInfo logEvent)
{
try
{
// don't report non-critical events without exceptions
if (logEvent.Exception == null || _unauthorized)
{
return;
}
var fingerPrint = GetFingerPrint(logEvent);
if (!_debounce.Allowed(fingerPrint))
{
return;
}
var extras = logEvent.Properties.ToDictionary(x => x.Key.ToString(), x => x.Value.ToString());
_client.Logger = logEvent.LoggerName;
var sentryMessage = new SentryMessage(logEvent.Message, logEvent.Parameters);
var sentryEvent = new SentryEvent(logEvent.Exception)
{
Level = LoggingLevelMap[logEvent.Level],
Message = sentryMessage,
Extra = extras,
Fingerprint =
{
logEvent.Level.ToString(),
logEvent.LoggerName,
logEvent.Message
}
};
if (logEvent.Exception != null)
{
sentryEvent.Fingerprint.Add(logEvent.Exception.GetType().FullName);
}
var osName = Environment.GetEnvironmentVariable("OS_NAME");
var osVersion = Environment.GetEnvironmentVariable("OS_VERSION");
var runTimeVersion = Environment.GetEnvironmentVariable("RUNTIME_VERSION");
sentryEvent.Tags.Add("os_name", osName);
sentryEvent.Tags.Add("os_version", $"{osName} {osVersion}");
sentryEvent.Tags.Add("runtime_version", $"{PlatformInfo.PlatformName} {runTimeVersion}");
_client.Capture(sentryEvent);
}
catch (Exception e)
{
OnError(e);
}
}
public void CaptureMessage_WithFormat_ReturnsValidID()
{
object[] args = Enumerable.Range(0, 5).Select(i => Guid.NewGuid()).Cast <object>().ToArray();
var message = new SentryMessage("Lorem %s ipsum %s dolor %s sit %s amet %s.", args);
var id = this.ravenClient.CaptureMessage(message);
//Console.WriteLine("Sent packet: " + id);
Assert.That(id, Is.Not.Null);
Assert.That(Guid.Parse(id), Is.Not.Null);
}
public void CaptureException_WithMessageFormat_ReturnsValidID()
{
object[] args = Enumerable.Range(0, 5).Select(i => Guid.NewGuid()).Cast <object>().ToArray();
var message = new SentryMessage("A {0:N} B {1:N} C {2:N} D {3:N} F {4:N}.", args);
var id = this.ravenClient.CaptureException(new Exception("Test without a stacktrace."), message);
//Console.WriteLine("Sent packet: " + id);
Assert.That(id, Is.Not.Null);
Assert.That(Guid.Parse(id), Is.Not.Null);
}
private SentryEvent CreateSentryEvent(SentryMessage message)
{
var sentryEvent = new SentryEvent(message);
sentryEvent.Tags.Add("OS", _appInfoService.GetPlatform());
sentryEvent.Tags.Add("Login", BasePresenter.User.Login);
sentryEvent.Tags.Add("AppVersion", _appInfoService.GetAppVersion());
sentryEvent.Tags.Add("AppBuild", _appInfoService.GetBuildVersion());
sentryEvent.Tags.Add("Model", _appInfoService.GetModel());
sentryEvent.Tags.Add("OsVersion", _appInfoService.GetOsVersion());
sentryEvent.Message = message;
return(sentryEvent);
}
/// <summary>
/// Captures the <see cref="Exception" />.
/// </summary>
/// <param name="exception">The <see cref="Exception" /> to capture.</param>
/// <param name="message">The optional messge to capture. Default: <see cref="Exception.Message" />.</param>
/// <param name="level">The <see cref="ErrorLevel" /> of the captured <paramref name="exception" />. Default: <see cref="ErrorLevel.Error" />.</param>
/// <param name="tags">The tags to annotate the captured <paramref name="exception" /> with.</param>
/// <param name="extra">The extra metadata to send with the captured <paramref name="exception" />.</param>
/// <returns>
/// The <see cref="JsonPacket.EventID" /> of the successfully captured <paramref name="exception" />, or <c>null</c> if it fails.
/// </returns>
public string CaptureException(Exception exception,
SentryMessage message = null,
ErrorLevel level = ErrorLevel.Error,
IDictionary<string, string> tags = null,
object extra = null)
{
JsonPacket packet = this.jsonPacketFactory.Create(this.currentDsn.ProjectID,
exception,
message,
level,
tags,
extra);
return Send(packet, CurrentDsn);
}
/// <summary>
/// Captures the message.
/// </summary>
/// <param name="message">The message to capture.</param>
/// <param name="level">The <see cref="ErrorLevel" /> of the captured <paramref name="message" />. Default <see cref="ErrorLevel.Info" />.</param>
/// <param name="tags">The tags to annotate the captured <paramref name="message" /> with.</param>
/// <param name="extra">The extra metadata to send with the captured <paramref name="message" />.</param>
/// <returns>
/// The <see cref="JsonPacket.EventID" /> of the successfully captured <paramref name="message" />, or <c>null</c> if it fails.
/// </returns>
public string CaptureMessage(SentryMessage message,
ErrorLevel level = ErrorLevel.Info,
Dictionary <string, string> tags = null,
object extra = null)
{
try
{
JsonPacket packet = this.jsonPacketFactory.Create(CurrentDsn.ProjectID, message, level, tags, extra);
return(Send(packet, CurrentDsn));
}
catch (Exception sendException)
{
return(HandleException(sendException));
}
}
public string CaptureMessage(SentryMessage message,
ErrorLevel level = ErrorLevel.Info,
IDictionary <string, string> tags = null,
string[] fingerprint = null,
object extra = null)
{
var @event = new SentryEvent(message)
{
Level = level,
Extra = extra,
Tags = MergeTags(tags),
Fingerprint = fingerprint
};
return(Capture(@event));
}
public void SerializeObject_AllPropertiesSetToNonDefault_SerializesValidObject()
{
var sut = new SentryMessage
{
Message = "Message {eventId} {name}",
Params = new object[] { 100, "test-name" },
Formatted = "Message 100 test-name"
};
var actual = JsonSerializer.SerializeObject(sut);
Assert.Equal("{\"message\":\"Message {eventId} {name}\","
+ "\"params\":[100,\"test-name\"],"
+ "\"formatted\":\"Message 100 test-name\"}",
actual);
}
public async Task <string> CaptureMessageAsync(SentryMessage message,
ErrorLevel level = ErrorLevel.Info,
IDictionary <string, string> tags = null,
string[] fingerprint = null,
object extra = null)
{
var @event = new SentryEvent(message)
{
Level = level,
Extra = extra,
Tags = tags,
Fingerprint = fingerprint
};
return(await CaptureAsync(@event));
}
public string CaptureMessage(SentryMessage message,
ErrorLevel level = ErrorLevel.Info,
IDictionary <string, string> tags = null,
string[] fingerprint = null,
object extra = null)
{
var finalTags = MergeTags(tags);
var packet = this.jsonPacketFactory.Create(CurrentDsn.ProjectID,
message,
level,
finalTags,
fingerprint,
extra);
return(Send(packet));
}
/// <summary>
/// Writes logging event to the log target.
/// </summary>
/// <param name="logEvent">Logging event to be written out.</param>
protected override void Write(LogEventInfo logEvent)
{
try
{
Dictionary <string, string> extras = SendLogEventInfoPropertiesAsTags
? null
: logEvent.Properties.ToDictionary(x => x.Key.ToString(), x => x.Value.ToString());
client.Value.Logger = logEvent.LoggerName;
// If the log event did not contain an exception and we're not ignoring
// those kinds of events then we'll send a "Message" to Sentry
if (logEvent.Exception == null && !IgnoreEventsWithNoException)
{
var sentryMessage = new SentryMessage(Layout.Render(logEvent));
var sentryEvent = new SentryEvent(sentryMessage)
{
Level = LoggingLevelMap[logEvent.Level],
Extra = extras,
Fingerprint = { logEvent.UserStackFrame?.ToString(), logEvent.LoggerName },
Tags = { { ServiceNameKey, ServiceName } }
};
client.Value.Capture(sentryEvent);
}
else if (logEvent.Exception != null)
{
var sentryMessage = new SentryMessage(logEvent.FormattedMessage);
var sentryEvent = new SentryEvent(logEvent.Exception)
{
Extra = new Dictionary <string, string> {
{ RawStackTraceKey, logEvent.Exception.StackTrace }
},
Level = LoggingLevelMap[logEvent.Level],
Message = sentryMessage,
Fingerprint = { logEvent.UserStackFrame?.ToString(), logEvent.LoggerName },
Tags = { { ServiceNameKey, ServiceName } }
};
client.Value.Capture(sentryEvent);
}
}
catch (Exception ex)
{
LogException(ex);
}
}
public static void QueueBobsBuddyTerminalCase(TestInput testInput, TestOutput output, string result, int turn, List <string> debugLog, Region region)
{
if (BobsBuddyEventsSent >= MaxBobsBuddyEvents)
{
return;
}
if (!Helper.IsSigned)
{
return;
}
// Clean up data
testInput.RemoveSelfReferencesFromMinions();
output.ClearListsForReporting(); //ignoring for some temporary debugging
var msg = new SentryMessage($"BobsBuddy {BobsBuddyUtils.VersionString}: Incorrect Terminal Case: {result}");
var data = new BobsBuddyData()
{
ShortId = "",
Turn = turn,
Result = result,
ThreadCount = BobsBuddyInvoker.ThreadCount,
Iterations = output.simulationCount,
ExitCondition = output.myExitCondition.ToString(),
Input = testInput,
Output = output,
Log = ReverseAndClone(debugLog),
Region = region,
CanRemoveLichKing = BobsBuddyInvoker.CanRemoveLichKing
};
var bbEvent = new SentryEvent(msg)
{
Level = ErrorLevel.Warning,
Extra = data,
};
bbEvent.Tags.Add("region", data.Region.ToString());
bbEvent.Fingerprint.Add(result);
bbEvent.Fingerprint.Add(BobsBuddyUtils.VersionString);
BobsBuddyEvents.Enqueue(bbEvent);
}
public async Task <string> CaptureMessageAsync(SentryMessage message, ErrorLevel level = ErrorLevel.Info, IDictionary <string, string> tags = null, string[] fingerprint = null, object extra = null)
{
var jsonPacket = new JsonPacket(CurrentDsn.ProjectId)
{
MessageObject = message,
Level = level,
Tags = tags,
Fingerprint = fingerprint,
Extra = extra,
Environment = this.Environment
};
var result = await sentryApi.StoreAsync(jsonPacket);
return(result.id);
}
