feat(khira): application-oriented error form with drafts and database cleanup

This commit is contained in:
2026-10-28 11:11:51 +05:30
parent db9c1a5840
commit 1bcc0d5dda
7 changed files with 943 additions and 90 deletions
+34 -10
View File
@@ -113,6 +113,16 @@ CREATE TABLE IF NOT EXISTS errors (
created_by VARCHAR(64) NOT NULL DEFAULT '',
request_payload TEXT NOT NULL DEFAULT '',
archived BOOLEAN NOT NULL DEFAULT FALSE,
platform VARCHAR(32) NOT NULL DEFAULT 'iOS',
current_phase VARCHAR(64) NOT NULL DEFAULT 'development phase',
error_screen VARCHAR(128) NOT NULL DEFAULT '',
feature_name VARCHAR(128) NOT NULL DEFAULT '',
error_type VARCHAR(32) NOT NULL DEFAULT 'Bug',
description TEXT NOT NULL DEFAULT '',
image_url TEXT NOT NULL DEFAULT '',
additional_info TEXT NOT NULL DEFAULT '',
is_draft BOOLEAN NOT NULL DEFAULT FALSE,
assigned_to VARCHAR(64) NOT NULL DEFAULT '',
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
@@ -213,8 +223,23 @@ func connectDB(url string) (*sql.DB, error) {
}
func initSchema(db *sql.DB) error {
_, err := db.Exec(ddlSchema)
return err
if _, err := db.Exec(ddlSchema); err != nil {
return err
}
// Ensure application-oriented error columns exist
_, _ = db.Exec(`
ALTER TABLE errors ADD COLUMN IF NOT EXISTS platform VARCHAR(32) NOT NULL DEFAULT 'iOS';
ALTER TABLE errors ADD COLUMN IF NOT EXISTS current_phase VARCHAR(64) NOT NULL DEFAULT 'development phase';
ALTER TABLE errors ADD COLUMN IF NOT EXISTS error_screen VARCHAR(128) NOT NULL DEFAULT '';
ALTER TABLE errors ADD COLUMN IF NOT EXISTS feature_name VARCHAR(128) NOT NULL DEFAULT '';
ALTER TABLE errors ADD COLUMN IF NOT EXISTS error_type VARCHAR(32) NOT NULL DEFAULT 'Bug';
ALTER TABLE errors ADD COLUMN IF NOT EXISTS description TEXT NOT NULL DEFAULT '';
ALTER TABLE errors ADD COLUMN IF NOT EXISTS image_url TEXT NOT NULL DEFAULT '';
ALTER TABLE errors ADD COLUMN IF NOT EXISTS additional_info TEXT NOT NULL DEFAULT '';
ALTER TABLE errors ADD COLUMN IF NOT EXISTS is_draft BOOLEAN NOT NULL DEFAULT FALSE;
ALTER TABLE errors ADD COLUMN IF NOT EXISTS assigned_to VARCHAR(64) NOT NULL DEFAULT '';
`)
return nil
}
func seedDefaultUsers(db *sql.DB) error {
@@ -232,11 +257,6 @@ func seedDefaultUsers(db *sql.DB) error {
avatar string
}{
{"admin", "System Administrator", "admin", "team_lead", "Team Lead", "A"},
{"charlie", "Charlie Diaz", "charlie123", "tester", "Tester", "🕵️‍♂️"},
{"alice", "Alice Sharma", "alice123", "ios_dev", "iOS Dev", "👩‍💻"},
{"bob", "Bob Anderson", "bob123", "backend_dev", "Backend Dev", "👨‍💻"},
{"diana", "Diana Prince", "diana123", "android_dev", "Android Dev", "🤖"},
{"eva", "Eva Chen", "eva123", "designer", "Designer", "🎨"},
}
for _, u := range defaultUsers {
@@ -438,7 +458,8 @@ func SyncDatabases(primaryDB, backupDB *sql.DB) (map[string]any, error) {
errRows, err := primaryDB.Query(`
SELECT id, fingerprint, app_name, version, environment, service, endpoint, exception_type, message,
stack_trace, severity, status, occurrences, first_seen, last_seen, resolved_at, resolved_by,
resolution_notes, linked_ticket_id, created_by, request_payload, archived, created_at
resolution_notes, linked_ticket_id, created_by, request_payload, archived, created_at,
platform, current_phase, error_screen, feature_name, error_type, description, image_url, additional_info, is_draft, assigned_to
FROM errors
`)
if err != nil {
@@ -449,8 +470,9 @@ func SyncDatabases(primaryDB, backupDB *sql.DB) (map[string]any, error) {
errStmt, err := tx.Prepare(`
INSERT INTO errors (id, fingerprint, app_name, version, environment, service, endpoint, exception_type, message,
stack_trace, severity, status, occurrences, first_seen, last_seen, resolved_at, resolved_by,
resolution_notes, linked_ticket_id, created_by, request_payload, archived, created_at)
VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23)
resolution_notes, linked_ticket_id, created_by, request_payload, archived, created_at,
platform, current_phase, error_screen, feature_name, error_type, description, image_url, additional_info, is_draft, assigned_to)
VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33)
`)
if err != nil {
return nil, err
@@ -463,6 +485,7 @@ func SyncDatabases(primaryDB, backupDB *sql.DB) (map[string]any, error) {
&e.ID, &e.Fingerprint, &e.AppName, &e.Version, &e.Environment, &e.Service, &e.Endpoint, &e.ExceptionType, &e.Message,
&e.StackTrace, &e.Severity, &e.Status, &e.Occurrences, &e.FirstSeen, &e.LastSeen, &e.ResolvedAt, &e.ResolvedBy,
&e.ResolutionNotes, &e.LinkedTicketID, &e.CreatedBy, &e.RequestPayload, &e.Archived, &e.CreatedAt,
&e.Platform, &e.CurrentPhase, &e.ErrorScreen, &e.FeatureName, &e.ErrorType, &e.Description, &e.ImageURL, &e.AdditionalInfo, &e.IsDraft, &e.AssignedTo,
); err != nil {
return nil, err
}
@@ -470,6 +493,7 @@ func SyncDatabases(primaryDB, backupDB *sql.DB) (map[string]any, error) {
e.ID, e.Fingerprint, e.AppName, e.Version, e.Environment, e.Service, e.Endpoint, e.ExceptionType, e.Message,
e.StackTrace, e.Severity, e.Status, e.Occurrences, e.FirstSeen, e.LastSeen, e.ResolvedAt, e.ResolvedBy,
e.ResolutionNotes, e.LinkedTicketID, e.CreatedBy, e.RequestPayload, e.Archived, e.CreatedAt,
e.Platform, e.CurrentPhase, e.ErrorScreen, e.FeatureName, e.ErrorType, e.Description, e.ImageURL, e.AdditionalInfo, e.IsDraft, e.AssignedTo,
); err != nil {
return nil, err
}
+74 -1
View File
@@ -144,6 +144,9 @@ func (s *Server) RegisterRoutes(r chi.Router) {
api.Post("/errors", s.handleIngestError)
api.Get("/errors/stats", s.handleErrorStats)
api.Get("/errors/{id}", s.handleGetError)
api.Put("/errors/{id}", s.handleUpdateError)
api.Post("/errors/{id}", s.handleUpdateError)
api.Delete("/errors/{id}", s.handleDeleteError)
api.Put("/errors/{id}/status", s.handleUpdateErrorStatus)
api.Post("/errors/{id}/status", s.handleUpdateErrorStatus)
api.Post("/errors/{id}/escalate", s.handleEscalateError)
@@ -1177,7 +1180,7 @@ func (s *Server) handleIngestError(w http.ResponseWriter, r *http.Request) {
}
var ticket *Ticket
if assignee != "" && actor != nil {
if !saved.IsDraft && assignee != "" && actor != nil {
title := fmt.Sprintf("[%s] %s: %s", saved.AppName, saved.ExceptionType, saved.Message)
if len(title) > 80 {
title = title[:77] + "..."
@@ -1196,6 +1199,76 @@ func (s *Server) handleIngestError(w http.ResponseWriter, r *http.Request) {
})
}
func (s *Server) handleUpdateError(w http.ResponseWriter, r *http.Request) {
actor := s.getActor(r)
if actor == nil {
s.writeJSON(w, http.StatusUnauthorized, map[string]string{"error": "Please sign in to update errors"})
return
}
id := chi.URLParam(r, "id")
var req struct {
AppError
AssignedTo string `json:"assigned_to"`
AssigneeUsername string `json:"assignee_username"`
Notes string `json:"notes"`
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
s.writeJSON(w, http.StatusBadRequest, map[string]string{"error": "Invalid request payload"})
return
}
assignee := strings.TrimSpace(req.AssignedTo)
if assignee == "" {
assignee = strings.TrimSpace(req.AssigneeUsername)
}
if assignee != "" {
req.AppError.AssignedTo = assignee
}
updated, err := s.Store.UpdateError(id, &req.AppError, actor)
if err != nil {
s.writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
return
}
var ticket *Ticket
if !updated.IsDraft && assignee != "" && updated.LinkedTicketID == "" {
title := fmt.Sprintf("[%s] %s: %s", updated.AppName, updated.ExceptionType, updated.Message)
if len(title) > 80 {
title = title[:77] + "..."
}
t, errItem, errEsc := s.Store.EscalateErrorToTicket(updated.ID, title, assignee, updated.Severity, req.Notes, actor)
if errEsc == nil {
ticket = t
updated = errItem
}
}
s.writeJSON(w, http.StatusOK, map[string]any{
"status": "ok",
"error": updated,
"ticket": ticket,
})
}
func (s *Server) handleDeleteError(w http.ResponseWriter, r *http.Request) {
actor := s.getActor(r)
if actor == nil {
s.writeJSON(w, http.StatusUnauthorized, map[string]string{"error": "Please sign in to delete errors"})
return
}
id := chi.URLParam(r, "id")
if err := s.Store.DeleteError(id, actor); err != nil {
s.writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
return
}
s.writeJSON(w, http.StatusOK, map[string]any{
"status": "ok",
"id": id,
})
}
func (s *Server) handleUpdateErrorStatus(w http.ResponseWriter, r *http.Request) {
actor := s.getActor(r)
if actor == nil {
+14 -1
View File
@@ -167,6 +167,7 @@ const (
ErrorStatusInvestigating ErrorStatus = "investigating"
ErrorStatusResolved ErrorStatus = "resolved"
ErrorStatusIgnored ErrorStatus = "ignored"
ErrorStatusDraft ErrorStatus = "draft"
)
type AppError struct {
@@ -181,7 +182,7 @@ type AppError struct {
Message string `json:"message"`
StackTrace string `json:"stack_trace"`
Severity string `json:"severity"` // critical, high, medium, low
Status string `json:"status"` // unresolved, investigating, resolved, ignored
Status string `json:"status"` // unresolved, investigating, resolved, ignored, draft
Occurrences int `json:"occurrences"`
FirstSeen time.Time `json:"first_seen"`
LastSeen time.Time `json:"last_seen"`
@@ -194,6 +195,18 @@ type AppError struct {
Archived bool `json:"archived"`
CreatedAt time.Time `json:"created_at"`
Tags []string `json:"tags,omitempty"`
// Application-oriented error fields
Platform string `json:"platform"` // iOS or Android
CurrentPhase string `json:"current_phase"` // development phase or ready to live
ErrorScreen string `json:"error_screen"` // screen or view where error occurred
FeatureName string `json:"feature_name"` // feature name
ErrorType string `json:"error_type"` // Bug or Crash
Description string `json:"description"` // user description of error
ImageURL string `json:"image_url"` // attached image URL
AdditionalInfo string `json:"additional_info"` // any additional info
IsDraft bool `json:"is_draft"` // draft flag
AssignedTo string `json:"assigned_to"` // assigned developer or recipient username
}
type Notification struct {
+188 -32
View File
@@ -1267,31 +1267,82 @@ func (s *Store) MarkNotificationsRead(username string) {
// ─────────────────────────────────────────────
func (s *Store) IngestError(errItem *AppError, actor *User) (*AppError, error) {
if errItem.AppName == "" || errItem.ExceptionType == "" || errItem.Message == "" {
return nil, errors.New("app_name, exception_type and message are required")
// Normalize defaults for application-oriented error reports
if errItem.Platform == "" {
errItem.Platform = "iOS"
}
if errItem.CurrentPhase == "" {
errItem.CurrentPhase = "development phase"
}
if errItem.ErrorType == "" {
errItem.ErrorType = "Bug"
}
if errItem.Description != "" && errItem.Message == "" {
errItem.Message = errItem.Description
}
if errItem.ErrorType != "" && errItem.ExceptionType == "" {
errItem.ExceptionType = errItem.ErrorType
}
if errItem.FeatureName != "" && errItem.Service == "" {
errItem.Service = errItem.FeatureName
}
if errItem.Severity == "" {
if strings.EqualFold(errItem.ErrorType, "Crash") {
errItem.Severity = "critical"
} else {
errItem.Severity = "medium"
}
}
if errItem.Environment == "" {
errItem.Environment = errItem.CurrentPhase
}
// Fingerprint for deduplication
fpRaw := fmt.Sprintf("%s:%s:%s", errItem.AppName, errItem.ExceptionType, errItem.Message)
h := sha256.Sum256([]byte(fpRaw))
fingerprint := fmt.Sprintf("%x", h)[:16]
if errItem.IsDraft {
errItem.Status = string(ErrorStatusDraft)
if errItem.AppName == "" {
errItem.AppName = "Draft Application"
}
if errItem.Message == "" {
errItem.Message = "(Draft Error)"
}
if errItem.ExceptionType == "" {
errItem.ExceptionType = "Bug"
}
} else {
if errItem.AppName == "" || errItem.Message == "" {
return nil, errors.New("app_name and description/message are required")
}
if errItem.ExceptionType == "" {
errItem.ExceptionType = "Bug"
}
if errItem.Status == "" || errItem.Status == string(ErrorStatusDraft) {
errItem.Status = string(ErrorStatusUnresolved)
}
}
now := time.Now()
// Check if already exists with same fingerprint
var existingID string
var occurrences int
err := s.primaryDB.QueryRow(`
SELECT id, occurrences FROM errors WHERE fingerprint = $1 AND status != 'resolved'
`, fingerprint).Scan(&existingID, &occurrences)
// Only deduplicate non-draft errors
if !errItem.IsDraft {
fpRaw := fmt.Sprintf("%s:%s:%s", errItem.AppName, errItem.ExceptionType, errItem.Message)
h := sha256.Sum256([]byte(fpRaw))
fingerprint := fmt.Sprintf("%x", h)[:16]
errItem.Fingerprint = fingerprint
if err == nil && existingID != "" {
// Update existing error occurrences
_, _ = s.primaryDB.Exec(`
UPDATE errors SET occurrences = occurrences + 1, last_seen = $1 WHERE id = $2
`, now, existingID)
return s.GetError(existingID)
var existingID string
var occurrences int
err := s.primaryDB.QueryRow(`
SELECT id, occurrences FROM errors WHERE fingerprint = $1 AND status != 'resolved' AND is_draft = FALSE
`, fingerprint).Scan(&existingID, &occurrences)
if err == nil && existingID != "" {
_, _ = s.primaryDB.Exec(`
UPDATE errors SET occurrences = occurrences + 1, last_seen = $1 WHERE id = $2
`, now, existingID)
return s.GetError(existingID)
}
} else {
errItem.Fingerprint = "draft-" + uuid.New().String()[:8]
}
id, err := s.nextSeq("error_seq", "ERR")
@@ -1299,11 +1350,9 @@ func (s *Store) IngestError(errItem *AppError, actor *User) (*AppError, error) {
return nil, err
}
errItem.ID = id
errItem.Fingerprint = fingerprint
errItem.Occurrences = 1
errItem.FirstSeen = now
errItem.LastSeen = now
errItem.Status = string(ErrorStatusUnresolved)
if actor != nil {
errItem.CreatedBy = actor.Username
}
@@ -1311,35 +1360,126 @@ func (s *Store) IngestError(errItem *AppError, actor *User) (*AppError, error) {
_, err = s.primaryDB.Exec(`
INSERT INTO errors (
id, fingerprint, app_name, version, environment, service, endpoint, exception_type, message,
stack_trace, severity, status, occurrences, first_seen, last_seen, created_by, request_payload, created_at
) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18)
stack_trace, severity, status, occurrences, first_seen, last_seen, created_by, request_payload,
platform, current_phase, error_screen, feature_name, error_type, description, image_url, additional_info, is_draft, assigned_to, created_at
) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28)
`, errItem.ID, errItem.Fingerprint, errItem.AppName, errItem.Version, errItem.Environment, errItem.Service,
errItem.Endpoint, errItem.ExceptionType, errItem.Message, errItem.StackTrace, errItem.Severity,
errItem.Status, errItem.Occurrences, errItem.FirstSeen, errItem.LastSeen, errItem.CreatedBy,
errItem.RequestPayload, now)
errItem.RequestPayload, errItem.Platform, errItem.CurrentPhase, errItem.ErrorScreen, errItem.FeatureName,
errItem.ErrorType, errItem.Description, errItem.ImageURL, errItem.AdditionalInfo, errItem.IsDraft,
errItem.AssignedTo, now)
if err != nil {
return nil, fmt.Errorf("failed to insert error: %w", err)
}
if s.Broker != nil {
s.Broker.Broadcast("error_logged", "", errItem.ID, "", "log", map[string]string{"app": errItem.AppName, "severity": errItem.Severity})
actionType := "log"
if errItem.IsDraft {
actionType = "draft_created"
}
s.Broker.Broadcast("error_logged", "", errItem.ID, "", actionType, map[string]string{
"app": errItem.AppName, "severity": errItem.Severity, "status": errItem.Status, "is_draft": fmt.Sprintf("%v", errItem.IsDraft),
})
}
return errItem, nil
}
func (s *Store) UpdateError(id string, u *AppError, actor *User) (*AppError, error) {
if u.Platform == "" {
u.Platform = "iOS"
}
if u.CurrentPhase == "" {
u.CurrentPhase = "development phase"
}
if u.ErrorType == "" {
u.ErrorType = "Bug"
}
if u.Description != "" && u.Message == "" {
u.Message = u.Description
}
if u.ErrorType != "" && u.ExceptionType == "" {
u.ExceptionType = u.ErrorType
}
if u.FeatureName != "" && u.Service == "" {
u.Service = u.FeatureName
}
if u.Severity == "" {
if strings.EqualFold(u.ErrorType, "Crash") {
u.Severity = "critical"
} else {
u.Severity = "medium"
}
}
if u.Environment == "" {
u.Environment = u.CurrentPhase
}
if u.IsDraft {
u.Status = string(ErrorStatusDraft)
} else {
if u.Status == "" || u.Status == string(ErrorStatusDraft) {
u.Status = string(ErrorStatusUnresolved)
}
}
now := time.Now()
_, err := s.primaryDB.Exec(`
UPDATE errors SET
app_name = $1, version = $2, environment = $3, service = $4, endpoint = $5,
exception_type = $6, message = $7, stack_trace = $8, severity = $9, status = $10,
platform = $11, current_phase = $12, error_screen = $13, feature_name = $14,
error_type = $15, description = $16, image_url = $17, additional_info = $18,
is_draft = $19, assigned_to = $20, last_seen = $21
WHERE id = $22
`, u.AppName, u.Version, u.Environment, u.Service, u.Endpoint,
u.ExceptionType, u.Message, u.StackTrace, u.Severity, u.Status,
u.Platform, u.CurrentPhase, u.ErrorScreen, u.FeatureName,
u.ErrorType, u.Description, u.ImageURL, u.AdditionalInfo,
u.IsDraft, u.AssignedTo, now, id)
if err != nil {
return nil, fmt.Errorf("failed to update error: %w", err)
}
if s.Broker != nil {
actionType := "error_updated"
if !u.IsDraft {
actionType = "error_published"
}
s.Broker.Broadcast("error_updated", "", id, "", actionType, map[string]string{
"app": u.AppName, "severity": u.Severity, "status": u.Status, "is_draft": fmt.Sprintf("%v", u.IsDraft),
})
}
return s.GetError(id)
}
func (s *Store) DeleteError(id string, actor *User) error {
_, err := s.primaryDB.Exec("DELETE FROM errors WHERE id = $1", id)
if err != nil {
return err
}
if s.Broker != nil {
s.Broker.Broadcast("error_deleted", "", id, "", "delete", map[string]string{})
}
return nil
}
func (s *Store) GetError(id string) (*AppError, error) {
var e AppError
err := s.primaryDB.QueryRow(`
SELECT id, fingerprint, app_name, version, environment, service, endpoint, exception_type, message,
stack_trace, severity, status, occurrences, first_seen, last_seen, resolved_at, resolved_by,
resolution_notes, linked_ticket_id, created_by, request_payload, archived
resolution_notes, linked_ticket_id, created_by, request_payload, archived,
platform, current_phase, error_screen, feature_name, error_type, description, image_url, additional_info, is_draft, assigned_to
FROM errors WHERE id = $1
`, id).Scan(
&e.ID, &e.Fingerprint, &e.AppName, &e.Version, &e.Environment, &e.Service, &e.Endpoint, &e.ExceptionType, &e.Message,
&e.StackTrace, &e.Severity, &e.Status, &e.Occurrences, &e.FirstSeen, &e.LastSeen, &e.ResolvedAt, &e.ResolvedBy,
&e.ResolutionNotes, &e.LinkedTicketID, &e.CreatedBy, &e.RequestPayload, &e.Archived,
&e.Platform, &e.CurrentPhase, &e.ErrorScreen, &e.FeatureName, &e.ErrorType, &e.Description, &e.ImageURL, &e.AdditionalInfo, &e.IsDraft, &e.AssignedTo,
)
if err != nil {
return nil, errors.New("error not found")
@@ -1353,11 +1493,19 @@ func (s *Store) ListErrors(status, severity, app, query string) []*AppError {
var args []any
idx := 1
if status != "" {
conds = append(conds, fmt.Sprintf("LOWER(status) = LOWER($%d)", idx))
if strings.EqualFold(status, "draft") {
conds = append(conds, "is_draft = TRUE")
} else if strings.EqualFold(status, "all_with_drafts") {
// Include all
} else if status != "" {
conds = append(conds, fmt.Sprintf("LOWER(status) = LOWER($%d) AND is_draft = FALSE", idx))
args = append(args, status)
idx++
} else {
// Default: list non-draft errors
conds = append(conds, "is_draft = FALSE")
}
if severity != "" {
conds = append(conds, fmt.Sprintf("LOWER(severity) = LOWER($%d)", idx))
args = append(args, severity)
@@ -1370,7 +1518,7 @@ func (s *Store) ListErrors(status, severity, app, query string) []*AppError {
}
if query != "" {
q := "%" + strings.ToLower(query) + "%"
conds = append(conds, fmt.Sprintf("(LOWER(id) LIKE $%d OR LOWER(message) LIKE $%d OR LOWER(exception_type) LIKE $%d OR LOWER(endpoint) LIKE $%d)", idx, idx, idx, idx))
conds = append(conds, fmt.Sprintf("(LOWER(id) LIKE $%d OR LOWER(message) LIKE $%d OR LOWER(description) LIKE $%d OR LOWER(exception_type) LIKE $%d OR LOWER(feature_name) LIKE $%d OR LOWER(error_screen) LIKE $%d OR LOWER(endpoint) LIKE $%d)", idx, idx, idx, idx, idx, idx, idx))
args = append(args, q)
idx++
}
@@ -1383,7 +1531,8 @@ func (s *Store) ListErrors(status, severity, app, query string) []*AppError {
querySQL := fmt.Sprintf(`
SELECT id, fingerprint, app_name, version, environment, service, endpoint, exception_type, message,
stack_trace, severity, status, occurrences, first_seen, last_seen, resolved_at, resolved_by,
resolution_notes, linked_ticket_id, created_by, request_payload, archived
resolution_notes, linked_ticket_id, created_by, request_payload, archived,
platform, current_phase, error_screen, feature_name, error_type, description, image_url, additional_info, is_draft, assigned_to
FROM errors
%s
ORDER BY last_seen DESC LIMIT 100
@@ -1402,6 +1551,7 @@ func (s *Store) ListErrors(status, severity, app, query string) []*AppError {
&e.ID, &e.Fingerprint, &e.AppName, &e.Version, &e.Environment, &e.Service, &e.Endpoint, &e.ExceptionType, &e.Message,
&e.StackTrace, &e.Severity, &e.Status, &e.Occurrences, &e.FirstSeen, &e.LastSeen, &e.ResolvedAt, &e.ResolvedBy,
&e.ResolutionNotes, &e.LinkedTicketID, &e.CreatedBy, &e.RequestPayload, &e.Archived,
&e.Platform, &e.CurrentPhase, &e.ErrorScreen, &e.FeatureName, &e.ErrorType, &e.Description, &e.ImageURL, &e.AdditionalInfo, &e.IsDraft, &e.AssignedTo,
); err == nil {
list = append(list, &e)
}
@@ -1419,9 +1569,10 @@ func (s *Store) GetErrorStats() map[string]int {
"critical": 0,
"high": 0,
"escalated": 0,
"drafts": 0,
}
rows, err := s.primaryDB.Query(`SELECT status, severity, linked_ticket_id FROM errors`)
rows, err := s.primaryDB.Query(`SELECT status, severity, linked_ticket_id, is_draft FROM errors`)
if err != nil {
return stats
}
@@ -1429,7 +1580,12 @@ func (s *Store) GetErrorStats() map[string]int {
for rows.Next() {
var st, sev, lk string
if err := rows.Scan(&st, &sev, &lk); err == nil {
var isDraft bool
if err := rows.Scan(&st, &sev, &lk, &isDraft); err == nil {
if isDraft {
stats["drafts"]++
continue
}
stats["total"]++
switch strings.ToLower(st) {
case "unresolved":