209 lines
12 KiB
TypeScript
209 lines
12 KiB
TypeScript
import { fleetSettings } from '../settings.js';
|
|
import { db } from '../db/index.js';
|
|
import { ONLINE_MAX_MS } from '../../server-freshness.js';
|
|
import { parseMetricsQuery, type HeatmapCell, type MapMetrics, type MetricPoint, type MetricsData,
|
|
type MetricsDays, type MetricsQuery, type PreviousMetrics, type ServerMetrics, type Utilization } from '../../metrics.js';
|
|
|
|
export type { MapMetrics, Utilization } from '../../metrics.js';
|
|
|
|
export interface MetricSample {
|
|
server: string;
|
|
game: string;
|
|
map: string;
|
|
players: number | null;
|
|
capacity: number | null;
|
|
}
|
|
|
|
export function recordMetrics(samples: MetricSample[], at = Date.now()): void {
|
|
const handle = db();
|
|
handle.transaction(() => {
|
|
const insert = handle.prepare('INSERT OR REPLACE INTO metric_samples (at, server, game, map, players, capacity) VALUES (?, ?, ?, ?, ?, ?)');
|
|
for (const s of samples) insert.run(at, s.server, s.game, s.map, s.players, s.capacity);
|
|
const days = fleetSettings().metricsKeepDays;
|
|
if (days) handle.prepare('DELETE FROM metric_samples WHERE at < ?').run(at - days * 86400_000);
|
|
})();
|
|
}
|
|
|
|
function emptyUtilization(): Utilization {
|
|
return { observed: 0, active: 0, idle: 0, unknown: 0, playerHours: 0 };
|
|
}
|
|
|
|
function addObservation(total: Utilization, players: number | null, hours: number): void {
|
|
if (players === null) total.unknown += hours;
|
|
else {
|
|
total.observed += hours;
|
|
if (players > 0) total.active += hours;
|
|
else if (players === 0) total.idle += hours;
|
|
total.playerHours += players * hours;
|
|
}
|
|
}
|
|
|
|
/** Each collection is a complete fleet snapshot. Hold it until the next collection,
|
|
* capped at the freshness limit; longer gaps contribute no observed or unknown time.
|
|
* Read the indexed history once and share the intervals across every aggregation. */
|
|
export function readMetrics(input: MetricsDays | MetricsQuery, now = Date.now()): MetricsData {
|
|
const query = parseMetricsQuery(new URLSearchParams(typeof input === 'number' ? { days: String(input) }
|
|
: { days: String(input.days), game: input.game ?? '', map: input.map ?? '', timeZone: input.timeZone }));
|
|
const { days, ...scope } = query;
|
|
const since = now - days * 86400_000;
|
|
const bucketMs = days === 1 ? 3600_000 : 86400_000;
|
|
const handle = db();
|
|
// These small grouped results keep options and retained evidence independent
|
|
// of the chosen scope/window without transferring a second raw history scan.
|
|
const groups = handle.prepare(`SELECT game, map, MIN(at) AS first, MAX(at) AS latest
|
|
FROM metric_samples WHERE at <= ? GROUP BY game, map ORDER BY game, map`).all(now) as
|
|
{ game: string; map: string; first: number; latest: number }[];
|
|
const matchesScope = (sample: { game: string; map: string }) =>
|
|
(scope.game === null || sample.game === scope.game) && (scope.map === null || sample.map === scope.map);
|
|
const evidenceBounds = (values: typeof groups) => values.reduce<{ first: number | null; latest: number | null }>((bounds, group) => ({
|
|
first: bounds.first === null ? group.first : Math.min(bounds.first, group.first),
|
|
latest: bounds.latest === null ? group.latest : Math.max(bounds.latest, group.latest)
|
|
}), { first: null, latest: null });
|
|
const globalBounds = evidenceBounds(groups);
|
|
const scopedBounds = evidenceBounds(groups.filter(matchesScope));
|
|
const registered = new Set((handle.prepare('SELECT name FROM servers WHERE destroyed_at IS NULL').all() as { name: string }[])
|
|
.map(server => server.name));
|
|
const metadata = { firstRetainedSampleAt: globalBounds.first, latestSampleAt: globalBounds.latest,
|
|
registeredServerCount: registered.size, scopeFirstSampleAt: scopedBounds.first, scopeLatestSampleAt: scopedBounds.latest };
|
|
const scopeOptions = { games: [...new Set(groups.map(group => group.game))], maps: groups.map(({ game, map }) => ({ game, map })) };
|
|
const summary = emptyUtilization();
|
|
const previous: PreviousMetrics = { since: since - days * 86400_000, until: since, summary: emptyUtilization(),
|
|
firstSampleAt: null, lastSampleAt: null, partialHistory: false };
|
|
const serverTotals = new Map<string, ServerMetrics>();
|
|
const mapTotals = new Map<string, Map<string, MapMetrics>>();
|
|
const points: MetricPoint[] = [];
|
|
for (let at = Math.floor(since / bucketMs) * bucketMs; at < now; at += bucketMs) {
|
|
const end = Math.min(at + bucketMs, now);
|
|
const start = Math.max(at, since);
|
|
points.push({ at, startAt: start, endAt: end, partial: start !== at || end !== at + bucketMs, ...emptyUtilization() });
|
|
}
|
|
|
|
const cells: HeatmapCell[] = Array.from({ length: 7 * 24 }, (_, index) => ({
|
|
weekday: Math.floor(index / 24), hour: index % 24, distinctDates: 0, ...emptyUtilization()
|
|
}));
|
|
const cellDates = cells.map(() => new Set<string>());
|
|
const calendar = new Intl.DateTimeFormat('en-US', { timeZone: scope.timeZone,
|
|
year: 'numeric', month: '2-digit', day: '2-digit', weekday: 'short', hour: 'numeric', hourCycle: 'h23' });
|
|
const weekdays: Record<string, number> = { Mon: 0, Tue: 1, Wed: 2, Thu: 3, Fri: 4, Sat: 5, Sun: 6 };
|
|
let cachedMinute = NaN;
|
|
let localCell = { index: 0, date: '' };
|
|
interface BatchCounts { known: number; active: number; idle: number; unknown: number; players: number }
|
|
function addHeatmap(counts: BatchCounts, start: number, end: number): void {
|
|
// Samples are bounded by the shared freshness window. Splitting at UTC minute boundaries
|
|
// handles local hour/day boundaries, DST, and fractional-hour zones.
|
|
// Cache each minute once across the complete fleet collection batches.
|
|
for (let cursor = start; cursor < end;) {
|
|
const minute = Math.floor(cursor / 60_000);
|
|
if (minute !== cachedMinute) {
|
|
const parts = Object.fromEntries(calendar.formatToParts(cursor).map(part => [part.type, part.value]));
|
|
localCell = { index: weekdays[parts.weekday] * 24 + Number(parts.hour), date: `${parts.year}-${parts.month}-${parts.day}` };
|
|
cachedMinute = minute;
|
|
}
|
|
const stop = Math.min(end, (minute + 1) * 60_000);
|
|
const hours = (stop - cursor) / 3600_000;
|
|
const cell = cells[localCell.index];
|
|
cell.observed += counts.known * hours;
|
|
cell.active += counts.active * hours;
|
|
cell.idle += counts.idle * hours;
|
|
cell.unknown += counts.unknown * hours;
|
|
cell.playerHours += counts.players * hours;
|
|
cellDates[localCell.index].add(localCell.date);
|
|
cursor = stop;
|
|
}
|
|
}
|
|
|
|
type RecordedSample = MetricSample & { at: number };
|
|
let batch: RecordedSample[] = [];
|
|
function aggregateBatch(nextAt: number): void {
|
|
if (!batch.length) return;
|
|
const at = batch[0].at;
|
|
const samples = scope.game === null ? batch : batch.filter(matchesScope);
|
|
if (!samples.length) return;
|
|
const end = Math.min(nextAt, at + ONLINE_MAX_MS, now);
|
|
const priorHours = Math.max(0, Math.min(end, previous.until) - Math.max(at, previous.since)) / 3600_000;
|
|
if (priorHours > 0) {
|
|
previous.firstSampleAt ??= at;
|
|
previous.lastSampleAt = at;
|
|
for (const sample of samples) addObservation(previous.summary, sample.players, priorHours);
|
|
}
|
|
// Preserve current-window zero-duration rows without bringing rows from
|
|
// the separate comparison window into the visible server/map tables.
|
|
if (at < since - ONLINE_MAX_MS) return;
|
|
const start = Math.max(at, since);
|
|
const hours = Math.max(0, end - start) / 3600_000;
|
|
const pressure = new Map<MapMetrics, { known: boolean; full: boolean }>();
|
|
const counts: BatchCounts = { known: 0, active: 0, idle: 0, unknown: 0, players: 0 };
|
|
// Split once for the entire batch; observations crossing UTC hour/day
|
|
// boundaries contribute to both buckets without shifting their duration.
|
|
const slices: { point: MetricPoint; hours: number }[] = [];
|
|
for (let cursor = start; cursor < end;) {
|
|
const index = Math.floor((cursor - points[0].at) / bucketMs);
|
|
const point = points[index];
|
|
const stop = Math.min(end, point.endAt);
|
|
slices.push({ point, hours: (stop - cursor) / 3600_000 });
|
|
cursor = stop;
|
|
}
|
|
for (const sample of samples) {
|
|
let server = serverTotals.get(sample.server);
|
|
if (!server) {
|
|
server = { server: sample.server, currentRegistered: registered.has(sample.server), ...emptyUtilization() };
|
|
serverTotals.set(sample.server, server);
|
|
}
|
|
let game = mapTotals.get(sample.game);
|
|
if (!game) { game = new Map(); mapTotals.set(sample.game, game); }
|
|
let map = game.get(sample.map);
|
|
if (!map) {
|
|
map = { game: sample.game, map: sample.map, full: 0, capacityObserved: 0, ...emptyUtilization() };
|
|
game.set(sample.map, map);
|
|
}
|
|
addObservation(summary, sample.players, hours);
|
|
addObservation(server, sample.players, hours);
|
|
addObservation(map, sample.players, hours);
|
|
for (const slice of slices) addObservation(slice.point, sample.players, slice.hours);
|
|
if (sample.players === null) counts.unknown++;
|
|
else {
|
|
counts.known++;
|
|
counts.players += sample.players;
|
|
if (sample.players > 0) counts.active++;
|
|
else if (sample.players === 0) counts.idle++;
|
|
}
|
|
const known = sample.players !== null && sample.capacity !== null && sample.capacity > 0;
|
|
const full = known && sample.players! >= sample.capacity!;
|
|
const previous = pressure.get(map);
|
|
pressure.set(map, { known: known && (previous?.known ?? true), full: full && (previous?.full ?? true) });
|
|
}
|
|
for (const [map, state] of pressure) {
|
|
if (state.known) {
|
|
map.capacityObserved += hours;
|
|
if (state.full) map.full += hours;
|
|
}
|
|
}
|
|
addHeatmap(counts, start, end);
|
|
}
|
|
|
|
type SampleRow = [at: number, server: string, game: string, map: string, players: number | null, capacity: number | null];
|
|
const samples = handle.prepare(`SELECT at, server, game, map, players, capacity FROM metric_samples
|
|
WHERE at >= ? AND at <= ? ORDER BY at`).raw().iterate(previous.since - ONLINE_MAX_MS, now) as IterableIterator<SampleRow>;
|
|
for (const [at, server, game, map, players, capacity] of samples) {
|
|
if (batch.length && at !== batch[0].at) {
|
|
aggregateBatch(at);
|
|
batch = [];
|
|
}
|
|
batch.push({ at, server, game, map, players, capacity });
|
|
}
|
|
aggregateBatch(now);
|
|
|
|
const compareText = (a: string, b: string) => a < b ? -1 : a > b ? 1 : 0;
|
|
const servers = [...serverTotals.values()].sort((a, b) => b.active - a.active || compareText(a.server, b.server));
|
|
const maps = [...mapTotals.values()].flatMap(game => [...game.values()])
|
|
.sort((a, b) => b.playerHours - a.playerHours || compareText(a.map, b.map) || compareText(a.game, b.game));
|
|
previous.partialHistory = scopedBounds.first === null || scopedBounds.first > previous.since || previous.firstSampleAt === null;
|
|
for (let index = 0; index < cells.length; index++) cells[index].distinctDates = cellDates[index].size;
|
|
const fullMapHours = maps.reduce((total, map) => total + map.full, 0);
|
|
const knownMapHours = maps.reduce((total, map) => total + map.capacityObserved, 0);
|
|
const pooledPressure = { value: knownMapHours > 0 ? 100 * fullMapHours / knownMapHours : null,
|
|
fullMapHours, knownMapHours, coveredMaps: maps.filter(map => map.capacityObserved > 0).length, totalMaps: maps.length };
|
|
return { days, since, now, ...metadata, scope, scopeOptions, summary, servers, maps, points, previous,
|
|
heatmap: { timeZone: scope.timeZone, cells }, pooledPressure };
|
|
}
|