forked from wrenn/wrenn
270 lines
8.7 KiB
Go
270 lines
8.7 KiB
Go
// Code generated by sqlc. DO NOT EDIT.
|
|
// versions:
|
|
// sqlc v1.30.0
|
|
// source: metrics.sql
|
|
|
|
package db
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/jackc/pgx/v5/pgtype"
|
|
)
|
|
|
|
const deleteMetricPointsByTeam = `-- name: DeleteMetricPointsByTeam :exec
|
|
DELETE FROM sandbox_metric_points
|
|
WHERE sandbox_id IN (SELECT id FROM sandboxes WHERE team_id = $1)
|
|
`
|
|
|
|
func (q *Queries) DeleteMetricPointsByTeam(ctx context.Context, teamID pgtype.UUID) error {
|
|
_, err := q.db.Exec(ctx, deleteMetricPointsByTeam, teamID)
|
|
return err
|
|
}
|
|
|
|
const deleteMetricsSnapshotsByTeam = `-- name: DeleteMetricsSnapshotsByTeam :exec
|
|
DELETE FROM sandbox_metrics_snapshots WHERE team_id = $1
|
|
`
|
|
|
|
func (q *Queries) DeleteMetricsSnapshotsByTeam(ctx context.Context, teamID pgtype.UUID) error {
|
|
_, err := q.db.Exec(ctx, deleteMetricsSnapshotsByTeam, teamID)
|
|
return err
|
|
}
|
|
|
|
const deleteSandboxMetricPoints = `-- name: DeleteSandboxMetricPoints :exec
|
|
DELETE FROM sandbox_metric_points
|
|
WHERE sandbox_id = $1
|
|
`
|
|
|
|
func (q *Queries) DeleteSandboxMetricPoints(ctx context.Context, sandboxID pgtype.UUID) error {
|
|
_, err := q.db.Exec(ctx, deleteSandboxMetricPoints, sandboxID)
|
|
return err
|
|
}
|
|
|
|
const deleteSandboxMetricPointsByTier = `-- name: DeleteSandboxMetricPointsByTier :exec
|
|
DELETE FROM sandbox_metric_points
|
|
WHERE sandbox_id = $1 AND tier = $2
|
|
`
|
|
|
|
type DeleteSandboxMetricPointsByTierParams struct {
|
|
SandboxID pgtype.UUID `json:"sandbox_id"`
|
|
Tier string `json:"tier"`
|
|
}
|
|
|
|
func (q *Queries) DeleteSandboxMetricPointsByTier(ctx context.Context, arg DeleteSandboxMetricPointsByTierParams) error {
|
|
_, err := q.db.Exec(ctx, deleteSandboxMetricPointsByTier, arg.SandboxID, arg.Tier)
|
|
return err
|
|
}
|
|
|
|
const getLiveMetrics = `-- name: GetLiveMetrics :one
|
|
SELECT
|
|
(COUNT(*) FILTER (WHERE status IN ('running', 'starting')))::INTEGER AS running_count,
|
|
(COALESCE(SUM(vcpus) FILTER (WHERE status IN ('running', 'starting')), 0))::INTEGER AS vcpus_reserved,
|
|
(COALESCE(SUM(memory_mb) FILTER (WHERE status IN ('running', 'starting')), 0)
|
|
+ COALESCE(SUM(CEIL(memory_mb::NUMERIC / 2)) FILTER (WHERE status = 'paused'), 0))::INTEGER AS memory_mb_reserved
|
|
FROM sandboxes
|
|
WHERE team_id = $1
|
|
`
|
|
|
|
type GetLiveMetricsRow struct {
|
|
RunningCount int32 `json:"running_count"`
|
|
VcpusReserved int32 `json:"vcpus_reserved"`
|
|
MemoryMbReserved int32 `json:"memory_mb_reserved"`
|
|
}
|
|
|
|
// Reads directly from sandboxes for accurate real-time current values.
|
|
// CPU reserved = running + starting only (paused VMs release CPU).
|
|
// RAM reserved = running + starting + sum(ceil(each_paused/2)) (per-VM ceiling).
|
|
func (q *Queries) GetLiveMetrics(ctx context.Context, teamID pgtype.UUID) (GetLiveMetricsRow, error) {
|
|
row := q.db.QueryRow(ctx, getLiveMetrics, teamID)
|
|
var i GetLiveMetricsRow
|
|
err := row.Scan(&i.RunningCount, &i.VcpusReserved, &i.MemoryMbReserved)
|
|
return i, err
|
|
}
|
|
|
|
const getPeakMetrics = `-- name: GetPeakMetrics :one
|
|
SELECT
|
|
COALESCE(MAX(running_count), 0)::INTEGER AS peak_running_count,
|
|
COALESCE(MAX(vcpus_reserved), 0)::INTEGER AS peak_vcpus,
|
|
COALESCE(MAX(memory_mb_reserved), 0)::INTEGER AS peak_memory_mb
|
|
FROM sandbox_metrics_snapshots
|
|
WHERE team_id = $1
|
|
AND sampled_at > NOW() - INTERVAL '30 days'
|
|
`
|
|
|
|
type GetPeakMetricsRow struct {
|
|
PeakRunningCount int32 `json:"peak_running_count"`
|
|
PeakVcpus int32 `json:"peak_vcpus"`
|
|
PeakMemoryMb int32 `json:"peak_memory_mb"`
|
|
}
|
|
|
|
func (q *Queries) GetPeakMetrics(ctx context.Context, teamID pgtype.UUID) (GetPeakMetricsRow, error) {
|
|
row := q.db.QueryRow(ctx, getPeakMetrics, teamID)
|
|
var i GetPeakMetricsRow
|
|
err := row.Scan(&i.PeakRunningCount, &i.PeakVcpus, &i.PeakMemoryMb)
|
|
return i, err
|
|
}
|
|
|
|
const getSandboxMetricPoints = `-- name: GetSandboxMetricPoints :many
|
|
SELECT ts, cpu_pct, mem_bytes, disk_bytes
|
|
FROM sandbox_metric_points
|
|
WHERE sandbox_id = $1 AND tier = $2 AND ts >= $3
|
|
ORDER BY ts ASC
|
|
`
|
|
|
|
type GetSandboxMetricPointsParams struct {
|
|
SandboxID pgtype.UUID `json:"sandbox_id"`
|
|
Tier string `json:"tier"`
|
|
Ts int64 `json:"ts"`
|
|
}
|
|
|
|
type GetSandboxMetricPointsRow struct {
|
|
Ts int64 `json:"ts"`
|
|
CpuPct float64 `json:"cpu_pct"`
|
|
MemBytes int64 `json:"mem_bytes"`
|
|
DiskBytes int64 `json:"disk_bytes"`
|
|
}
|
|
|
|
func (q *Queries) GetSandboxMetricPoints(ctx context.Context, arg GetSandboxMetricPointsParams) ([]GetSandboxMetricPointsRow, error) {
|
|
rows, err := q.db.Query(ctx, getSandboxMetricPoints, arg.SandboxID, arg.Tier, arg.Ts)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetSandboxMetricPointsRow
|
|
for rows.Next() {
|
|
var i GetSandboxMetricPointsRow
|
|
if err := rows.Scan(
|
|
&i.Ts,
|
|
&i.CpuPct,
|
|
&i.MemBytes,
|
|
&i.DiskBytes,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const insertMetricsSnapshot = `-- name: InsertMetricsSnapshot :exec
|
|
INSERT INTO sandbox_metrics_snapshots (team_id, running_count, vcpus_reserved, memory_mb_reserved)
|
|
VALUES ($1, $2, $3, $4)
|
|
`
|
|
|
|
type InsertMetricsSnapshotParams struct {
|
|
TeamID pgtype.UUID `json:"team_id"`
|
|
RunningCount int32 `json:"running_count"`
|
|
VcpusReserved int32 `json:"vcpus_reserved"`
|
|
MemoryMbReserved int32 `json:"memory_mb_reserved"`
|
|
}
|
|
|
|
func (q *Queries) InsertMetricsSnapshot(ctx context.Context, arg InsertMetricsSnapshotParams) error {
|
|
_, err := q.db.Exec(ctx, insertMetricsSnapshot,
|
|
arg.TeamID,
|
|
arg.RunningCount,
|
|
arg.VcpusReserved,
|
|
arg.MemoryMbReserved,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const insertSandboxMetricPoint = `-- name: InsertSandboxMetricPoint :exec
|
|
INSERT INTO sandbox_metric_points (sandbox_id, tier, ts, cpu_pct, mem_bytes, disk_bytes)
|
|
VALUES ($1, $2, $3, $4, $5, $6)
|
|
ON CONFLICT (sandbox_id, tier, ts) DO NOTHING
|
|
`
|
|
|
|
type InsertSandboxMetricPointParams struct {
|
|
SandboxID pgtype.UUID `json:"sandbox_id"`
|
|
Tier string `json:"tier"`
|
|
Ts int64 `json:"ts"`
|
|
CpuPct float64 `json:"cpu_pct"`
|
|
MemBytes int64 `json:"mem_bytes"`
|
|
DiskBytes int64 `json:"disk_bytes"`
|
|
}
|
|
|
|
func (q *Queries) InsertSandboxMetricPoint(ctx context.Context, arg InsertSandboxMetricPointParams) error {
|
|
_, err := q.db.Exec(ctx, insertSandboxMetricPoint,
|
|
arg.SandboxID,
|
|
arg.Tier,
|
|
arg.Ts,
|
|
arg.CpuPct,
|
|
arg.MemBytes,
|
|
arg.DiskBytes,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const pruneOldMetrics = `-- name: PruneOldMetrics :exec
|
|
DELETE FROM sandbox_metrics_snapshots
|
|
WHERE sampled_at < NOW() - INTERVAL '60 days'
|
|
`
|
|
|
|
func (q *Queries) PruneOldMetrics(ctx context.Context) error {
|
|
_, err := q.db.Exec(ctx, pruneOldMetrics)
|
|
return err
|
|
}
|
|
|
|
const pruneSandboxMetricPoints = `-- name: PruneSandboxMetricPoints :exec
|
|
DELETE FROM sandbox_metric_points
|
|
WHERE ts < EXTRACT(EPOCH FROM NOW() - INTERVAL '30 days')::BIGINT
|
|
`
|
|
|
|
// Remove metric points older than 30 days for destroyed sandboxes.
|
|
func (q *Queries) PruneSandboxMetricPoints(ctx context.Context) error {
|
|
_, err := q.db.Exec(ctx, pruneSandboxMetricPoints)
|
|
return err
|
|
}
|
|
|
|
const sampleSandboxMetrics = `-- name: SampleSandboxMetrics :many
|
|
SELECT
|
|
team_id,
|
|
(COUNT(*) FILTER (WHERE status IN ('running', 'starting')))::INTEGER AS running_count,
|
|
(COALESCE(SUM(vcpus) FILTER (WHERE status IN ('running', 'starting')), 0))::INTEGER AS vcpus_reserved,
|
|
(COALESCE(SUM(memory_mb) FILTER (WHERE status IN ('running', 'starting')), 0)
|
|
+ COALESCE(SUM(CEIL(memory_mb::NUMERIC / 2)) FILTER (WHERE status = 'paused'), 0))::INTEGER AS memory_mb_reserved
|
|
FROM sandboxes
|
|
GROUP BY team_id
|
|
`
|
|
|
|
type SampleSandboxMetricsRow struct {
|
|
TeamID pgtype.UUID `json:"team_id"`
|
|
RunningCount int32 `json:"running_count"`
|
|
VcpusReserved int32 `json:"vcpus_reserved"`
|
|
MemoryMbReserved int32 `json:"memory_mb_reserved"`
|
|
}
|
|
|
|
// Aggregates per-team resource usage from the live sandboxes table.
|
|
// Groups by all teams that have any sandbox row (including stopped) so that
|
|
// zero-value snapshots are recorded when all capsules are stopped, keeping the
|
|
// time-series charts continuous rather than trailing off into empty space.
|
|
// CPU reserved = running + starting only (paused VMs release CPU).
|
|
// RAM reserved = running + starting + sum(ceil(each_paused/2)) (per-VM ceiling).
|
|
func (q *Queries) SampleSandboxMetrics(ctx context.Context) ([]SampleSandboxMetricsRow, error) {
|
|
rows, err := q.db.Query(ctx, sampleSandboxMetrics)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []SampleSandboxMetricsRow
|
|
for rows.Next() {
|
|
var i SampleSandboxMetricsRow
|
|
if err := rows.Scan(
|
|
&i.TeamID,
|
|
&i.RunningCount,
|
|
&i.VcpusReserved,
|
|
&i.MemoryMbReserved,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|