public DeleteIssueErrorsResponse Invoke(DeleteIssueErrorsRequest request)
{
Trace("Starting...");
TraceObject(request);
var issue = Load <Issue>(Issue.GetId(request.IssueId));
if (issue == null)
{
return(new DeleteIssueErrorsResponse());
}
_authorisationManager.Authorise(issue, request.CurrentUser);
//delete the issue's errors
Session.AddCommitAction(new DeleteAllErrorsCommitAction(issue.Id));
Session.AddCommitAction(new DeleteAllDailyCountsCommitAction(issue.Id));
var hourlyCount = Session.Raven.Load <IssueHourlyCount>("IssueHourlyCount/{0}".FormatWith(issue.FriendlyId));
if (hourlyCount == null)
{
hourlyCount = new IssueHourlyCount
{
IssueId = issue.Id,
Id = "IssueHourlyCount/{0}".FormatWith(issue.FriendlyId),
ApplicationId = issue.ApplicationId
};
hourlyCount.Initialise();
Store(hourlyCount);
}
else
{
hourlyCount.Initialise();
}
//create or update the historical count of errors for this issue
var historicalCount = Load <IssueDailyCount>("IssueDailyCount/{0}-Historical".FormatWith(issue.FriendlyId));
if (historicalCount == null)
{
historicalCount = new IssueDailyCount
{
IssueId = issue.Id,
ApplicationId = issue.ApplicationId,
Count = issue.ErrorCount,
Date = DateTime.MinValue.Date,
Historical = true,
Id = "IssueDailyCount/{0}-Historical".FormatWith(issue.FriendlyId)
};
Store(historicalCount);
}
else
{
historicalCount.Count += issue.ErrorCount;
}
Store(new IssueHistory
{
DateAddedUtc = DateTime.UtcNow.ToDateTimeOffset(request.CurrentUser.ActiveOrganisation.TimezoneId),
UserId = request.CurrentUser.Id,
Type = HistoryItemType.ErrorsPurged,
IssueId = issue.Id,
ApplicationId = issue.ApplicationId,
SystemMessage = true
});
issue.ErrorCount = 0;
issue.LimitStatus = ErrorLimitStatus.Ok;
return(new DeleteIssueErrorsResponse());
}
public AttachToExistingIssueResponse Invoke(AttachToExistingIssueRequest request)
{
Trace("Attempting to load issue with Id {0} from database {1}", request.IssueId, Session.OrganisationDatabaseName);
var issue = Load <Issue>(request.IssueId);
issue.ErrorCount++;
if (request.Error.TimestampUtc > issue.LastErrorUtc)
{
issue.LastErrorUtc = request.Error.TimestampUtc;
}
var issueDailyCount = Load <IssueDailyCount>("IssueDailyCount/{0}-{1}".FormatWith(issue.FriendlyId, request.Error.TimestampUtc.ToString("yyyy-MM-dd")));
if (issueDailyCount == null)
{
issueDailyCount = new IssueDailyCount
{
Id = "IssueDailyCount/{0}-{1}".FormatWith(issue.FriendlyId, request.Error.TimestampUtc.ToString("yyyy-MM-dd")),
IssueId = issue.Id,
Count = 1,
Date = request.Error.TimestampUtc.Date,
ApplicationId = issue.ApplicationId
};
Store(issueDailyCount);
}
else
{
issueDailyCount.Count++;
}
var issueHourlyCount = Load <IssueHourlyCount>("IssueHourlyCount/{0}".FormatWith(issue.FriendlyId));
if (issueHourlyCount == null)
{
issueHourlyCount = new IssueHourlyCount
{
IssueId = issue.Id,
Id = "IssueHourlyCount/{0}".FormatWith(issue.FriendlyId),
ApplicationId = issue.ApplicationId
};
issueHourlyCount.Initialise();
issueHourlyCount.IncrementHourlyCount(issue.CreatedOnUtc);
Store(issueHourlyCount);
}
else
{
issueHourlyCount.IncrementHourlyCount(request.Error.TimestampUtc);
}
SetLimitStatus(issue);
Trace("Assigning issue Id to error with Id:={0}, Existing Error IssueId:={1}, New IssueId:={2}", request.Error.Id, request.Error.IssueId, issue.Id);
request.Error.IssueId = issue.Id;
//only store the error is it is a new error, not the result of reprocessing
if (request.Error.Id.IsNullOrEmpty())
{
Trace("It's a new error, so Store it");
Store(request.Error);
//if the matching issue is solved, send an email and set it back to Acknowledged
if (issue.Status == IssueStatus.Solved)
{
issue.LastNotified = DateTime.UtcNow;
issue.Status = IssueStatus.Acknowledged;
SendNotification(issue, request.Application,
NotificationType.NotifyOnNewInstanceOfSolvedIssue
, request.Error, request.Organisation);
}
else if ((issue.NotifyFrequency ?? "0") != "0" && issue.LastNotified.GetValueOrDefault() < DateTime.UtcNow - new Duration(issue.NotifyFrequency))
{
issue.LastNotified = DateTime.UtcNow;
SendNotification(issue, request.Application, NotificationType.AlwaysNotifyOnInstanceOfIssue,
request.Error, request.Organisation, new Duration(issue.NotifyFrequency));
}
}
if (issue.LimitStatus == ErrorLimitStatus.Exceeded)
{
_makeExceededErrorsUnloggedCommand.Invoke(new MakeExceededErrorsUnloggedRequest {
IssueId = issue.Id
});
}
return(new AttachToExistingIssueResponse
{
Issue = issue
});
}
public AddIssueResponse Invoke(AddIssueRequest request)
{
Trace("Starting...");
var applicationId = Application.GetId(request.ApplicationId);
var dateTimeOffset = DateTime.UtcNow.ToDateTimeOffset(request.CurrentUser.ActiveOrganisation.TimezoneId);
var issue = new Issue
{
Name = request.Name,
Rules = request.Rules,
ApplicationId = applicationId,
CreatedOnUtc = dateTimeOffset,
LastModifiedUtc = dateTimeOffset,
UserId = User.GetId(request.AssignedUserId),
ErrorCount = 0,
LastErrorUtc = dateTimeOffset,
OrganisationId = Organisation.GetId(request.CurrentUser.OrganisationId),
};
var issuesWithSameRules = _getIssueWithMatchingRulesQuery.Invoke(new GetIssueWithMatchingRulesRequest
{
IssueToMatch = issue,
});
if (issuesWithSameRules.Issue != null)
{
return(new AddIssueResponse
{
IssueId = issuesWithSameRules.Issue.FriendlyId,
Status = AddIssueStatus.SameRulesExist
});
}
Store(issue);
Store(new IssueHistory
{
DateAddedUtc = dateTimeOffset,
UserId = request.CurrentUser.Id,
Type = HistoryItemType.ManuallyCreated,
IssueId = issue.Id,
AssignedToUserId = request.AssignedUserId,
PreviousStatus = request.Status,
ApplicationId = issue.ApplicationId,
SystemMessage = true
});
var issueHourlyCount = new IssueHourlyCount
{
IssueId = issue.Id,
Id = "IssueHourlyCount/{0}".FormatWith(issue.FriendlyId),
ApplicationId = issue.ApplicationId
};
issueHourlyCount.Initialise();
Store(issueHourlyCount);
Session.AddCommitAction(new RaiseIssueCreatedEvent(issue));
return(new AddIssueResponse
{
Status = AddIssueStatus.Ok,
IssueId = issue.FriendlyId
});
}
public AttachToNewIssueResponse Invoke(AttachToNewIssueRequest request)
{
Trace("Starting...");
//mark the error as unclassified
var error = request.Error;
var application = request.Application;
var matchRuleFactory = _matchRuleFactoryFactory.Create(application.MatchRuleFactoryId);
var rules = matchRuleFactory.Create(error).ToList();
var issue = new Issue
{
Name = "{0} ({1})".FormatWith(error.ExceptionInfos.First().Type, error.TimestampUtc.ToString("yyyy.MM.ddTHH.mm.ss")),
Rules = rules,
ApplicationId = application.Id,
CreatedOnUtc = error.TimestampUtc,
LastModifiedUtc = error.TimestampUtc,
UserId = application.DefaultUserId,
ErrorCount = 1,
LastErrorUtc = error.TimestampUtc,
OrganisationId = application.OrganisationId,
TestIssue = error.TestError,
NotifyFrequency = application.DefaultNotificationFrequency.IsNullOrEmpty() ? "0" : application.DefaultNotificationFrequency
};
Store(issue);
Store(new IssueHistory
{
DateAddedUtc = DateTime.UtcNow.ToDateTimeOffset(application.TimezoneId),
Type = HistoryItemType.AutoCreated,
ExceptionType = error.ExceptionInfos.First().Type,
ExceptionMethod = error.ExceptionInfos.First().MethodName,
ExceptionMachine = error.MachineName,
SystemMessage = true,
IssueId = issue.Id,
ApplicationId = issue.ApplicationId,
});
var issueHourlyCount = new IssueHourlyCount
{
IssueId = issue.Id,
Id = "IssueHourlyCount/{0}".FormatWith(issue.FriendlyId),
ApplicationId = issue.ApplicationId
};
issueHourlyCount.Initialise();
issueHourlyCount.IncrementHourlyCount(issue.CreatedOnUtc);
Store(issueHourlyCount);
var issueDailyCount = new IssueDailyCount
{
Id = "IssueDailyCount/{0}-{1}".FormatWith(issue.FriendlyId, issue.CreatedOnUtc.ToString("yyyy-MM-dd")),
IssueId = issue.Id,
Count = 1,
Date = issue.CreatedOnUtc.Date,
ApplicationId = issue.ApplicationId
};
Store(issueDailyCount);
Trace("AttachTod issue: Id:={0}, Name:={1}", issue.Id, issue.Name);
error.IssueId = issue.Id;
SendNotification(issue, application, NotificationType.NotifyOnNewIssueCreated, error, request.Organisation);
//tell the issue cache we have a new issue
_receptionServiceIssueCache.Add(issue);
Store(error);
Trace("Complete");
return(new AttachToNewIssueResponse
{
Issue = issue
});
}
public ResetIssueErrorCountsResponse Invoke(ResetIssueErrorCountsRequest request)
{
Trace("Starting...");
Trace("Syncing issue with Id:={0}...", request.IssueId);
TraceObject(request);
var issue = Load <Issue>(Issue.GetId(request.IssueId));
if (issue == null)
{
return(new ResetIssueErrorCountsResponse());
}
var currentIssueCount = issue.ErrorCount;
//re-initialise the issue hourly counts
var hourlyCount = Session.Raven.Load <IssueHourlyCount>("IssueHourlyCount/{0}".FormatWith(issue.FriendlyId));
if (hourlyCount == null)
{
hourlyCount = new IssueHourlyCount
{
IssueId = issue.Id,
Id = "IssueHourlyCount/{0}".FormatWith(issue.FriendlyId),
ApplicationId = issue.ApplicationId
};
Store(hourlyCount);
}
hourlyCount.Initialise();
var errors = _getApplicationErrorsQuery.Invoke(new GetApplicationErrorsRequest
{
ApplicationId = issue.ApplicationId,
OrganisationId = issue.OrganisationId,
IssueId = issue.Id,
Paging = new PageRequestWithSort(1, int.MaxValue),
WaitForIndexStaleAtUtc = request.TriggerEventUtc,
}).Errors;
var dailyCounts = new Dictionary <DateTime, IssueDailyCount>();
foreach (var error in errors.Items)
{
hourlyCount.IncrementHourlyCount(error.TimestampUtc);
if (dailyCounts.ContainsKey(error.TimestampUtc.Date))
{
dailyCounts[error.TimestampUtc.Date].Count++;
}
else
{
var dailyCount = new IssueDailyCount
{
Id = "IssueDailyCount/{0}-{1}".FormatWith(issue.FriendlyId, error.TimestampUtc.ToString("yyyy-MM-dd")),
IssueId = issue.Id,
Count = 1,
Date = error.TimestampUtc.Date,
ApplicationId = issue.ApplicationId
};
dailyCounts.Add(error.TimestampUtc.Date, dailyCount);
Trace("Creating IssueDailyCount, Id:={0}", dailyCount.Id);
}
if (issue.LastErrorUtc < error.TimestampUtc)
{
issue.LastErrorUtc = error.TimestampUtc;
}
}
//delete any daily issue count docs except the historical one
new DeleteAllDailyCountsCommitAction(issue.Id, deleteHistorical: false).Execute(Session);
//make sure the issue index is not stale
new SynchroniseIndexCommitAction <IssueDailyCounts>().Execute(Session);
foreach (var dailyCount in dailyCounts)
{
Store(dailyCount.Value);
}
issue.ErrorCount = errors.PagingStatus.TotalItems;
issue.LimitStatus = issue.ErrorCount >= _configuration.IssueErrorLimit ? ErrorLimitStatus.Exceeded : ErrorLimitStatus.Ok;
//create or update the historical count of errors for this issue
var historicalCount = Load <IssueDailyCount>("IssueDailyCount/{0}-Historical".FormatWith(issue.FriendlyId));
if (historicalCount == null)
{
historicalCount = new IssueDailyCount
{
IssueId = issue.Id,
ApplicationId = issue.ApplicationId,
Count = currentIssueCount - issue.ErrorCount,
Date = DateTime.MinValue.Date,
Historical = true,
Id = "IssueDailyCount/{0}-Historical".FormatWith(issue.FriendlyId)
};
Store(historicalCount);
}
else
{
historicalCount.Count += (currentIssueCount - issue.ErrorCount);
}
return(new ResetIssueErrorCountsResponse());
}
