internal async Task <string> SendPayloadAsync(RavenPayload payload)
{
try
{
string jsonString = JsonConvert.SerializeObject(payload);
StringContent content = new StringContent(jsonString, Encoding.UTF8, "application/json");
System.Diagnostics.Debug.WriteLine("[SENTRY] Sending exception to: " + Dsn.SentryUri);
System.Diagnostics.Debug.WriteLine("[SENTRY] Payload: " + jsonString);
var response = await _httpClient.PostAsync(Dsn.SentryUri, content);
response.EnsureSuccessStatusCode();
// Extract the ID and delete the stored exception so it doesn't get sent again.
// This will just return if no exception is stored with this ID.
JObject responseJson = JObject.Parse(await response.Content.ReadAsStringAsync());
string resultId = (string)responseJson["id"];
await _storage.DeleteStoredExceptionAsync(resultId);
return(resultId);
}
catch (Exception ex)
{
HandleInternalException(ex);
// Store this payload if there's an error sending the exception
// e.g. server offline or client has no internet connection
await StorePayloadAsync(payload);
}
return(null);
}
internal async Task <RavenPayload> GeneratePayloadAsync(string message, RavenLogLevel level, IDictionary <string, string> tags, IDictionary <string, object> extra, string[] fingerprint)
{
RavenPayload payload = await GetBasePayloadAsync(level, tags, extra, fingerprint).ConfigureAwait(false);
payload.Message = message;
return(payload);
}
internal async Task <RavenPayload> GeneratePayloadAsync(string message, RavenLogLevel level, IDictionary <string, string> tags, IDictionary <string, object> extra)
{
RavenPayload payload = await GetBasePayloadAsync(level, tags, extra);
payload.Message = message;
return(payload);
}
internal async Task ProcessExceptionAsync(Exception ex, RavenLogLevel level, IDictionary <string, string> tags, IDictionary <string, object> extra, bool forceSend)
{
RavenPayload payload = await GeneratePayloadAsync(ex, level, tags, extra);
if (forceSend)
{
await SendPayloadAsync(payload);
}
else
{
await StorePayloadAsync(payload);
}
}
internal async Task ProcessMessageAsync(string message, RavenLogLevel level, IDictionary <string, string> tags, IDictionary <string, object> extra, string[] fingerprint, bool forceSend)
{
RavenPayload payload = await GeneratePayloadAsync(message, level, tags, extra, fingerprint);
if (forceSend)
{
await SendPayloadAsync(payload).ConfigureAwait(false);
}
else
{
await StorePayloadAsync(payload).ConfigureAwait(false);
}
}
private async Task <RavenPayload> GetBasePayloadAsync(RavenLogLevel level, IDictionary <string, string> tags, IDictionary <string, object> extra)
{
RavenPayload payload = new RavenPayload()
{
EventID = Guid.NewGuid().ToString("n"),
Project = Dsn.ProjectID,
Level = level,
Timestamp = DateTime.UtcNow,
Platform = _platform.PlatformTag,
Logger = String.IsNullOrEmpty(Logger) ? "root" : Logger,
User = _user,
Tags = await SetDefaultTagsAsync(tags),
Extra = SetDefaultExtra(extra)
};
return(payload);
}
public async Task StoreExceptionAsync(RavenPayload payload)
{
if (payload == null)
{
return;
}
try
{
StorageFolder folder = await GetRavenFolderAsync();
StorageFile file = await folder.CreateFileAsync(payload.EventID, CreationCollisionOption.ReplaceExisting);
await FileIO.WriteTextAsync(file, JsonConvert.SerializeObject(payload));
}
catch (FileNotFoundException) { }
}
public async Task <RavenPayload> GetPayloadByIdAsync(string eventId)
{
try
{
StorageFolder folder = await GetRavenFolderAsync();
StorageFile file = await folder.GetFileAsync(eventId);
string fileText = await FileIO.ReadTextAsync(file);
RavenPayload payload = JsonConvert.DeserializeObject <RavenPayload>(fileText);
return(payload);
}
catch (FileNotFoundException) { }
return(null);
}
internal async Task <RavenPayload> GeneratePayloadAsync(Exception ex, RavenLogLevel level, IDictionary <string, string> tags, IDictionary <string, object> extra)
{
string exceptionName = ex.GetBaseException().GetType().FullName;
string exceptionMessage = ex.InnerException != null ? ex.InnerException.Message : ex.Message;
RavenPayload payload = await GetBasePayloadAsync(level, tags, extra);
payload.Message = String.Format("{0}: {1}", exceptionName, exceptionMessage);
payload.Exceptions = ex.EnumerateAllExceptions().ToList();
payload.Stacktrace = payload.Exceptions?.LastOrDefault()?.Stacktrace;
var lastFrame = payload.Stacktrace?.Frames?.LastOrDefault();
if (lastFrame != null)
{
payload.Culprit = String.Format("{0} in {1}", lastFrame.Method, lastFrame.Filename);
}
return(payload);
}
/// <summary>
/// Gets a list of exceptions currently stored locally.
/// </summary>
/// <returns><see cref="List{RavenJsonPayload}"/> waiting to be sent.</returns>
public async Task <List <RavenPayload> > ListStoredExceptionsAsync()
{
StorageFolder folder = await GetRavenFolderAsync();
List <RavenPayload> exceptions = new List <RavenPayload>();
List <StorageFile> invalidFiles = new List <StorageFile>();
foreach (StorageFile file in await folder.GetFilesAsync())
{
try
{
string fileText = await FileIO.ReadTextAsync(file);
RavenPayload payload = JsonConvert.DeserializeObject <RavenPayload>(fileText);
exceptions.Add(payload);
}
catch (JsonException)
{
invalidFiles.Add(file);
}
catch (FileNotFoundException)
{
continue;
}
}
// Make sure we clean up any files here that don't match the current
// JSON schema so we don't continue to try and read them.
foreach (var file in invalidFiles)
{
await file.DeleteAsync(StorageDeleteOption.PermanentDelete);
}
return(exceptions);
}
internal async Task StorePayloadAsync(RavenPayload payload)
{
await _storage.StoreExceptionAsync(payload);
}
