Extract Grammaratur, Dregarnuhr, Geduldh, Mestionora, Ordoschnellic, Schutzaria, Kunstzeal and Seheweit behind compatible application contracts. Include accumulated editor resilience, navigation and theme UX, remote CLI, storage/schema and DR groundwork, tests and design/operations documentation. Verified: uncached full Go suite; go vet ./...; race tests for all eight components; 11 targeted Chromium tests; Node suites; 19 Python CLI tests; reproducible editor build. No push, release tag or deployment in this checkpoint.
690 lines
25 KiB
Go
690 lines
25 KiB
Go
package store
|
||
|
||
import (
|
||
"context"
|
||
"database/sql"
|
||
"errors"
|
||
"fmt"
|
||
"strings"
|
||
"time"
|
||
|
||
"github.com/google/uuid"
|
||
"pageswiki/internal/dregarnuhr"
|
||
)
|
||
|
||
// EventJob retains the existing public JSON shape and source compatibility.
|
||
type EventJob = dregarnuhr.Job
|
||
|
||
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 = dregarnuhr.Settings
|
||
|
||
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 = dregarnuhr.ErrSkipped
|
||
|
||
func (s *Store) EnsureEventJobsSchema() error {
|
||
if err := s.ensureSchemaComponent("event-jobs"); err != nil {
|
||
return err
|
||
}
|
||
return s.recoverInterruptedEventJobs()
|
||
}
|
||
|
||
// Startup recovery mutates runtime state, not schema. Never call it from
|
||
// status/preflight, read-only standby or a migration rehearsal.
|
||
func (s *Store) recoverInterruptedEventJobs() error {
|
||
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) {
|
||
return s.ClaimDueEventAt(context.Background(), time.Now())
|
||
}
|
||
|
||
// ClaimDueEventAt keeps selection and claim in one statement; injected time
|
||
// allows scheduler tests without real sleeps or production data.
|
||
func (s *Store) ClaimDueEventAt(ctx context.Context, at time.Time) (*EventJob, error) {
|
||
if s.ReadOnly {
|
||
return nil, ErrReadOnly
|
||
}
|
||
now := at.UnixMilli()
|
||
// A deferred SELECT transaction cannot always upgrade its WAL snapshot to a
|
||
// writer (SQLITE_BUSY[_SNAPSHOT]), even with busy_timeout. Select and claim in
|
||
// one write statement instead. SQLite serializes concurrent claimers; RETURNING
|
||
// gives the committed attempt/status/timestamps, not the pre-claim snapshot.
|
||
return scanEventJob(s.DB.QueryRowContext(ctx, `
|
||
UPDATE event_jobs SET status='running', attempts=attempts+1,
|
||
started_at_ms=?, updated_at_ms=?
|
||
WHERE uuid=(SELECT uuid FROM event_jobs
|
||
WHERE status='queued' AND run_at_ms<=?
|
||
ORDER BY priority DESC,run_at_ms,created_at_ms,uuid LIMIT 1)
|
||
AND status='queued'
|
||
RETURNING `+eventJobColumns, now, now, now))
|
||
}
|
||
|
||
func (s *Store) FinishEvent(uuid string, runErr error) error {
|
||
return s.FinishEventAt(context.Background(), uuid, runErr, time.Now())
|
||
}
|
||
|
||
func (s *Store) FinishEventAt(ctx context.Context, uuid string, runErr error, at time.Time) error {
|
||
job, err := scanEventJob(s.DB.QueryRowContext(ctx, `SELECT `+eventJobColumns+` FROM event_jobs WHERE uuid=?`, uuid))
|
||
if err != nil {
|
||
return err
|
||
}
|
||
base := 1
|
||
if runErr != nil && !errors.Is(runErr, ErrEventSkipped) && !job.CancelRequested && job.Attempts < job.MaxAttempts {
|
||
settings, err := s.GetQueueSettings()
|
||
if err != nil {
|
||
return err
|
||
}
|
||
base = settings.RetryBaseSeconds
|
||
}
|
||
outcome := dregarnuhr.Complete(*job, runErr, base, at)
|
||
if outcome.Status == "queued" {
|
||
_, err = s.DB.ExecContext(ctx, `UPDATE event_jobs SET status='queued', error=?,
|
||
run_at_ms=?, finished_at_ms=0, updated_at_ms=? WHERE uuid=?`,
|
||
outcome.Message, outcome.RetryAt.UnixMilli(), at.UnixMilli(), uuid)
|
||
if err == nil {
|
||
_ = s.AddEventLog(uuid, job.EventUUID, outcome.Level, "execution failed; retry scheduled: "+outcome.Message)
|
||
}
|
||
return err
|
||
}
|
||
_, err = s.DB.ExecContext(ctx, `UPDATE event_jobs SET status=?, error=?,
|
||
finished_at_ms=?, updated_at_ms=? WHERE uuid=?`,
|
||
outcome.Status, outcome.Message, at.UnixMilli(), at.UnixMilli(), uuid)
|
||
message := outcome.Status
|
||
if outcome.Message != "" {
|
||
message += ": " + outcome.Message
|
||
}
|
||
if err == nil {
|
||
_ = s.AddEventLog(uuid, job.EventUUID, outcome.Level, message)
|
||
}
|
||
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 {
|
||
requested, err := s.EventCancellationState(context.Background(), jobUUID)
|
||
return err == nil && requested
|
||
}
|
||
|
||
// EventCancellationState lets the runner distinguish a read failure from a
|
||
// confirmed absence of cancellation. The boolean compatibility API stays.
|
||
func (s *Store) EventCancellationState(ctx context.Context, jobUUID string) (bool, error) {
|
||
var requested int
|
||
err := s.DB.QueryRowContext(ctx, `SELECT cancel_requested FROM event_jobs WHERE uuid=?`, jobUUID).Scan(&requested)
|
||
return requested != 0, err
|
||
}
|
||
|
||
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
|
||
}
|