1050 lines
36 KiB
TypeScript
1050 lines
36 KiB
TypeScript
import type { Pool } from "pg";
|
|
import type { Monitor, MonitorsSummary, MonitorStatus, MonitorType, MonitorMatchMethod, GeoContinent } from "@/types/monitor.js";
|
|
import { DefaultPageSpeedStrategy } from "@/types/monitor.js";
|
|
import type { IMonitorsRepository, TeamQueryConfig, SummaryConfig } from "./IMonitorsRepository.js";
|
|
import { AppError } from "@/utils/AppError.js";
|
|
|
|
interface MonitorRow {
|
|
id: string;
|
|
user_id: string;
|
|
team_id: string;
|
|
name: string;
|
|
description: string | null;
|
|
type: MonitorType;
|
|
status: MonitorStatus;
|
|
url: string | null;
|
|
port: number | null;
|
|
ignore_tls_errors: boolean;
|
|
use_advanced_matching: boolean;
|
|
json_path: string | null;
|
|
expected_value: string | null;
|
|
match_method: MonitorMatchMethod | null;
|
|
secret: string | null;
|
|
interval_ms: number;
|
|
is_active: boolean;
|
|
status_window: boolean[] | null;
|
|
status_window_size: number;
|
|
status_window_threshold: number;
|
|
uptime_percentage: number | null;
|
|
cpu_alert_threshold: number;
|
|
cpu_alert_counter: number;
|
|
memory_alert_threshold: number;
|
|
memory_alert_counter: number;
|
|
disk_alert_threshold: number;
|
|
disk_alert_counter: number;
|
|
temp_alert_threshold: number;
|
|
temp_alert_counter: number;
|
|
selected_disks: string[] | null;
|
|
game_id: string | null;
|
|
grpc_service_name: string | null;
|
|
strategy: string | null;
|
|
monitor_group: string | null;
|
|
geo_check_enabled: boolean;
|
|
geo_check_locations: GeoContinent[] | null;
|
|
geo_check_interval_ms: number;
|
|
created_at: Date;
|
|
updated_at: Date;
|
|
}
|
|
|
|
const MONITOR_COLUMNS = `id, user_id, team_id, name, description, type, status, url, port,
|
|
ignore_tls_errors, use_advanced_matching, json_path, expected_value, match_method, secret,
|
|
interval_ms, is_active, status_window, status_window_size, status_window_threshold, uptime_percentage,
|
|
cpu_alert_threshold, cpu_alert_counter, memory_alert_threshold, memory_alert_counter,
|
|
disk_alert_threshold, disk_alert_counter, temp_alert_threshold, temp_alert_counter, selected_disks,
|
|
game_id, grpc_service_name, strategy, monitor_group, geo_check_enabled, geo_check_locations, geo_check_interval_ms,
|
|
created_at, updated_at`;
|
|
|
|
export class TimescaleMonitorsRepository implements IMonitorsRepository {
|
|
constructor(private pool: Pool) {}
|
|
|
|
create = async (monitor: Monitor, teamId: string, userId: string): Promise<Monitor | null> => {
|
|
const result = await this.pool.query<MonitorRow>(
|
|
`INSERT INTO monitors (user_id, team_id, name, description, type, status, url, port,
|
|
ignore_tls_errors, use_advanced_matching, json_path, expected_value, match_method, secret,
|
|
interval_ms, is_active, status_window, status_window_size, status_window_threshold,
|
|
cpu_alert_threshold, cpu_alert_counter, memory_alert_threshold, memory_alert_counter,
|
|
disk_alert_threshold, disk_alert_counter, temp_alert_threshold, temp_alert_counter, selected_disks,
|
|
game_id, grpc_service_name, strategy, monitor_group, geo_check_enabled, geo_check_locations, geo_check_interval_ms)
|
|
VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35)
|
|
RETURNING ${MONITOR_COLUMNS}`,
|
|
[
|
|
userId,
|
|
teamId,
|
|
monitor.name,
|
|
monitor.description ?? null,
|
|
monitor.type,
|
|
monitor.status ?? "initializing",
|
|
monitor.url ?? null,
|
|
monitor.port ?? null,
|
|
monitor.ignoreTlsErrors ?? false,
|
|
monitor.useAdvancedMatching ?? false,
|
|
monitor.jsonPath ?? null,
|
|
monitor.expectedValue ?? null,
|
|
monitor.matchMethod || null,
|
|
monitor.secret ?? null,
|
|
monitor.interval ?? 60000,
|
|
monitor.isActive ?? true,
|
|
monitor.statusWindow ?? null,
|
|
monitor.statusWindowSize ?? 5,
|
|
monitor.statusWindowThreshold ?? 60,
|
|
monitor.cpuAlertThreshold ?? 0,
|
|
monitor.cpuAlertCounter ?? 0,
|
|
monitor.memoryAlertThreshold ?? 0,
|
|
monitor.memoryAlertCounter ?? 0,
|
|
monitor.diskAlertThreshold ?? 0,
|
|
monitor.diskAlertCounter ?? 0,
|
|
monitor.tempAlertThreshold ?? 0,
|
|
monitor.tempAlertCounter ?? 0,
|
|
monitor.selectedDisks ?? [],
|
|
monitor.gameId ?? null,
|
|
monitor.grpcServiceName ?? null,
|
|
monitor.strategy ?? DefaultPageSpeedStrategy,
|
|
monitor.group ?? null,
|
|
monitor.geoCheckEnabled ?? false,
|
|
monitor.geoCheckLocations ?? [],
|
|
monitor.geoCheckInterval ?? 300000,
|
|
]
|
|
);
|
|
const row = result.rows[0];
|
|
if (!row) {
|
|
return null;
|
|
}
|
|
|
|
// Insert notification associations
|
|
if (monitor.notifications?.length) {
|
|
for (const notificationId of monitor.notifications) {
|
|
await this.pool.query(`INSERT INTO monitor_notifications (monitor_id, notification_id) VALUES ($1, $2) ON CONFLICT DO NOTHING`, [
|
|
row.id,
|
|
notificationId,
|
|
]);
|
|
}
|
|
}
|
|
|
|
const entity = this.toEntity(row);
|
|
entity.notifications = monitor.notifications ?? [];
|
|
return entity;
|
|
};
|
|
|
|
createMonitors = async (monitors: Monitor[]): Promise<Monitor[]> => {
|
|
if (!monitors.length) {
|
|
return [];
|
|
}
|
|
const created: Monitor[] = [];
|
|
for (const monitor of monitors) {
|
|
const result = await this.create(monitor, monitor.teamId, monitor.userId);
|
|
if (result) {
|
|
created.push(result);
|
|
}
|
|
}
|
|
return created;
|
|
};
|
|
|
|
findById = async (monitorId: string, teamId: string): Promise<Monitor> => {
|
|
const result = await this.pool.query<MonitorRow>(`SELECT ${MONITOR_COLUMNS} FROM monitors WHERE id = $1 AND team_id = $2`, [monitorId, teamId]);
|
|
const row = result.rows[0];
|
|
if (!row) {
|
|
throw new AppError({ message: `Monitor with ID ${monitorId} not found`, status: 404 });
|
|
}
|
|
const monitor = this.toEntity(row);
|
|
|
|
// Populate latest check with child data
|
|
const checkResult = await this.pool.query(`SELECT * FROM checks WHERE monitor_id = $1 ORDER BY created_at DESC LIMIT 1`, [monitorId]);
|
|
if (checkResult.rows[0]) {
|
|
const checkRow = checkResult.rows[0];
|
|
const childData = await this.fetchCheckChildData(checkRow.id);
|
|
monitor.recentChecks = [this.toCheckSnapshot(checkRow, childData)];
|
|
}
|
|
|
|
// Populate notifications
|
|
monitor.notifications = await this.fetchNotificationIds([monitorId]).then((m) => m.get(monitorId) ?? []);
|
|
|
|
return monitor;
|
|
};
|
|
|
|
findAll = async (): Promise<Monitor[]> => {
|
|
const result = await this.pool.query<MonitorRow>(`SELECT ${MONITOR_COLUMNS} FROM monitors`);
|
|
const monitors = result.rows.map(this.toEntity);
|
|
if (monitors.length > 0) {
|
|
const notifMap = await this.fetchNotificationIds(monitors.map((m) => m.id));
|
|
for (const monitor of monitors) {
|
|
monitor.notifications = notifMap.get(monitor.id) ?? [];
|
|
}
|
|
}
|
|
return monitors;
|
|
};
|
|
|
|
findByTeamId = async (teamId: string, config: TeamQueryConfig): Promise<Monitor[] | null> => {
|
|
const { page = 0, rowsPerPage = 0, filter, field = "createdAt", order = "desc", type } = config ?? {};
|
|
|
|
const conditions: string[] = ["team_id = $1"];
|
|
const values: unknown[] = [teamId];
|
|
let paramIndex = 2;
|
|
|
|
if (type !== undefined) {
|
|
if (Array.isArray(type)) {
|
|
conditions.push(`type = ANY($${paramIndex++})`);
|
|
values.push(type);
|
|
} else {
|
|
conditions.push(`type = $${paramIndex++}`);
|
|
values.push(type);
|
|
}
|
|
}
|
|
|
|
if (filter !== undefined) {
|
|
switch (field) {
|
|
case "name":
|
|
conditions.push(`(name ILIKE $${paramIndex} OR url ILIKE $${paramIndex})`);
|
|
values.push(`%${filter}%`);
|
|
paramIndex++;
|
|
break;
|
|
case "isActive":
|
|
conditions.push(`is_active = $${paramIndex++}`);
|
|
values.push(filter === "true");
|
|
break;
|
|
case "status":
|
|
conditions.push(`status = $${paramIndex++}`);
|
|
values.push(filter);
|
|
break;
|
|
case "type":
|
|
conditions.push(`type = $${paramIndex++}`);
|
|
values.push(filter);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
const fieldMap: Record<string, string> = {
|
|
createdAt: "created_at",
|
|
name: "name",
|
|
status: "status",
|
|
type: "type",
|
|
isActive: "is_active",
|
|
};
|
|
const sortColumn = fieldMap[field] ?? "created_at";
|
|
const sortDirection = order === "asc" ? "ASC" : "DESC";
|
|
|
|
let query = `SELECT ${MONITOR_COLUMNS} FROM monitors WHERE ${conditions.join(" AND ")} ORDER BY ${sortColumn} ${sortDirection}`;
|
|
|
|
if (rowsPerPage > 0) {
|
|
const offset = Math.max(page, 0) * rowsPerPage;
|
|
query += ` LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
|
|
values.push(rowsPerPage, offset);
|
|
}
|
|
|
|
const result = await this.pool.query<MonitorRow>(query, values);
|
|
const monitors = result.rows.map(this.toEntity);
|
|
|
|
if (monitors.length === 0) return monitors;
|
|
|
|
// Populate recentChecks — 25 latest checks per monitor in a single query
|
|
const monitorIds = monitors.map((m) => m.id);
|
|
const checksResult = await this.pool.query(
|
|
`SELECT * FROM (
|
|
SELECT *, ROW_NUMBER() OVER (PARTITION BY monitor_id ORDER BY created_at DESC) AS rn
|
|
FROM checks
|
|
WHERE monitor_id = ANY($1)
|
|
) sub WHERE rn <= 25
|
|
ORDER BY monitor_id, created_at ASC`,
|
|
[monitorIds]
|
|
);
|
|
|
|
// Group checks by monitor_id
|
|
const checksMap = new Map<string, typeof checksResult.rows>();
|
|
for (const row of checksResult.rows) {
|
|
if (!checksMap.has(row.monitor_id)) checksMap.set(row.monitor_id, []);
|
|
checksMap.get(row.monitor_id)!.push(row);
|
|
}
|
|
|
|
// Batch fetch child data for all checks in 3 queries
|
|
const checkIds = checksResult.rows.map((r) => r.id);
|
|
const diskMap = new Map<string, Record<string, unknown>[]>();
|
|
const netMap = new Map<string, Record<string, unknown>[]>();
|
|
const errorsMap = new Map<string, Record<string, unknown>[]>();
|
|
|
|
if (checkIds.length > 0) {
|
|
const [disksResult, netsResult, errsResult] = await Promise.all([
|
|
this.pool.query(
|
|
`SELECT check_id, device, mountpoint, total_bytes, free_bytes, used_bytes, usage_percent,
|
|
total_inodes, free_inodes, used_inodes, inodes_usage_percent,
|
|
read_bytes, write_bytes, read_time, write_time
|
|
FROM check_disks WHERE check_id = ANY($1)`,
|
|
[checkIds]
|
|
),
|
|
this.pool.query(
|
|
`SELECT check_id, name, bytes_sent, bytes_recv, packets_sent, packets_recv,
|
|
err_in, err_out, drop_in, drop_out, fifo_in, fifo_out
|
|
FROM check_network_interfaces WHERE check_id = ANY($1)`,
|
|
[checkIds]
|
|
),
|
|
this.pool.query(
|
|
`SELECT check_id, metrics, error
|
|
FROM check_errors WHERE check_id = ANY($1)`,
|
|
[checkIds]
|
|
),
|
|
]);
|
|
|
|
for (const d of disksResult.rows) {
|
|
const key = d.check_id as string;
|
|
if (!diskMap.has(key)) diskMap.set(key, []);
|
|
diskMap.get(key)!.push(d);
|
|
}
|
|
for (const n of netsResult.rows) {
|
|
const key = n.check_id as string;
|
|
if (!netMap.has(key)) netMap.set(key, []);
|
|
netMap.get(key)!.push(n);
|
|
}
|
|
for (const e of errsResult.rows) {
|
|
const key = e.check_id as string;
|
|
if (!errorsMap.has(key)) errorsMap.set(key, []);
|
|
errorsMap.get(key)!.push(e);
|
|
}
|
|
}
|
|
|
|
for (const monitor of monitors) {
|
|
const rows = checksMap.get(monitor.id) ?? [];
|
|
monitor.recentChecks = rows.map((row) => {
|
|
const childData = {
|
|
disk: (diskMap.get(row.id) ?? []).map((d) => ({
|
|
device: d.device,
|
|
mountpoint: d.mountpoint,
|
|
total_bytes: Number(d.total_bytes),
|
|
free_bytes: Number(d.free_bytes),
|
|
used_bytes: Number(d.used_bytes),
|
|
usage_percent: d.usage_percent as number,
|
|
total_inodes: Number(d.total_inodes),
|
|
free_inodes: Number(d.free_inodes),
|
|
used_inodes: Number(d.used_inodes),
|
|
inodes_usage_percent: d.inodes_usage_percent as number,
|
|
read_bytes: Number(d.read_bytes),
|
|
write_bytes: Number(d.write_bytes),
|
|
read_time: Number(d.read_time),
|
|
write_time: Number(d.write_time),
|
|
})),
|
|
net: (netMap.get(row.id) ?? []).map((n) => ({
|
|
name: n.name as string,
|
|
bytes_sent: Number(n.bytes_sent),
|
|
bytes_recv: Number(n.bytes_recv),
|
|
packets_sent: Number(n.packets_sent),
|
|
packets_recv: Number(n.packets_recv),
|
|
err_in: Number(n.err_in),
|
|
err_out: Number(n.err_out),
|
|
drop_in: Number(n.drop_in),
|
|
drop_out: Number(n.drop_out),
|
|
fifo_in: Number(n.fifo_in),
|
|
fifo_out: Number(n.fifo_out),
|
|
})),
|
|
errors: (errorsMap.get(row.id) ?? []).map((e) => ({
|
|
metric: (e.metrics as string[]) ?? [],
|
|
err: (e.error as string) ?? "",
|
|
})),
|
|
};
|
|
return this.toCheckSnapshot(row, childData);
|
|
});
|
|
}
|
|
|
|
// Populate notifications in batch
|
|
const notifMap = await this.fetchNotificationIds(monitorIds);
|
|
for (const monitor of monitors) {
|
|
monitor.notifications = notifMap.get(monitor.id) ?? [];
|
|
}
|
|
|
|
return monitors;
|
|
};
|
|
|
|
findByIds = async (monitorIds: string[]): Promise<Monitor[]> => {
|
|
if (!monitorIds.length) {
|
|
return [];
|
|
}
|
|
const result = await this.pool.query<MonitorRow>(`SELECT ${MONITOR_COLUMNS} FROM monitors WHERE id = ANY($1)`, [monitorIds]);
|
|
const monitors = result.rows.map(this.toEntity);
|
|
const notifMap = await this.fetchNotificationIds(monitorIds);
|
|
for (const monitor of monitors) {
|
|
monitor.notifications = notifMap.get(monitor.id) ?? [];
|
|
}
|
|
return monitors;
|
|
};
|
|
|
|
findByIdsWithChecks = async (monitorIds: string[], checksCount: number = 25): Promise<Monitor[]> => {
|
|
if (!monitorIds.length) {
|
|
return [];
|
|
}
|
|
const monitors = await this.findByIds(monitorIds);
|
|
|
|
for (const monitor of monitors) {
|
|
const checksResult = await this.pool.query(
|
|
`SELECT * FROM checks
|
|
WHERE monitor_id = $1
|
|
ORDER BY created_at DESC
|
|
LIMIT $2`,
|
|
[monitor.id, checksCount]
|
|
);
|
|
monitor.recentChecks = await Promise.all(
|
|
checksResult.rows.map(async (row) => {
|
|
// Fetch child records for hardware monitors
|
|
let disk: import("@/types/index.js").CheckDiskInfo[] = [];
|
|
let net: import("@/types/index.js").CheckNetworkInterfaceInfo[] = [];
|
|
let errors: import("@/types/index.js").CheckErrorInfo[] = [];
|
|
|
|
if (monitor.type === "hardware") {
|
|
const [diskResult, netResult, errorsResult] = await Promise.all([
|
|
this.pool.query(
|
|
`SELECT device, mountpoint, total_bytes, free_bytes, used_bytes, usage_percent,
|
|
total_inodes, free_inodes, used_inodes, inodes_usage_percent,
|
|
read_bytes, write_bytes, read_time, write_time
|
|
FROM check_disks WHERE check_id = $1`,
|
|
[row.id]
|
|
),
|
|
this.pool.query(
|
|
`SELECT name, bytes_sent, bytes_recv, packets_sent, packets_recv,
|
|
err_in, err_out, drop_in, drop_out, fifo_in, fifo_out
|
|
FROM check_network_interfaces WHERE check_id = $1`,
|
|
[row.id]
|
|
),
|
|
this.pool.query(`SELECT metrics, error FROM check_errors WHERE check_id = $1`, [row.id]),
|
|
]);
|
|
disk = diskResult.rows.map((d) => ({
|
|
device: d.device,
|
|
mountpoint: d.mountpoint,
|
|
total_bytes: Number(d.total_bytes),
|
|
free_bytes: Number(d.free_bytes),
|
|
used_bytes: Number(d.used_bytes),
|
|
usage_percent: d.usage_percent,
|
|
total_inodes: Number(d.total_inodes),
|
|
free_inodes: Number(d.free_inodes),
|
|
used_inodes: Number(d.used_inodes),
|
|
inodes_usage_percent: d.inodes_usage_percent,
|
|
read_bytes: Number(d.read_bytes),
|
|
write_bytes: Number(d.write_bytes),
|
|
read_time: Number(d.read_time),
|
|
write_time: Number(d.write_time),
|
|
}));
|
|
net = netResult.rows.map((n) => ({
|
|
name: n.name,
|
|
bytes_sent: Number(n.bytes_sent),
|
|
bytes_recv: Number(n.bytes_recv),
|
|
packets_sent: Number(n.packets_sent),
|
|
packets_recv: Number(n.packets_recv),
|
|
err_in: Number(n.err_in),
|
|
err_out: Number(n.err_out),
|
|
drop_in: Number(n.drop_in),
|
|
drop_out: Number(n.drop_out),
|
|
fifo_in: Number(n.fifo_in),
|
|
fifo_out: Number(n.fifo_out),
|
|
}));
|
|
errors = errorsResult.rows.map((e) => ({ metric: e.metrics ?? [], err: e.error ?? "" }));
|
|
}
|
|
|
|
return {
|
|
id: row.id,
|
|
status: row.status,
|
|
responseTime: row.response_time ?? 0,
|
|
statusCode: row.status_code ?? 0,
|
|
message: row.message ?? "",
|
|
timings:
|
|
row.timing_start !== null
|
|
? {
|
|
start: row.timing_start,
|
|
socket: row.timing_socket,
|
|
lookup: row.timing_lookup,
|
|
connect: row.timing_connect,
|
|
secureConnect: row.timing_secure_connect,
|
|
upload: row.timing_upload,
|
|
response: row.timing_response,
|
|
end: row.timing_end,
|
|
phases: {
|
|
wait: row.phase_wait,
|
|
dns: row.phase_dns,
|
|
tcp: row.phase_tcp,
|
|
tls: row.phase_tls,
|
|
request: row.phase_request,
|
|
firstByte: row.phase_first_byte,
|
|
download: row.phase_download,
|
|
total: row.phase_total,
|
|
},
|
|
}
|
|
: undefined,
|
|
cpu:
|
|
row.cpu_usage_percent !== null
|
|
? {
|
|
physical_core: row.cpu_physical_core,
|
|
logical_core: row.cpu_logical_core,
|
|
frequency: row.cpu_frequency,
|
|
current_frequency: row.cpu_current_frequency,
|
|
temperature: row.cpu_temperature ?? [],
|
|
free_percent: row.cpu_free_percent,
|
|
usage_percent: row.cpu_usage_percent,
|
|
}
|
|
: undefined,
|
|
memory:
|
|
row.mem_usage_percent !== null
|
|
? {
|
|
total_bytes: Number(row.mem_total_bytes),
|
|
available_bytes: Number(row.mem_available_bytes),
|
|
used_bytes: Number(row.mem_used_bytes),
|
|
usage_percent: row.mem_usage_percent,
|
|
}
|
|
: undefined,
|
|
disk,
|
|
host:
|
|
row.host_os !== null
|
|
? {
|
|
os: row.host_os,
|
|
platform: row.host_platform,
|
|
kernel_version: row.host_kernel_version,
|
|
pretty_name: row.host_pretty_name,
|
|
}
|
|
: undefined,
|
|
errors,
|
|
capture:
|
|
row.capture_version !== null
|
|
? {
|
|
version: row.capture_version,
|
|
mode: row.capture_mode,
|
|
}
|
|
: undefined,
|
|
net,
|
|
performance: row.lighthouse_performance ?? undefined,
|
|
accessibility: row.lighthouse_accessibility ?? undefined,
|
|
bestPractices: row.lighthouse_best_practices ?? undefined,
|
|
seo: row.lighthouse_seo ?? undefined,
|
|
audits:
|
|
row.audit_cls_score !== null
|
|
? {
|
|
cls: { score: row.audit_cls_score, numericValue: row.audit_cls_value, displayValue: row.audit_cls_display },
|
|
si: { score: row.audit_si_score, numericValue: row.audit_si_value, displayValue: row.audit_si_display },
|
|
fcp: { score: row.audit_fcp_score, numericValue: row.audit_fcp_value, displayValue: row.audit_fcp_display },
|
|
lcp: { score: row.audit_lcp_score, numericValue: row.audit_lcp_value, displayValue: row.audit_lcp_display },
|
|
tbt: { score: row.audit_tbt_score, numericValue: row.audit_tbt_value, displayValue: row.audit_tbt_display },
|
|
}
|
|
: undefined,
|
|
createdAt: row.created_at.toISOString(),
|
|
};
|
|
})
|
|
);
|
|
|
|
const maintResult = await this.pool.query(
|
|
`SELECT 1 FROM maintenance_windows
|
|
WHERE monitor_id = $1 AND active = TRUE AND start_time <= NOW() AND end_time >= NOW()
|
|
LIMIT 1`,
|
|
[monitor.id]
|
|
);
|
|
if ((maintResult.rowCount ?? 0) > 0) {
|
|
monitor.status = "maintenance";
|
|
}
|
|
|
|
const statsResult = await this.pool.query(`SELECT uptime_percentage FROM monitor_stats WHERE monitor_id = $1`, [monitor.id]);
|
|
if (statsResult.rows[0]) {
|
|
monitor.uptimePercentage = statsResult.rows[0].uptime_percentage;
|
|
}
|
|
}
|
|
|
|
return monitors;
|
|
};
|
|
|
|
findMonitorCountByTeamIdAndType = async (teamId: string, config?: TeamQueryConfig): Promise<number> => {
|
|
const { type } = config ?? {};
|
|
const conditions: string[] = ["team_id = $1"];
|
|
const values: unknown[] = [teamId];
|
|
let paramIndex = 2;
|
|
|
|
if (type !== undefined) {
|
|
if (Array.isArray(type)) {
|
|
conditions.push(`type = ANY($${paramIndex++})`);
|
|
values.push(type);
|
|
} else {
|
|
conditions.push(`type = $${paramIndex++}`);
|
|
values.push(type);
|
|
}
|
|
}
|
|
|
|
const result = await this.pool.query(`SELECT COUNT(*)::int AS count FROM monitors WHERE ${conditions.join(" AND ")}`, values);
|
|
return result.rows[0].count;
|
|
};
|
|
|
|
updateById = async (monitorId: string, teamId: string, patch: Partial<Monitor>): Promise<Monitor> => {
|
|
const sets: string[] = [];
|
|
const values: unknown[] = [];
|
|
let paramIndex = 1;
|
|
|
|
const fieldMap: [keyof Monitor, string][] = [
|
|
["name", "name"],
|
|
["description", "description"],
|
|
["type", "type"],
|
|
["status", "status"],
|
|
["url", "url"],
|
|
["port", "port"],
|
|
["ignoreTlsErrors", "ignore_tls_errors"],
|
|
["useAdvancedMatching", "use_advanced_matching"],
|
|
["jsonPath", "json_path"],
|
|
["expectedValue", "expected_value"],
|
|
["matchMethod", "match_method"],
|
|
["secret", "secret"],
|
|
["interval", "interval_ms"],
|
|
["isActive", "is_active"],
|
|
["statusWindow", "status_window"],
|
|
["statusWindowSize", "status_window_size"],
|
|
["statusWindowThreshold", "status_window_threshold"],
|
|
["uptimePercentage", "uptime_percentage"],
|
|
["cpuAlertThreshold", "cpu_alert_threshold"],
|
|
["cpuAlertCounter", "cpu_alert_counter"],
|
|
["memoryAlertThreshold", "memory_alert_threshold"],
|
|
["memoryAlertCounter", "memory_alert_counter"],
|
|
["diskAlertThreshold", "disk_alert_threshold"],
|
|
["diskAlertCounter", "disk_alert_counter"],
|
|
["tempAlertThreshold", "temp_alert_threshold"],
|
|
["tempAlertCounter", "temp_alert_counter"],
|
|
["selectedDisks", "selected_disks"],
|
|
["gameId", "game_id"],
|
|
["grpcServiceName", "grpc_service_name"],
|
|
["strategy", "strategy"],
|
|
["group", "monitor_group"],
|
|
["geoCheckEnabled", "geo_check_enabled"],
|
|
["geoCheckLocations", "geo_check_locations"],
|
|
["geoCheckInterval", "geo_check_interval_ms"],
|
|
];
|
|
|
|
for (const [key, column] of fieldMap) {
|
|
if (patch[key] !== undefined) {
|
|
sets.push(`${column} = $${paramIndex++}`);
|
|
// Empty string matchMethod is stored as NULL (not a valid enum value)
|
|
values.push(key === "matchMethod" && patch[key] === "" ? null : patch[key]);
|
|
}
|
|
}
|
|
|
|
if (sets.length === 0) {
|
|
return this.findById(monitorId, teamId);
|
|
}
|
|
|
|
sets.push(`updated_at = NOW()`);
|
|
values.push(monitorId, teamId);
|
|
|
|
const result = await this.pool.query<MonitorRow>(
|
|
`UPDATE monitors SET ${sets.join(", ")} WHERE id = $${paramIndex++} AND team_id = $${paramIndex}
|
|
RETURNING ${MONITOR_COLUMNS}`,
|
|
values
|
|
);
|
|
const row = result.rows[0];
|
|
if (!row) {
|
|
throw new AppError({ message: `Failed to update monitor with id ${monitorId}`, status: 500 });
|
|
}
|
|
|
|
// Update notification associations if provided
|
|
if (patch.notifications !== undefined) {
|
|
await this.pool.query(`DELETE FROM monitor_notifications WHERE monitor_id = $1`, [monitorId]);
|
|
for (const notificationId of patch.notifications) {
|
|
await this.pool.query(`INSERT INTO monitor_notifications (monitor_id, notification_id) VALUES ($1, $2) ON CONFLICT DO NOTHING`, [
|
|
monitorId,
|
|
notificationId,
|
|
]);
|
|
}
|
|
}
|
|
|
|
const entity = this.toEntity(row);
|
|
entity.notifications = patch.notifications ?? (await this.fetchNotificationIds([monitorId]).then((m) => m.get(monitorId) ?? []));
|
|
return entity;
|
|
};
|
|
|
|
togglePauseById = async (monitorId: string, teamId: string): Promise<Monitor> => {
|
|
const result = await this.pool.query<MonitorRow>(
|
|
`UPDATE monitors SET
|
|
is_active = NOT is_active,
|
|
status = CASE WHEN status = 'paused' THEN 'initializing'::monitor_status ELSE 'paused'::monitor_status END,
|
|
updated_at = NOW()
|
|
WHERE id = $1 AND team_id = $2
|
|
RETURNING ${MONITOR_COLUMNS}`,
|
|
[monitorId, teamId]
|
|
);
|
|
const row = result.rows[0];
|
|
if (!row) {
|
|
throw new AppError({ message: `Monitor with ID ${monitorId} not found for the given team.`, status: 404 });
|
|
}
|
|
const entity = this.toEntity(row);
|
|
entity.notifications = await this.fetchNotificationIds([monitorId]).then((m) => m.get(monitorId) ?? []);
|
|
return entity;
|
|
};
|
|
|
|
deleteById = async (monitorId: string, teamId: string): Promise<Monitor> => {
|
|
// Fetch notifications before delete (FK cascade will remove join rows)
|
|
const notifs = await this.fetchNotificationIds([monitorId]).then((m) => m.get(monitorId) ?? []);
|
|
const result = await this.pool.query<MonitorRow>(`DELETE FROM monitors WHERE id = $1 AND team_id = $2 RETURNING ${MONITOR_COLUMNS}`, [
|
|
monitorId,
|
|
teamId,
|
|
]);
|
|
const row = result.rows[0];
|
|
if (!row) {
|
|
throw new AppError({ message: `Monitor with ID ${monitorId} not found for the given team.`, status: 404 });
|
|
}
|
|
const entity = this.toEntity(row);
|
|
entity.notifications = notifs;
|
|
return entity;
|
|
};
|
|
|
|
deleteByTeamId = async (teamId: string): Promise<{ monitors: Monitor[]; deletedCount: number }> => {
|
|
// Fetch notifications before delete
|
|
const monitorsResult = await this.pool.query<MonitorRow>(`SELECT ${MONITOR_COLUMNS} FROM monitors WHERE team_id = $1`, [teamId]);
|
|
const monitorIds = monitorsResult.rows.map((r) => r.id);
|
|
const notifMap = monitorIds.length > 0 ? await this.fetchNotificationIds(monitorIds) : new Map();
|
|
|
|
const result = await this.pool.query<MonitorRow>(`DELETE FROM monitors WHERE team_id = $1 RETURNING ${MONITOR_COLUMNS}`, [teamId]);
|
|
const monitors = result.rows.map((row) => {
|
|
const entity = this.toEntity(row);
|
|
entity.notifications = notifMap.get(row.id) ?? [];
|
|
return entity;
|
|
});
|
|
return { monitors, deletedCount: result.rowCount ?? 0 };
|
|
};
|
|
|
|
findMonitorsSummaryByTeamId = async (teamId: string, config?: SummaryConfig): Promise<MonitorsSummary> => {
|
|
const conditions: string[] = ["team_id = $1"];
|
|
const values: unknown[] = [teamId];
|
|
let paramIndex = 2;
|
|
|
|
if (config?.type !== undefined) {
|
|
if (Array.isArray(config.type)) {
|
|
conditions.push(`type = ANY($${paramIndex++})`);
|
|
values.push(config.type);
|
|
} else {
|
|
conditions.push(`type = $${paramIndex++}`);
|
|
values.push(config.type);
|
|
}
|
|
}
|
|
|
|
const result = await this.pool.query(
|
|
`SELECT
|
|
COUNT(*)::int AS "totalMonitors",
|
|
COUNT(*) FILTER (WHERE status = 'up')::int AS "upMonitors",
|
|
COUNT(*) FILTER (WHERE status = 'down')::int AS "downMonitors",
|
|
COUNT(*) FILTER (WHERE status = 'paused')::int AS "pausedMonitors",
|
|
COUNT(*) FILTER (WHERE status = 'initializing')::int AS "initializingMonitors",
|
|
COUNT(*) FILTER (WHERE status = 'maintenance')::int AS "maintenanceMonitors",
|
|
COUNT(*) FILTER (WHERE status = 'breached')::int AS "breachedMonitors"
|
|
FROM monitors WHERE ${conditions.join(" AND ")}`,
|
|
values
|
|
);
|
|
|
|
return (
|
|
result.rows[0] ?? {
|
|
totalMonitors: 0,
|
|
upMonitors: 0,
|
|
downMonitors: 0,
|
|
pausedMonitors: 0,
|
|
initializingMonitors: 0,
|
|
maintenanceMonitors: 0,
|
|
breachedMonitors: 0,
|
|
}
|
|
);
|
|
};
|
|
|
|
findGroupsByTeamId = async (teamId: string): Promise<string[]> => {
|
|
const result = await this.pool.query(
|
|
`SELECT DISTINCT monitor_group FROM monitors
|
|
WHERE team_id = $1 AND monitor_group IS NOT NULL AND monitor_group != ''
|
|
ORDER BY monitor_group`,
|
|
[teamId]
|
|
);
|
|
return result.rows.map((row) => row.monitor_group);
|
|
};
|
|
|
|
removeNotificationFromMonitors = async (notificationId: string): Promise<void> => {
|
|
await this.pool.query(`DELETE FROM monitor_notifications WHERE notification_id = $1`, [notificationId]);
|
|
};
|
|
|
|
updateNotifications = async (
|
|
teamId: string,
|
|
monitorIds: string[],
|
|
notificationIds: string[],
|
|
action: "add" | "remove" | "set"
|
|
): Promise<number> => {
|
|
if (!monitorIds.length) {
|
|
return 0;
|
|
}
|
|
|
|
// Verify monitors belong to team
|
|
const monitorCheck = await this.pool.query(`SELECT id FROM monitors WHERE id = ANY($1) AND team_id = $2`, [monitorIds, teamId]);
|
|
const validMonitorIds = monitorCheck.rows.map((row) => row.id);
|
|
|
|
if (!validMonitorIds.length) {
|
|
return 0;
|
|
}
|
|
|
|
let modified = 0;
|
|
|
|
switch (action) {
|
|
case "set": {
|
|
// Track which monitors actually change
|
|
const existingSet = await this.pool.query(`SELECT monitor_id, notification_id FROM monitor_notifications WHERE monitor_id = ANY($1)`, [
|
|
validMonitorIds,
|
|
]);
|
|
const existingByMonitor = new Map<string, Set<string>>();
|
|
for (const row of existingSet.rows) {
|
|
if (!existingByMonitor.has(row.monitor_id)) existingByMonitor.set(row.monitor_id, new Set());
|
|
existingByMonitor.get(row.monitor_id)!.add(row.notification_id);
|
|
}
|
|
|
|
await this.pool.query(`DELETE FROM monitor_notifications WHERE monitor_id = ANY($1)`, [validMonitorIds]);
|
|
for (const monitorId of validMonitorIds) {
|
|
const existing = existingByMonitor.get(monitorId);
|
|
const newSet = new Set(notificationIds);
|
|
const changed = !existing || existing.size !== newSet.size || [...newSet].some((id) => !existing.has(id));
|
|
if (changed) modified++;
|
|
|
|
for (const notificationId of notificationIds) {
|
|
await this.pool.query(
|
|
`INSERT INTO monitor_notifications (monitor_id, notification_id)
|
|
VALUES ($1, $2)
|
|
ON CONFLICT DO NOTHING`,
|
|
[monitorId, notificationId]
|
|
);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case "add": {
|
|
// Count monitors where at least one new notification was added
|
|
const monitorsModified = new Set<string>();
|
|
for (const monitorId of validMonitorIds) {
|
|
for (const notificationId of notificationIds) {
|
|
const res = await this.pool.query(
|
|
`INSERT INTO monitor_notifications (monitor_id, notification_id)
|
|
VALUES ($1, $2)
|
|
ON CONFLICT DO NOTHING`,
|
|
[monitorId, notificationId]
|
|
);
|
|
if ((res.rowCount ?? 0) > 0) {
|
|
monitorsModified.add(monitorId);
|
|
}
|
|
}
|
|
}
|
|
modified = monitorsModified.size;
|
|
break;
|
|
}
|
|
case "remove": {
|
|
// Count distinct monitors that will be affected before deleting
|
|
const affectedResult = await this.pool.query(
|
|
`SELECT COUNT(DISTINCT monitor_id)::int AS count FROM monitor_notifications
|
|
WHERE monitor_id = ANY($1) AND notification_id = ANY($2)`,
|
|
[validMonitorIds, notificationIds]
|
|
);
|
|
modified = affectedResult.rows[0]?.count ?? 0;
|
|
await this.pool.query(
|
|
`DELETE FROM monitor_notifications
|
|
WHERE monitor_id = ANY($1) AND notification_id = ANY($2)`,
|
|
[validMonitorIds, notificationIds]
|
|
);
|
|
break;
|
|
}
|
|
default:
|
|
throw new AppError({ message: `Invalid action: ${action}`, status: 400 });
|
|
}
|
|
|
|
return modified;
|
|
};
|
|
|
|
deleteByTeamIdsNotIn = async (teamIds: string[]): Promise<number> => {
|
|
if (!teamIds.length) {
|
|
const result = await this.pool.query(`DELETE FROM monitors`);
|
|
return result.rowCount ?? 0;
|
|
}
|
|
const result = await this.pool.query(`DELETE FROM monitors WHERE team_id != ALL($1)`, [teamIds]);
|
|
return result.rowCount ?? 0;
|
|
};
|
|
|
|
findAllMonitorIds = async (): Promise<string[]> => {
|
|
const result = await this.pool.query(`SELECT id FROM monitors`);
|
|
return result.rows.map((row) => row.id);
|
|
};
|
|
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
private toCheckSnapshot = (row: any, childData?: { disk: any[]; net: any[]; errors: any[] }) => ({
|
|
id: row.id,
|
|
status: row.status,
|
|
responseTime: row.response_time ?? 0,
|
|
statusCode: row.status_code ?? 0,
|
|
message: row.message ?? "",
|
|
timings:
|
|
row.timing_start !== null
|
|
? {
|
|
start: row.timing_start,
|
|
socket: row.timing_socket,
|
|
lookup: row.timing_lookup,
|
|
connect: row.timing_connect,
|
|
secureConnect: row.timing_secure_connect,
|
|
upload: row.timing_upload,
|
|
response: row.timing_response,
|
|
end: row.timing_end,
|
|
phases: {
|
|
wait: row.phase_wait,
|
|
dns: row.phase_dns,
|
|
tcp: row.phase_tcp,
|
|
tls: row.phase_tls,
|
|
request: row.phase_request,
|
|
firstByte: row.phase_first_byte,
|
|
download: row.phase_download,
|
|
total: row.phase_total,
|
|
},
|
|
}
|
|
: undefined,
|
|
cpu:
|
|
row.cpu_usage_percent !== null
|
|
? {
|
|
physical_core: row.cpu_physical_core,
|
|
logical_core: row.cpu_logical_core,
|
|
frequency: row.cpu_frequency,
|
|
current_frequency: row.cpu_current_frequency,
|
|
temperature: row.cpu_temperature ?? [],
|
|
free_percent: row.cpu_free_percent,
|
|
usage_percent: row.cpu_usage_percent,
|
|
}
|
|
: undefined,
|
|
memory:
|
|
row.mem_usage_percent !== null
|
|
? {
|
|
total_bytes: Number(row.mem_total_bytes),
|
|
available_bytes: Number(row.mem_available_bytes),
|
|
used_bytes: Number(row.mem_used_bytes),
|
|
usage_percent: row.mem_usage_percent,
|
|
}
|
|
: undefined,
|
|
disk: childData?.disk ?? [],
|
|
host:
|
|
row.host_os !== null
|
|
? {
|
|
os: row.host_os,
|
|
platform: row.host_platform,
|
|
kernel_version: row.host_kernel_version,
|
|
pretty_name: row.host_pretty_name,
|
|
}
|
|
: undefined,
|
|
errors: childData?.errors ?? [],
|
|
capture:
|
|
row.capture_version !== null
|
|
? {
|
|
version: row.capture_version,
|
|
mode: row.capture_mode,
|
|
}
|
|
: undefined,
|
|
net: childData?.net ?? [],
|
|
performance: row.lighthouse_performance ?? undefined,
|
|
accessibility: row.lighthouse_accessibility ?? undefined,
|
|
bestPractices: row.lighthouse_best_practices ?? undefined,
|
|
seo: row.lighthouse_seo ?? undefined,
|
|
audits:
|
|
row.audit_cls_score !== null
|
|
? {
|
|
cls: { score: row.audit_cls_score, numericValue: row.audit_cls_value, displayValue: row.audit_cls_display },
|
|
si: { score: row.audit_si_score, numericValue: row.audit_si_value, displayValue: row.audit_si_display },
|
|
fcp: { score: row.audit_fcp_score, numericValue: row.audit_fcp_value, displayValue: row.audit_fcp_display },
|
|
lcp: { score: row.audit_lcp_score, numericValue: row.audit_lcp_value, displayValue: row.audit_lcp_display },
|
|
tbt: { score: row.audit_tbt_score, numericValue: row.audit_tbt_value, displayValue: row.audit_tbt_display },
|
|
}
|
|
: undefined,
|
|
createdAt: row.created_at.toISOString(),
|
|
});
|
|
|
|
private fetchNotificationIds = async (monitorIds: string[]): Promise<Map<string, string[]>> => {
|
|
const result = await this.pool.query(`SELECT monitor_id, notification_id FROM monitor_notifications WHERE monitor_id = ANY($1)`, [monitorIds]);
|
|
const map = new Map<string, string[]>();
|
|
for (const row of result.rows) {
|
|
if (!map.has(row.monitor_id)) map.set(row.monitor_id, []);
|
|
map.get(row.monitor_id)!.push(row.notification_id);
|
|
}
|
|
return map;
|
|
};
|
|
|
|
private fetchCheckChildData = async (checkId: string) => {
|
|
const [diskResult, netResult, errorsResult] = await Promise.all([
|
|
this.pool.query(
|
|
`SELECT device, mountpoint, total_bytes, free_bytes, used_bytes, usage_percent,
|
|
total_inodes, free_inodes, used_inodes, inodes_usage_percent,
|
|
read_bytes, write_bytes, read_time, write_time
|
|
FROM check_disks WHERE check_id = $1`,
|
|
[checkId]
|
|
),
|
|
this.pool.query(
|
|
`SELECT name, bytes_sent, bytes_recv, packets_sent, packets_recv,
|
|
err_in, err_out, drop_in, drop_out, fifo_in, fifo_out
|
|
FROM check_network_interfaces WHERE check_id = $1`,
|
|
[checkId]
|
|
),
|
|
this.pool.query(`SELECT metrics, error FROM check_errors WHERE check_id = $1`, [checkId]),
|
|
]);
|
|
return {
|
|
disk: diskResult.rows.map((d) => ({
|
|
device: d.device,
|
|
mountpoint: d.mountpoint,
|
|
total_bytes: Number(d.total_bytes),
|
|
free_bytes: Number(d.free_bytes),
|
|
used_bytes: Number(d.used_bytes),
|
|
usage_percent: d.usage_percent,
|
|
total_inodes: Number(d.total_inodes),
|
|
free_inodes: Number(d.free_inodes),
|
|
used_inodes: Number(d.used_inodes),
|
|
inodes_usage_percent: d.inodes_usage_percent,
|
|
read_bytes: Number(d.read_bytes),
|
|
write_bytes: Number(d.write_bytes),
|
|
read_time: Number(d.read_time),
|
|
write_time: Number(d.write_time),
|
|
})),
|
|
net: netResult.rows.map((n) => ({
|
|
name: n.name,
|
|
bytes_sent: Number(n.bytes_sent),
|
|
bytes_recv: Number(n.bytes_recv),
|
|
packets_sent: Number(n.packets_sent),
|
|
packets_recv: Number(n.packets_recv),
|
|
err_in: Number(n.err_in),
|
|
err_out: Number(n.err_out),
|
|
drop_in: Number(n.drop_in),
|
|
drop_out: Number(n.drop_out),
|
|
fifo_in: Number(n.fifo_in),
|
|
fifo_out: Number(n.fifo_out),
|
|
})),
|
|
errors: errorsResult.rows.map((e) => ({ metric: e.metrics ?? [], err: e.error ?? "" })),
|
|
};
|
|
};
|
|
|
|
private toEntity = (row: MonitorRow): Monitor => ({
|
|
id: row.id,
|
|
userId: row.user_id,
|
|
teamId: row.team_id,
|
|
name: row.name,
|
|
description: row.description ?? undefined,
|
|
status: row.status as MonitorStatus,
|
|
statusWindow: row.status_window ?? [],
|
|
statusWindowSize: row.status_window_size,
|
|
statusWindowThreshold: row.status_window_threshold,
|
|
type: row.type,
|
|
ignoreTlsErrors: row.ignore_tls_errors,
|
|
useAdvancedMatching: row.use_advanced_matching,
|
|
jsonPath: row.json_path ?? undefined,
|
|
expectedValue: row.expected_value ?? undefined,
|
|
matchMethod: row.match_method ?? undefined,
|
|
url: row.url ?? "",
|
|
port: row.port ?? undefined,
|
|
isActive: row.is_active,
|
|
interval: row.interval_ms,
|
|
uptimePercentage: row.uptime_percentage ?? undefined,
|
|
notifications: [],
|
|
secret: row.secret ?? undefined,
|
|
cpuAlertThreshold: row.cpu_alert_threshold,
|
|
cpuAlertCounter: row.cpu_alert_counter,
|
|
memoryAlertThreshold: row.memory_alert_threshold,
|
|
memoryAlertCounter: row.memory_alert_counter,
|
|
diskAlertThreshold: row.disk_alert_threshold,
|
|
diskAlertCounter: row.disk_alert_counter,
|
|
tempAlertThreshold: row.temp_alert_threshold,
|
|
tempAlertCounter: row.temp_alert_counter,
|
|
selectedDisks: row.selected_disks ?? [],
|
|
gameId: row.game_id ?? undefined,
|
|
grpcServiceName: row.grpc_service_name ?? undefined,
|
|
strategy: (row.strategy as Monitor["strategy"]) ?? undefined,
|
|
group: row.monitor_group,
|
|
geoCheckEnabled: row.geo_check_enabled,
|
|
geoCheckLocations: row.geo_check_locations ?? [],
|
|
geoCheckInterval: row.geo_check_interval_ms,
|
|
recentChecks: [],
|
|
createdAt: row.created_at.toISOString(),
|
|
updatedAt: row.updated_at.toISOString(),
|
|
});
|
|
}
|