Files
pages/internal/store/event_jobs.go
T
2026-11-15 05:47:14 +09:00

810 lines
33 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"
"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() (resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
if err := s.ensureSchemaComponent("event-jobs"); err != nil {
return err
}
if s.sqlBackend == storePostgreSQL {
// Native schema initialization never steals a live worker's execution.
return nil
}
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() (resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
if s.sqlBackend == storePostgreSQL {
return ErrPostgreSQLComponentNotReady
}
now := time.Now().UnixMilli()
if _, err := s.execEventSQL(`UPDATE event_jobs SET status='queued',
error=CASE WHEN error='' THEN 'execution interrupted by process restart' ELSE error END,
run_at_ms=`+s.sqlParam(1)+`, started_at_ms=0, updated_at_ms=`+s.sqlParam(2)+`
WHERE status='running'`, now, now); err != nil {
return err
}
return nil
}
func (s *Store) EnqueueEvent(eventType, eventKey, payload string, runAt time.Time) (_ bool, resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
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, resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
if s.sqlBackend == storePostgreSQL {
var queued bool
err := s.withNativeEventWriter(context.Background(), func(tx *sql.Tx) error {
var err error
queued, err = s.enqueueNativeEventTx(context.Background(), tx, eventUUID, eventType, eventKey, payload, runAt, priority, maxAttempts)
return err
})
return queued, err
}
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.execEventSQL(`
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 `+s.sqlParam(1)+`, `+s.sqlParam(2)+`, `+s.sqlParam(3)+`, `+s.sqlParam(4)+`, `+s.sqlParam(5)+`, 'queued', `+s.sqlParam(6)+`, 0, `+s.sqlParam(7)+`, `+s.sqlParam(8)+`, '', `+s.sqlParam(9)+`, `+s.sqlParam(10)+`
WHERE NOT EXISTS (
SELECT 1 FROM event_jobs WHERE event_type = `+s.sqlParam(11)+` AND event_key = `+s.sqlParam(12)+`
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, resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
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, resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
if s.ReadOnly {
return nil, ErrReadOnly
}
if s.sqlBackend == storePostgreSQL {
return s.claimNativeEvent(ctx, at)
}
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=`+s.sqlParam(1)+`, updated_at_ms=`+s.sqlParam(2)+`
WHERE uuid=(SELECT uuid FROM event_jobs
WHERE status='queued' AND run_at_ms<=`+s.sqlParam(3)+`
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) (resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
return s.FinishEventAt(context.Background(), uuid, runErr, time.Now())
}
func (s *Store) FinishEventAt(ctx context.Context, uuid string, runErr error, at time.Time) (resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
if s.sqlBackend == storePostgreSQL {
return ErrEventClaim
}
job, err := scanEventJob(s.DB.QueryRowContext(ctx, `SELECT `+eventJobColumns+` FROM event_jobs WHERE uuid=`+s.sqlParam(1), 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=`+s.sqlParam(1)+`,
run_at_ms=`+s.sqlParam(2)+`, finished_at_ms=0, updated_at_ms=`+s.sqlParam(3)+` WHERE uuid=`+s.sqlParam(4),
outcome.Message, outcome.RetryAt.UnixMilli(), at.UnixMilli(), uuid)
if err == nil {
err = s.addEventCompletionLog(ctx, uuid, job.EventUUID, outcome.Level, "execution failed; retry scheduled: "+outcome.Message)
}
return err
}
_, err = s.DB.ExecContext(ctx, `UPDATE event_jobs SET status=`+s.sqlParam(1)+`, error=`+s.sqlParam(2)+`,
finished_at_ms=`+s.sqlParam(3)+`, updated_at_ms=`+s.sqlParam(4)+` WHERE uuid=`+s.sqlParam(5),
outcome.Status, outcome.Message, at.UnixMilli(), at.UnixMilli(), uuid)
message := outcome.Status
if outcome.Message != "" {
message += ": " + outcome.Message
}
if err == nil {
err = s.addEventCompletionLog(ctx, uuid, job.EventUUID, outcome.Level, message)
}
return err
}
func (s *Store) EventStats() (_ EventJobStats, resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
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, resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
return s.eventStats(`SELECT status, COUNT(*) FROM event_jobs WHERE status IN ('queued','running') GROUP BY status`)
}
func (s *Store) eventStats(query string) (_ EventJobStats, resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
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, resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
if limit < 1 || limit > 500 {
limit = 100
}
rows, err := s.DB.Query(`SELECT `+eventJobColumns+` FROM event_jobs ORDER BY created_at_ms DESC LIMIT `+s.sqlParam(1), 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) (resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
result, err := s.execEventSQL(`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 `+s.sqlParam(1)+` ELSE finished_at_ms END,
updated_at_ms=`+s.sqlParam(2)+` WHERE uuid=`+s.sqlParam(3)+` 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) (resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
now := time.Now().UnixMilli()
_, err := s.execEventSQL(`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 `+s.sqlParam(1)+` ELSE finished_at_ms END,
updated_at_ms=`+s.sqlParam(2)+`
WHERE event_type=`+s.sqlParam(3)+` AND event_key=`+s.sqlParam(4)+` AND status IN ('queued','running')`,
now, now, eventType, eventKey)
return err
}
func (s *Store) RetryEventJob(jobUUID string) (resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
if s.sqlBackend == storePostgreSQL {
return s.retryNativeEvent(jobUUID)
}
result, err := s.execEventSQL(`UPDATE event_jobs SET status='queued', attempts=0,
cancel_requested=0, error='', run_at_ms=`+s.sqlParam(1)+`, started_at_ms=0,
finished_at_ms=0, updated_at_ms=`+s.sqlParam(2)+` WHERE uuid=`+s.sqlParam(3)+`
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, resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
var requested int
err := s.DB.QueryRowContext(ctx, `SELECT cancel_requested FROM event_jobs WHERE uuid=`+s.sqlParam(1), jobUUID).Scan(&requested)
return requested != 0, err
}
func (s *Store) PurgeEventHistory(retentionHours int) (resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
if s.sqlBackend == storePostgreSQL {
return ErrBackendFeatureUnavailable
}
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.execEventSQL(`DELETE FROM event_logs AS l WHERE l.created_at_ms < `+s.sqlParam(1)+` 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.execEventSQL(`DELETE FROM event_log_buckets AS b WHERE b.bucket_start_ms < `+s.sqlParam(1)+` 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.execEventSQL(`DELETE FROM event_logs AS l WHERE l.created_at_ms < `+s.sqlParam(1)+` 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=`+s.sqlParam(2)+`)`, policyCutoff, policy.EventType); err != nil {
return err
}
if policy.MaxRows > 0 {
if _, err := s.execEventSQL(`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=`+s.sqlParam(1)+` ORDER BY l.created_at_ms DESC,l.id DESC LIMIT -1 OFFSET `+s.sqlParam(2)+`)`, policy.EventType, policy.MaxRows); err != nil {
return err
}
}
if _, err := s.execEventSQL(`DELETE FROM event_log_buckets WHERE event_type=`+s.sqlParam(1)+` AND bucket_start_ms < `+s.sqlParam(2), policy.EventType, now.Add(-time.Duration(policy.RetentionHours)*time.Hour).UnixMilli()); err != nil {
return err
}
}
_, err = s.execEventSQL(`DELETE FROM event_jobs WHERE updated_at_ms < `+s.sqlParam(1)+`
AND status IN ('succeeded','skipped','failed','cancelled')`, cutoff)
return err
}
func (s *Store) GetQueueSettings() (_ QueueSettings, resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
var q QueueSettings
var paused int
err := s.DB.QueryRowContext(ctx, `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) (resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
if q.Concurrency < 1 || q.Concurrency > 32 || q.MaxDepth < 1 ||
q.RetryBaseSeconds < 1 || q.RetentionHours < 1 {
return errors.New("invalid queue settings")
}
_, err := s.execEventSQL(`UPDATE event_queue_settings SET paused=`+s.sqlParam(1)+`, concurrency=`+s.sqlParam(2)+`,
max_depth=`+s.sqlParam(3)+`, retry_base_seconds=`+s.sqlParam(4)+`, retention_hours=`+s.sqlParam(5)+` WHERE id=1`,
boolToInt(q.Paused), q.Concurrency, q.MaxDepth, q.RetryBaseSeconds, q.RetentionHours)
return err
}
func (s *Store) AddEventLog(jobUUID, eventUUID, level, message string) (resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
return s.AddEventLogContext(context.Background(), jobUUID, eventUUID, level, message)
}
func (s *Store) addEventCompletionLog(ctx context.Context, jobUUID, eventUUID, level, message string) (resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
if err := s.AddEventLogContext(ctx, jobUUID, eventUUID, level, message); err != nil {
return errors.Join(ErrEventCompletionLog, err)
}
return nil
}
// AddEventLogContext atomically persists a raw log and its trend counter. The
// caller's earlier deadline wins; even Background callers have a finite budget.
func (s *Store) AddEventLogContext(ctx context.Context, jobUUID, eventUUID, level, message string) (resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
if s.ReadOnly {
return ErrReadOnly
}
ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
defer cancel()
write := func(tx eventLogSQL) error {
eventType := "unknown"
// The common path is a primary-key lookup, not OR + sorting the retained
// job history while holding the writer lock. Keep event-only fallback.
err := tx.QueryRowContext(ctx, `SELECT event_type FROM event_jobs WHERE uuid=`+s.sqlParam(1), jobUUID).Scan(&eventType)
if errors.Is(err, sql.ErrNoRows) && eventUUID != "" {
err = tx.QueryRowContext(ctx, `SELECT event_type FROM event_jobs WHERE event_uuid=`+s.sqlParam(1)+` LIMIT 1`, eventUUID).Scan(&eventType)
}
if err != nil && !errors.Is(err, sql.ErrNoRows) {
return err
}
if eventType == "" {
eventType = "unknown"
}
policy := EventLogPolicy{EventType: "*", RetentionHours: 168, AggregateAfterHours: 24, BucketSeconds: 60, MaxRows: 5000}
var specific EventLogPolicy
if err := scanEventLogPolicy(tx.QueryRowContext(ctx, `SELECT event_type,retention_hours,aggregate_after_hours,bucket_seconds,max_rows FROM event_log_policies WHERE event_type=`+s.sqlParam(1), eventType), &specific); err == nil {
policy = specific
} else if errors.Is(err, sql.ErrNoRows) {
if err := scanEventLogPolicy(tx.QueryRowContext(ctx, `SELECT event_type,retention_hours,aggregate_after_hours,bucket_seconds,max_rows FROM event_log_policies WHERE event_type='*'`), &policy); err != nil && !errors.Is(err, sql.ErrNoRows) {
return err
}
} else {
return err
}
now := time.Now().UnixMilli()
if _, err := tx.ExecContext(ctx, `INSERT INTO event_logs(job_uuid,event_uuid,level,message,created_at_ms) VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`)`, 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.ExecContext(ctx, `INSERT INTO event_log_buckets(event_type,bucket_start_ms,level,count,first_at_ms,last_at_ms,sample_message)
VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,1,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`,`+s.sqlParam(6)+`) ON CONFLICT(event_type,bucket_start_ms,level) DO UPDATE SET count=event_log_buckets.count+1,last_at_ms=excluded.last_at_ms`, eventType, bucketStart, level, now, now, message); err != nil {
return err
}
return nil
}
if s.sqlBackend == storePostgreSQL {
return s.withNativeEventWriter(ctx, func(tx *sql.Tx) error { return write(tx) })
}
return s.withEventLogWriter(ctx, func(conn *sql.Conn) error { return write(conn) })
}
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, resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
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) (resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
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.execEventSQL(`INSERT INTO event_log_policies(event_type,retention_hours,aggregate_after_hours,bucket_seconds,max_rows)
VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`) 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, resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
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>=` + s.sqlParam(1)
args := []any{sinceMS}
if strings.TrimSpace(eventType) != "" {
query += ` AND event_type=` + s.sqlParam(len(args)+1)
args = append(args, strings.TrimSpace(eventType))
}
query += ` ORDER BY bucket_start_ms DESC,event_type,level LIMIT ` + s.sqlParam(len(args)+1)
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, resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
return s.ListEventLogsBefore(jobUUID, limit, 0)
}
func (s *Store) ListEventLogsBefore(jobUUID string, limit int, beforeID int64) (_ []EventLog, resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
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=` + s.sqlParam(len(args)+1)
args = append(args, jobUUID)
}
if beforeID > 0 {
query += ` AND id < ` + s.sqlParam(len(args)+1)
args = append(args, beforeID)
}
query += ` ORDER BY id DESC LIMIT ` + s.sqlParam(len(args)+1)
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
}
// EnsureBuiltinEventDefinition registers a default without overwriting an
// administrator's existing schedule, including disabled definitions.
func (s *Store) EnsureBuiltinEventDefinition(event EventDefinition) (resultErr error) {
defer func() { resultErr = s.sqlError("builtin event definition", resultErr) }()
if event.UUID == "" {
return errors.New("builtin event requires a fixed identifier")
}
if err := validateEventDefinition(event); err != nil {
return err
}
now := time.Now().UnixMilli()
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()
}
_, err := s.execEventSQL(`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(`+s.sqlValues(13)+`) ON CONFLICT(uuid) DO NOTHING`, event.UUID, event.Name, event.EventType, event.EventKey, event.Payload, event.ScheduleKind, event.IntervalSeconds, event.NextRunAtMS, boolToInt(event.Enabled), event.Priority, event.MaxAttempts, now, now)
return err
}
func (s *Store) SaveEventDefinition(event *EventDefinition) (resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
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.execEventSQL(`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(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`,`+s.sqlParam(6)+`,`+s.sqlParam(7)+`,`+s.sqlParam(8)+`,`+s.sqlParam(9)+`,`+s.sqlParam(10)+`,`+s.sqlParam(11)+`,`+s.sqlParam(12)+`,`+s.sqlParam(13)+`)
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, boolToInt(event.Enabled),
event.Priority, event.MaxAttempts, event.CreatedAtMS, event.UpdatedAtMS)
return err
}
func (s *Store) ListEventDefinitions() (_ []EventDefinition, resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
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) (resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
if eventUUID == ResourceEventID {
return errors.New("disable the builtin resource event instead of deleting it")
}
_, err := s.execEventSQL(`DELETE FROM event_definitions WHERE uuid=`+s.sqlParam(1), eventUUID)
return err
}
func (s *Store) RunEventDefinition(eventUUID string) (_ bool, resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
if s.sqlBackend == storePostgreSQL {
return s.runNativeDefinition(eventUUID)
}
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=`+s.sqlParam(1), 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, resultErr error) {
defer func() { resultErr = s.sqlError("event repository", resultErr) }()
if s.sqlBackend == storePostgreSQL {
return s.enqueueNativeDefinitions(context.Background(), now)
}
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<=`+s.sqlParam(1),
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.execEventSQL(`UPDATE event_definitions SET
next_run_at_ms=CASE schedule_kind WHEN 'once' THEN 0
ELSE `+s.sqlParam(1)+` + interval_seconds*1000 END,
enabled=CASE schedule_kind WHEN 'once' THEN 0 ELSE enabled END,
updated_at_ms=`+s.sqlParam(2)+` WHERE uuid=`+s.sqlParam(3), now.UnixMilli(), now.UnixMilli(), id)
if err != nil {
return count, err
}
}
return count, nil
}