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

81 lines
2.9 KiB
Go

package store
import (
"context"
"encoding/json"
"time"
"pageswiki/internal/seheweit"
)
const ResourceEventID = seheweit.ResourceEventID
const ResourceEventType = seheweit.ResourceEventType
func (s *Store) EnsureResourceHistorySchema() error {
return s.ensureSchemaComponent("resource-history")
}
func (s *Store) EnsureBuiltinResourceEvent() error {
if s.sqlBackend == storePostgreSQL {
return s.ensureNativeBuiltinEvent(ResourceEventID, "Resource monitoring", ResourceEventType, 60, 100, 1)
}
now := time.Now().UnixMilli()
_, err := s.DB.Exec(`INSERT OR IGNORE 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(?,?,?,?,?,'interval',60,?,1,100,1,?,?)`, ResourceEventID, "Resource monitoring", ResourceEventType, "local", "{}", now, now, now)
return err
}
func (s *Store) SaveResourceSample(job string, at int64, payload []byte) error {
return s.SaveResourceSampleContext(context.Background(), job, at, payload)
}
func (s *Store) SaveResourceSampleContext(ctx context.Context, job string, at int64, payload []byte) (resultErr error) {
defer func() { resultErr = s.sqlError("resource sample", resultErr) }()
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
if s.ReadOnly {
return ErrReadOnly
}
tx, err := s.DB.BeginTx(ctx, nil)
if err != nil {
return err
}
defer tx.Rollback()
if err = s.lockTaskWriter(ctx, tx); err != nil {
return err
}
if _, err = tx.ExecContext(ctx, `INSERT INTO resource_samples(job_uuid,timestamp_ms,payload) VALUES(`+s.sqlValues(3)+`) ON CONFLICT(job_uuid) DO NOTHING`, job, at, string(payload)); err != nil {
return err
}
if _, err = tx.ExecContext(ctx, `DELETE FROM resource_samples WHERE timestamp_ms < `+s.sqlParam(1), seheweit.RetentionCutoff(at)); err != nil {
return err
}
return tx.Commit()
}
// Return the last inserted sample in each time bucket, not averages or peaks.
// At most 361 points and an indexed seven-day scan; no request-side collection.
func (s *Store) ResourceHistory(ctx context.Context, hours int, now time.Time) (_ []json.RawMessage, resultErr error) {
defer func() { resultErr = s.sqlError("resource history", resultErr) }()
ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
defer cancel()
window := seheweit.Window(hours, now)
rows, err := s.DB.QueryContext(ctx, `SELECT payload FROM resource_samples WHERE id IN
(SELECT MAX(id) FROM resource_samples WHERE timestamp_ms>=`+s.sqlParam(1)+` AND timestamp_ms<=`+s.sqlParam(2)+` GROUP BY timestamp_ms / `+s.sqlParam(3)+`)
ORDER BY timestamp_ms LIMIT `+s.sqlParam(4), window.FromMS, window.ToMS, window.BucketMS, seheweit.MaxHistoryPoints)
if err != nil {
return nil, err
}
defer rows.Close()
out := []json.RawMessage{}
for rows.Next() {
var raw string
if err := rows.Scan(&raw); err != nil {
return nil, err
}
out = append(out, json.RawMessage(raw))
}
return out, rows.Err()
}