Files
pages/internal/store/event_jobs.go
T
Anya Tokugawa c1175d389f Implement Knowledge City platform, organizer and DAV integration
Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming.

Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
2026-09-27 14:44:43 +09:00

802 lines
29 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package store
import (
"context"
"database/sql"
"errors"
"fmt"
"strings"
"time"
"github.com/google/uuid"
)
type EventJob struct {
UUID string `json:"uuid"`
EventUUID string `json:"event_uuid,omitempty"`
Type string `json:"event_type"`
Key string `json:"event_key"`
Payload string `json:"payload,omitempty"`
Status string `json:"status"`
Priority int `json:"priority"`
Attempts int `json:"attempts"`
MaxAttempts int `json:"max_attempts"`
RunAtMS int64 `json:"run_at_ms"`
StartedAtMS int64 `json:"started_at_ms,omitempty"`
FinishedAtMS int64 `json:"finished_at_ms,omitempty"`
CancelRequested bool `json:"cancel_requested"`
Error string `json:"error,omitempty"`
CreatedAt int64 `json:"created_at_ms"`
UpdatedAt int64 `json:"updated_at_ms"`
}
type EventDefinition struct {
UUID string `json:"uuid"`
Name string `json:"name"`
EventType string `json:"event_type"`
EventKey string `json:"event_key"`
Payload string `json:"payload"`
ScheduleKind string `json:"schedule_kind"`
IntervalSeconds int64 `json:"interval_seconds"`
NextRunAtMS int64 `json:"next_run_at_ms"`
Enabled bool `json:"enabled"`
Priority int `json:"priority"`
MaxAttempts int `json:"max_attempts"`
CreatedAtMS int64 `json:"created_at_ms"`
UpdatedAtMS int64 `json:"updated_at_ms"`
}
type EventLog struct {
ID int64 `json:"id"`
JobUUID string `json:"job_uuid"`
EventUUID string `json:"event_uuid,omitempty"`
EventType string `json:"event_type,omitempty"`
Level string `json:"level"`
Message string `json:"message"`
CreatedAtMS int64 `json:"created_at_ms"`
}
type EventLogPolicy struct {
EventType string `json:"event_type"`
RetentionHours int `json:"retention_hours"`
AggregateAfterHours int `json:"aggregate_after_hours"`
BucketSeconds int `json:"bucket_seconds"`
MaxRows int `json:"max_rows"`
}
type EventLogTrend struct {
EventType string `json:"event_type"`
BucketStartMS int64 `json:"bucket_start_ms"`
Level string `json:"level"`
Count int64 `json:"count"`
FirstAtMS int64 `json:"first_at_ms"`
LastAtMS int64 `json:"last_at_ms"`
SampleMessage string `json:"sample_message,omitempty"`
}
type QueueSettings struct {
Paused bool `json:"paused"`
Concurrency int `json:"concurrency"`
MaxDepth int `json:"max_depth"`
RetryBaseSeconds int `json:"retry_base_seconds"`
RetentionHours int `json:"retention_hours"`
}
type EventJobStats struct {
Queued int `json:"queued"`
Running int `json:"running"`
Succeeded int `json:"succeeded"`
Skipped int `json:"skipped"`
Failed int `json:"failed"`
Cancelled int `json:"cancelled"`
}
var ErrEventSkipped = errors.New("event is not applicable")
func (s *Store) EnsureEventJobsSchema() error {
if _, err := s.DB.Exec(`
CREATE TABLE IF NOT EXISTS event_jobs (
uuid TEXT PRIMARY KEY,
event_type TEXT NOT NULL,
event_key TEXT NOT NULL,
payload TEXT NOT NULL,
status TEXT NOT NULL,
attempts INTEGER NOT NULL DEFAULT 0,
run_at_ms INTEGER NOT NULL,
error TEXT NOT NULL DEFAULT '',
created_at_ms INTEGER NOT NULL,
updated_at_ms INTEGER NOT NULL
)
`); err != nil {
return err
}
for _, statement := range []string{
`ALTER TABLE event_jobs ADD COLUMN event_uuid TEXT NOT NULL DEFAULT ''`,
`ALTER TABLE event_jobs ADD COLUMN priority INTEGER NOT NULL DEFAULT 0`,
`ALTER TABLE event_jobs ADD COLUMN max_attempts INTEGER NOT NULL DEFAULT 3`,
`ALTER TABLE event_jobs ADD COLUMN started_at_ms INTEGER NOT NULL DEFAULT 0`,
`ALTER TABLE event_jobs ADD COLUMN finished_at_ms INTEGER NOT NULL DEFAULT 0`,
`ALTER TABLE event_jobs ADD COLUMN cancel_requested INTEGER NOT NULL DEFAULT 0`,
} {
_, _ = s.DB.Exec(statement)
}
statements := []string{
`CREATE INDEX IF NOT EXISTS idx_event_jobs_listing ON event_jobs (created_at_ms DESC, uuid DESC)`,
`CREATE INDEX IF NOT EXISTS idx_event_jobs_status_listing ON event_jobs (status, created_at_ms DESC, uuid DESC)`,
`CREATE INDEX IF NOT EXISTS idx_event_jobs_history ON event_jobs (created_at_ms DESC, uuid DESC) WHERE status IN ('succeeded','skipped','failed','cancelled')`,
`CREATE INDEX IF NOT EXISTS idx_event_jobs_due
ON event_jobs (status, priority DESC, run_at_ms, created_at_ms)`,
`CREATE TABLE IF NOT EXISTS event_definitions (
uuid TEXT PRIMARY KEY, name TEXT NOT NULL, event_type TEXT NOT NULL,
event_key TEXT NOT NULL, payload TEXT NOT NULL DEFAULT '',
schedule_kind TEXT NOT NULL DEFAULT 'manual',
interval_seconds INTEGER NOT NULL DEFAULT 0,
next_run_at_ms INTEGER NOT NULL DEFAULT 0,
enabled INTEGER NOT NULL DEFAULT 1, priority INTEGER NOT NULL DEFAULT 0,
max_attempts INTEGER NOT NULL DEFAULT 3,
created_at_ms INTEGER NOT NULL, updated_at_ms INTEGER NOT NULL
)`,
`CREATE INDEX IF NOT EXISTS idx_event_definitions_due
ON event_definitions (enabled, next_run_at_ms)`,
`CREATE TABLE IF NOT EXISTS event_logs (
id INTEGER PRIMARY KEY AUTOINCREMENT, job_uuid TEXT NOT NULL,
event_uuid TEXT NOT NULL DEFAULT '', level TEXT NOT NULL,
message TEXT NOT NULL, created_at_ms INTEGER NOT NULL
)`,
`CREATE INDEX IF NOT EXISTS idx_event_logs_job
ON event_logs (job_uuid, created_at_ms DESC)`,
`CREATE INDEX IF NOT EXISTS idx_event_logs_job_id ON event_logs (job_uuid, id DESC)`,
`CREATE TABLE IF NOT EXISTS event_log_policies (
event_type TEXT PRIMARY KEY,
retention_hours INTEGER NOT NULL DEFAULT 168,
aggregate_after_hours INTEGER NOT NULL DEFAULT 24,
bucket_seconds INTEGER NOT NULL DEFAULT 60,
max_rows INTEGER NOT NULL DEFAULT 5000
)`,
`INSERT OR IGNORE INTO event_log_policies(event_type,retention_hours,aggregate_after_hours,bucket_seconds,max_rows)
VALUES('*',168,24,60,5000)`,
`CREATE TABLE IF NOT EXISTS event_log_buckets (
event_type TEXT NOT NULL,
bucket_start_ms INTEGER NOT NULL,
level TEXT NOT NULL,
count INTEGER NOT NULL DEFAULT 0,
first_at_ms INTEGER NOT NULL,
last_at_ms INTEGER NOT NULL,
sample_message TEXT NOT NULL DEFAULT '',
PRIMARY KEY(event_type,bucket_start_ms,level)
)`,
`CREATE INDEX IF NOT EXISTS idx_event_log_buckets_time ON event_log_buckets(event_type,bucket_start_ms DESC)`,
`CREATE TABLE IF NOT EXISTS event_queue_settings (
id INTEGER PRIMARY KEY CHECK (id = 1), paused INTEGER NOT NULL DEFAULT 0,
concurrency INTEGER NOT NULL DEFAULT 1,
max_depth INTEGER NOT NULL DEFAULT 10000,
retry_base_seconds INTEGER NOT NULL DEFAULT 30,
retention_hours INTEGER NOT NULL DEFAULT 168
)`,
`INSERT OR IGNORE INTO event_queue_settings
(id, paused, concurrency, max_depth, retry_base_seconds, retention_hours)
VALUES (1, 0, 1, 10000, 30, 168)`,
}
for _, statement := range statements {
if _, err := s.DB.Exec(statement); err != nil {
return err
}
}
now := time.Now().UnixMilli()
if _, err := s.DB.Exec(`UPDATE event_jobs SET status='queued',
error=CASE WHEN error='' THEN 'execution interrupted by process restart' ELSE error END,
run_at_ms=?, started_at_ms=0, updated_at_ms=?
WHERE status='running'`, now, now); err != nil {
return err
}
return nil
}
func (s *Store) EnqueueEvent(eventType, eventKey, payload string, runAt time.Time) (bool, error) {
return s.EnqueueEventWithOptions("", eventType, eventKey, payload, runAt, 0, 3)
}
func (s *Store) EnqueueEventWithOptions(eventUUID, eventType, eventKey, payload string, runAt time.Time, priority, maxAttempts int) (bool, error) {
settings, err := s.GetQueueSettings()
if err != nil {
return false, err
}
var depth int
if err := s.DB.QueryRow(`SELECT COUNT(*) FROM event_jobs WHERE status IN ('queued','running')`).Scan(&depth); err != nil {
return false, err
}
if depth >= settings.MaxDepth {
return false, fmt.Errorf("event queue is full (%d)", settings.MaxDepth)
}
if maxAttempts < 1 {
maxAttempts = 1
}
now := time.Now().UnixMilli()
result, err := s.DB.Exec(`
INSERT INTO event_jobs (
uuid, event_uuid, event_type, event_key, payload, status, priority,
attempts, max_attempts, run_at_ms, error, created_at_ms, updated_at_ms
)
SELECT ?, ?, ?, ?, ?, 'queued', ?, 0, ?, ?, '', ?, ?
WHERE NOT EXISTS (
SELECT 1 FROM event_jobs WHERE event_type = ? AND event_key = ?
AND status IN ('queued', 'running')
)`,
uuid.NewString(), eventUUID, eventType, eventKey, payload, priority,
maxAttempts, runAt.UnixMilli(), now, now, eventType, eventKey,
)
if err != nil {
return false, err
}
count, err := result.RowsAffected()
return count > 0, err
}
func scanEventJob(scanner interface{ Scan(...any) error }) (*EventJob, error) {
var job EventJob
var cancelled int
err := scanner.Scan(
&job.UUID, &job.EventUUID, &job.Type, &job.Key, &job.Payload,
&job.Status, &job.Priority, &job.Attempts, &job.MaxAttempts,
&job.RunAtMS, &job.StartedAtMS, &job.FinishedAtMS, &cancelled,
&job.Error, &job.CreatedAt, &job.UpdatedAt,
)
job.CancelRequested = cancelled != 0
return &job, err
}
const eventJobColumns = `uuid, event_uuid, event_type, event_key, payload,
status, priority, attempts, max_attempts, run_at_ms, started_at_ms,
finished_at_ms, cancel_requested, error, created_at_ms, updated_at_ms`
func (s *Store) ClaimDueEvent() (*EventJob, error) {
tx, err := s.DB.Begin()
if err != nil {
return nil, err
}
defer tx.Rollback()
job, err := scanEventJob(tx.QueryRow(`
SELECT `+eventJobColumns+` FROM event_jobs
WHERE status = 'queued' AND run_at_ms <= ?
ORDER BY priority DESC, run_at_ms, created_at_ms LIMIT 1`,
time.Now().UnixMilli()))
if err != nil {
return nil, err
}
now := time.Now().UnixMilli()
result, err := tx.Exec(`
UPDATE event_jobs SET status='running', attempts=attempts+1,
started_at_ms=?, updated_at_ms=? WHERE uuid=? AND status='queued'`,
now, now, job.UUID)
if err != nil {
return nil, err
}
count, err := result.RowsAffected()
if err != nil || count != 1 {
return nil, sql.ErrNoRows
}
if err := tx.Commit(); err != nil {
return nil, err
}
job.Status, job.Attempts, job.StartedAtMS = "running", job.Attempts+1, now
return job, nil
}
func (s *Store) FinishEvent(uuid string, runErr error) error {
job, err := scanEventJob(s.DB.QueryRow(`SELECT `+eventJobColumns+` FROM event_jobs WHERE uuid=?`, uuid))
if err != nil {
return err
}
status, message := "succeeded", ""
if runErr != nil {
message = runErr.Error()
if errors.Is(runErr, ErrEventSkipped) {
status = "skipped"
} else if job.CancelRequested {
status = "cancelled"
} else if job.Attempts < job.MaxAttempts {
settings, settingsErr := s.GetQueueSettings()
if settingsErr != nil {
return settingsErr
}
delay := time.Duration(settings.RetryBaseSeconds) * time.Second
for i := 1; i < job.Attempts; i++ {
delay *= 2
if delay >= 24*time.Hour {
delay = 24 * time.Hour
break
}
}
_, err = s.DB.Exec(`UPDATE event_jobs SET status='queued', error=?,
run_at_ms=?, finished_at_ms=0, updated_at_ms=? WHERE uuid=?`,
message, time.Now().Add(delay).UnixMilli(), time.Now().UnixMilli(), uuid)
_ = s.AddEventLog(uuid, job.EventUUID, "warning", "execution failed; retry scheduled: "+message)
return err
} else {
status = "failed"
}
}
now := time.Now().UnixMilli()
_, err = s.DB.Exec(`UPDATE event_jobs SET status=?, error=?,
finished_at_ms=?, updated_at_ms=? WHERE uuid=?`,
status, message, now, now, uuid)
level := "info"
if status == "failed" {
level = "error"
}
_ = s.AddEventLog(uuid, job.EventUUID, level, status+func() string {
if message != "" {
return ": " + message
}
return ""
}())
return err
}
func (s *Store) EventStats() (EventJobStats, error) {
return s.eventStats(`SELECT status, COUNT(*) FROM event_jobs GROUP BY status`)
}
// Live monitoring must not count the entire retained execution history every
// few seconds. The status index restricts this to the active queue.
func (s *Store) ActiveEventStats() (EventJobStats, error) {
return s.eventStats(`SELECT status, COUNT(*) FROM event_jobs WHERE status IN ('queued','running') GROUP BY status`)
}
func (s *Store) eventStats(query string) (EventJobStats, error) {
var stats EventJobStats
rows, err := s.DB.Query(query)
if err != nil {
return stats, err
}
defer rows.Close()
for rows.Next() {
var status string
var count int
if err := rows.Scan(&status, &count); err != nil {
return stats, err
}
switch status {
case "queued":
stats.Queued = count
case "running":
stats.Running = count
case "succeeded":
stats.Succeeded = count
case "skipped":
stats.Skipped = count
case "failed":
stats.Failed = count
case "cancelled":
stats.Cancelled = count
}
}
return stats, rows.Err()
}
func (s *Store) ListEventJobs(limit int) ([]EventJob, error) {
if limit < 1 || limit > 500 {
limit = 100
}
rows, err := s.DB.Query(`SELECT `+eventJobColumns+` FROM event_jobs ORDER BY created_at_ms DESC LIMIT ?`, limit)
if err != nil {
return nil, err
}
defer rows.Close()
out := make([]EventJob, 0)
for rows.Next() {
job, err := scanEventJob(rows)
if err != nil {
return nil, err
}
out = append(out, *job)
}
return out, rows.Err()
}
func (s *Store) CancelEventJob(jobUUID string) error {
result, err := s.DB.Exec(`UPDATE event_jobs SET
status=CASE WHEN status='queued' THEN 'cancelled' ELSE status END,
cancel_requested=1, finished_at_ms=CASE WHEN status='queued' THEN ? ELSE finished_at_ms END,
updated_at_ms=? WHERE uuid=? AND status IN ('queued','running')`,
time.Now().UnixMilli(), time.Now().UnixMilli(), jobUUID)
if err != nil {
return err
}
count, _ := result.RowsAffected()
if count == 0 {
return sql.ErrNoRows
}
return s.AddEventLog(jobUUID, "", "warning", "cancellation requested")
}
// CancelEventJobsByTypeKey is used when the resource that owns queued work is
// deleted. Historical jobs are retained; queued jobs become cancelled and a
// running worker observes cancel_requested before committing its result.
func (s *Store) CancelEventJobsByTypeKey(eventType, eventKey string) error {
now := time.Now().UnixMilli()
_, err := s.DB.Exec(`UPDATE event_jobs SET
status=CASE WHEN status='queued' THEN 'cancelled' ELSE status END,
cancel_requested=1,
finished_at_ms=CASE WHEN status='queued' THEN ? ELSE finished_at_ms END,
updated_at_ms=?
WHERE event_type=? AND event_key=? AND status IN ('queued','running')`,
now, now, eventType, eventKey)
return err
}
func (s *Store) RetryEventJob(jobUUID string) error {
result, err := s.DB.Exec(`UPDATE event_jobs SET status='queued', attempts=0,
cancel_requested=0, error='', run_at_ms=?, started_at_ms=0,
finished_at_ms=0, updated_at_ms=? WHERE uuid=?
AND status IN ('failed','cancelled','skipped')`,
time.Now().UnixMilli(), time.Now().UnixMilli(), jobUUID)
if err != nil {
return err
}
count, _ := result.RowsAffected()
if count == 0 {
return sql.ErrNoRows
}
return s.AddEventLog(jobUUID, "", "info", "manually requeued")
}
func (s *Store) EventCancellationRequested(jobUUID string) bool {
var requested int
err := s.DB.QueryRow(`SELECT cancel_requested FROM event_jobs WHERE uuid=?`, jobUUID).Scan(&requested)
return err == nil && requested != 0
}
func (s *Store) PurgeEventHistory(retentionHours int) error {
if retentionHours < 1 {
return errors.New("retention hours must be positive")
}
cutoff := time.Now().Add(-time.Duration(retentionHours) * time.Hour).UnixMilli()
// Keep explicit event policies authoritative. The wildcard policy and
// unknown jobs use the queue-level retention as their fallback.
if _, err := s.DB.Exec(`DELETE FROM event_logs AS l WHERE l.created_at_ms < ? AND NOT EXISTS (
SELECT 1 FROM event_jobs j JOIN event_log_policies p ON p.event_type=j.event_type
WHERE (j.uuid=l.job_uuid OR (j.event_uuid<>'' AND j.event_uuid=l.event_uuid))
)`, cutoff); err != nil {
return err
}
if _, err := s.DB.Exec(`DELETE FROM event_log_buckets AS b WHERE b.bucket_start_ms < ? AND NOT EXISTS (
SELECT 1 FROM event_log_policies p WHERE p.event_type=b.event_type AND p.event_type<>'*'
)`, cutoff); err != nil {
return err
}
policies, err := s.ListEventLogPolicies()
if err != nil {
return err
}
now := time.Now()
for _, policy := range policies {
if policy.EventType == "*" {
continue
}
policyCutoff := now.Add(-time.Duration(policy.RetentionHours) * time.Hour).UnixMilli()
if policy.AggregateAfterHours > 0 {
aggregateCutoff := now.Add(-time.Duration(policy.AggregateAfterHours) * time.Hour).UnixMilli()
if aggregateCutoff > policyCutoff {
policyCutoff = aggregateCutoff
}
}
if _, err := s.DB.Exec(`DELETE FROM event_logs AS l WHERE l.created_at_ms < ? AND EXISTS (
SELECT 1 FROM event_jobs j WHERE (j.uuid=l.job_uuid OR (j.event_uuid<>'' AND j.event_uuid=l.event_uuid)) AND j.event_type=?)`, policyCutoff, policy.EventType); err != nil {
return err
}
if policy.MaxRows > 0 {
if _, err := s.DB.Exec(`DELETE FROM event_logs WHERE id IN (
SELECT l.id FROM event_logs l JOIN event_jobs j ON (j.uuid=l.job_uuid OR (j.event_uuid<>'' AND j.event_uuid=l.event_uuid))
WHERE j.event_type=? ORDER BY l.created_at_ms DESC,l.id DESC LIMIT -1 OFFSET ?)`, policy.EventType, policy.MaxRows); err != nil {
return err
}
}
if _, err := s.DB.Exec(`DELETE FROM event_log_buckets WHERE event_type=? AND bucket_start_ms < ?`, policy.EventType, now.Add(-time.Duration(policy.RetentionHours)*time.Hour).UnixMilli()); err != nil {
return err
}
}
_, err = s.DB.Exec(`DELETE FROM event_jobs WHERE updated_at_ms < ?
AND status IN ('succeeded','skipped','failed','cancelled')`, cutoff)
return err
}
func (s *Store) GetQueueSettings() (QueueSettings, error) {
var q QueueSettings
var paused int
err := s.DB.QueryRow(`SELECT paused, concurrency, max_depth,
retry_base_seconds, retention_hours FROM event_queue_settings WHERE id=1`).
Scan(&paused, &q.Concurrency, &q.MaxDepth, &q.RetryBaseSeconds, &q.RetentionHours)
q.Paused = paused != 0
return q, err
}
func (s *Store) SetQueueSettings(q QueueSettings) error {
if q.Concurrency < 1 || q.Concurrency > 32 || q.MaxDepth < 1 ||
q.RetryBaseSeconds < 1 || q.RetentionHours < 1 {
return errors.New("invalid queue settings")
}
_, err := s.DB.Exec(`UPDATE event_queue_settings SET paused=?, concurrency=?,
max_depth=?, retry_base_seconds=?, retention_hours=? WHERE id=1`,
q.Paused, q.Concurrency, q.MaxDepth, q.RetryBaseSeconds, q.RetentionHours)
return err
}
func (s *Store) AddEventLog(jobUUID, eventUUID, level, message string) error {
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
eventType := "unknown"
_ = tx.QueryRow(`SELECT event_type FROM event_jobs WHERE uuid=? OR event_uuid=? ORDER BY CASE WHEN uuid=? THEN 0 ELSE 1 END LIMIT 1`, jobUUID, eventUUID, jobUUID).Scan(&eventType)
if eventType == "" {
eventType = "unknown"
}
policy := EventLogPolicy{EventType: "*", RetentionHours: 168, AggregateAfterHours: 24, BucketSeconds: 60, MaxRows: 5000}
var specific EventLogPolicy
if err := scanEventLogPolicy(tx.QueryRow(`SELECT event_type,retention_hours,aggregate_after_hours,bucket_seconds,max_rows FROM event_log_policies WHERE event_type=?`, eventType), &specific); err == nil {
policy = specific
} else {
_ = scanEventLogPolicy(tx.QueryRow(`SELECT event_type,retention_hours,aggregate_after_hours,bucket_seconds,max_rows FROM event_log_policies WHERE event_type='*'`), &policy)
}
now := time.Now().UnixMilli()
if _, err := tx.Exec(`INSERT INTO event_logs(job_uuid,event_uuid,level,message,created_at_ms) VALUES(?,?,?,?,?)`, jobUUID, eventUUID, level, message, now); err != nil {
return err
}
bucket := int64(policy.BucketSeconds)
if bucket < 1 {
bucket = 60
}
bucketStart := now - (now % (bucket * 1000))
if _, err := tx.Exec(`INSERT INTO event_log_buckets(event_type,bucket_start_ms,level,count,first_at_ms,last_at_ms,sample_message)
VALUES(?,?,?,1,?,?,?) ON CONFLICT(event_type,bucket_start_ms,level) DO UPDATE SET count=count+1,last_at_ms=excluded.last_at_ms`, eventType, bucketStart, level, now, now, message); err != nil {
return err
}
return tx.Commit()
}
func scanEventLogPolicy(scanner interface{ Scan(...any) error }, policy *EventLogPolicy) error {
return scanner.Scan(&policy.EventType, &policy.RetentionHours, &policy.AggregateAfterHours, &policy.BucketSeconds, &policy.MaxRows)
}
func (s *Store) ListEventLogPolicies() ([]EventLogPolicy, error) {
rows, err := s.DB.Query(`SELECT event_type,retention_hours,aggregate_after_hours,bucket_seconds,max_rows FROM event_log_policies ORDER BY event_type`)
if err != nil {
return nil, err
}
defer rows.Close()
items := make([]EventLogPolicy, 0)
for rows.Next() {
var item EventLogPolicy
if err := scanEventLogPolicy(rows, &item); err != nil {
return nil, err
}
items = append(items, item)
}
return items, rows.Err()
}
func (s *Store) SetEventLogPolicy(policy EventLogPolicy) error {
policy.EventType = strings.TrimSpace(policy.EventType)
if policy.EventType == "" || policy.RetentionHours < 1 || policy.RetentionHours > 24*3650 ||
policy.AggregateAfterHours < 0 || policy.AggregateAfterHours > 24*3650 || policy.BucketSeconds < 10 || policy.BucketSeconds > 86400 ||
policy.MaxRows < 100 || policy.MaxRows > 10000000 {
return errors.New("invalid event log policy")
}
_, err := s.DB.Exec(`INSERT INTO event_log_policies(event_type,retention_hours,aggregate_after_hours,bucket_seconds,max_rows)
VALUES(?,?,?,?,?) ON CONFLICT(event_type) DO UPDATE SET retention_hours=excluded.retention_hours,
aggregate_after_hours=excluded.aggregate_after_hours,bucket_seconds=excluded.bucket_seconds,max_rows=excluded.max_rows`,
policy.EventType, policy.RetentionHours, policy.AggregateAfterHours, policy.BucketSeconds, policy.MaxRows)
return err
}
func (s *Store) ListEventLogTrends(ctx context.Context, eventType string, sinceMS int64, limit int) ([]EventLogTrend, error) {
if limit < 1 || limit > 2000 {
limit = 500
}
if sinceMS < 0 {
sinceMS = 0
}
query := `SELECT event_type,bucket_start_ms,level,count,first_at_ms,last_at_ms,sample_message FROM event_log_buckets WHERE bucket_start_ms>=?`
args := []any{sinceMS}
if strings.TrimSpace(eventType) != "" {
query += ` AND event_type=?`
args = append(args, strings.TrimSpace(eventType))
}
query += ` ORDER BY bucket_start_ms DESC,event_type,level LIMIT ?`
args = append(args, limit)
rows, err := s.DB.QueryContext(ctx, query, args...)
if err != nil {
return nil, err
}
defer rows.Close()
items := make([]EventLogTrend, 0, limit)
for rows.Next() {
var item EventLogTrend
if err := rows.Scan(&item.EventType, &item.BucketStartMS, &item.Level, &item.Count, &item.FirstAtMS, &item.LastAtMS, &item.SampleMessage); err != nil {
return nil, err
}
items = append(items, item)
}
return items, rows.Err()
}
func (s *Store) ListEventLogs(jobUUID string, limit int) ([]EventLog, error) {
return s.ListEventLogsBefore(jobUUID, limit, 0)
}
func (s *Store) ListEventLogsBefore(jobUUID string, limit int, beforeID int64) ([]EventLog, error) {
if limit < 1 || limit > 1000 {
limit = 200
}
query := `SELECT l.id,l.job_uuid,l.event_uuid,COALESCE(j.event_type,''),l.level,l.message,l.created_at_ms FROM event_logs l LEFT JOIN event_jobs j ON j.uuid=l.job_uuid WHERE 1=1`
args := []any{}
if jobUUID != "" {
query += ` AND job_uuid=?`
args = append(args, jobUUID)
}
if beforeID > 0 {
query += ` AND id < ?`
args = append(args, beforeID)
}
query += ` ORDER BY id DESC LIMIT ?`
args = append(args, limit)
rows, err := s.DB.Query(query, args...)
if err != nil {
return nil, err
}
defer rows.Close()
out := make([]EventLog, 0)
for rows.Next() {
var item EventLog
if err := rows.Scan(&item.ID, &item.JobUUID, &item.EventUUID, &item.EventType, &item.Level, &item.Message, &item.CreatedAtMS); err != nil {
return nil, err
}
out = append(out, item)
}
return out, rows.Err()
}
func validateEventDefinition(event EventDefinition) error {
if event.UUID == ResourceEventID || event.EventType == ResourceEventType {
if event.UUID != ResourceEventID || event.EventType != ResourceEventType || event.ScheduleKind != "interval" || event.IntervalSeconds < 30 || event.IntervalSeconds > 86400 {
return errors.New("builtin resource monitoring requires its fixed ID and an interval of 30–86400 seconds")
}
}
event.ScheduleKind = strings.ToLower(strings.TrimSpace(event.ScheduleKind))
if event.Name == "" || event.EventType == "" {
return errors.New("name and event_type are required")
}
switch event.ScheduleKind {
case "manual":
case "once":
if event.NextRunAtMS <= 0 {
return errors.New("next_run_at_ms is required for once schedule")
}
case "interval":
if event.IntervalSeconds < 1 {
return errors.New("interval_seconds must be positive")
}
default:
return errors.New("schedule_kind must be manual, once, or interval")
}
return nil
}
func (s *Store) SaveEventDefinition(event *EventDefinition) error {
if err := validateEventDefinition(*event); err != nil {
return err
}
now := time.Now().UnixMilli()
if event.UUID == "" {
event.UUID = uuid.NewString()
event.CreatedAtMS = now
}
if event.MaxAttempts < 1 {
event.MaxAttempts = 3
}
if event.ScheduleKind == "interval" && event.NextRunAtMS == 0 {
event.NextRunAtMS = time.Now().Add(time.Duration(event.IntervalSeconds) * time.Second).UnixMilli()
}
event.UpdatedAtMS = now
_, err := s.DB.Exec(`INSERT INTO event_definitions
(uuid,name,event_type,event_key,payload,schedule_kind,interval_seconds,
next_run_at_ms,enabled,priority,max_attempts,created_at_ms,updated_at_ms)
VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?)
ON CONFLICT(uuid) DO UPDATE SET name=excluded.name,event_type=excluded.event_type,
event_key=excluded.event_key,payload=excluded.payload,schedule_kind=excluded.schedule_kind,
interval_seconds=excluded.interval_seconds,next_run_at_ms=excluded.next_run_at_ms,
enabled=excluded.enabled,priority=excluded.priority,max_attempts=excluded.max_attempts,
updated_at_ms=excluded.updated_at_ms`,
event.UUID, event.Name, event.EventType, event.EventKey, event.Payload,
event.ScheduleKind, event.IntervalSeconds, event.NextRunAtMS, event.Enabled,
event.Priority, event.MaxAttempts, event.CreatedAtMS, event.UpdatedAtMS)
return err
}
func (s *Store) ListEventDefinitions() ([]EventDefinition, error) {
rows, err := s.DB.Query(`SELECT uuid,name,event_type,event_key,payload,schedule_kind,
interval_seconds,next_run_at_ms,enabled,priority,max_attempts,created_at_ms,updated_at_ms
FROM event_definitions ORDER BY name`)
if err != nil {
return nil, err
}
defer rows.Close()
out := make([]EventDefinition, 0)
for rows.Next() {
var item EventDefinition
var enabled int
if err := rows.Scan(&item.UUID, &item.Name, &item.EventType, &item.EventKey,
&item.Payload, &item.ScheduleKind, &item.IntervalSeconds, &item.NextRunAtMS,
&enabled, &item.Priority, &item.MaxAttempts, &item.CreatedAtMS, &item.UpdatedAtMS); err != nil {
return nil, err
}
item.Enabled = enabled != 0
out = append(out, item)
}
return out, rows.Err()
}
func (s *Store) DeleteEventDefinition(eventUUID string) error {
if eventUUID == ResourceEventID {
return errors.New("disable the builtin resource event instead of deleting it")
}
_, err := s.DB.Exec(`DELETE FROM event_definitions WHERE uuid=?`, eventUUID)
return err
}
func (s *Store) RunEventDefinition(eventUUID string) (bool, error) {
var event EventDefinition
var enabled int
err := s.DB.QueryRow(`SELECT uuid,name,event_type,event_key,payload,schedule_kind,
interval_seconds,next_run_at_ms,enabled,priority,max_attempts,created_at_ms,updated_at_ms
FROM event_definitions WHERE uuid=?`, eventUUID).Scan(
&event.UUID, &event.Name, &event.EventType, &event.EventKey, &event.Payload,
&event.ScheduleKind, &event.IntervalSeconds, &event.NextRunAtMS, &enabled,
&event.Priority, &event.MaxAttempts, &event.CreatedAtMS, &event.UpdatedAtMS)
if err != nil {
return false, err
}
return s.EnqueueEventWithOptions(event.UUID, event.EventType,
event.EventKey+":"+uuid.NewString(), event.Payload, time.Now(), event.Priority, event.MaxAttempts)
}
func (s *Store) EnqueueDueDefinitions(now time.Time) (int, error) {
rows, err := s.DB.Query(`SELECT uuid FROM event_definitions WHERE enabled=1
AND schedule_kind IN ('once','interval') AND next_run_at_ms>0 AND next_run_at_ms<=?`,
now.UnixMilli())
if err != nil {
return 0, err
}
var ids []string
for rows.Next() {
var id string
if err := rows.Scan(&id); err != nil {
rows.Close()
return 0, err
}
ids = append(ids, id)
}
rows.Close()
count := 0
for _, id := range ids {
queued, err := s.RunEventDefinition(id)
if err != nil {
return count, err
}
if queued {
count++
}
_, err = s.DB.Exec(`UPDATE event_definitions SET
next_run_at_ms=CASE schedule_kind WHEN 'once' THEN 0
ELSE ? + interval_seconds*1000 END,
enabled=CASE schedule_kind WHEN 'once' THEN 0 ELSE enabled END,
updated_at_ms=? WHERE uuid=?`, now.UnixMilli(), now.UnixMilli(), id)
if err != nil {
return count, err
}
}
return count, nil
}