Files
Checkmate/server/src/domain/checks/check.repository.mongo.ts
T

595 lines
18 KiB
TypeScript

import { IChecksRepository } from "@/domain/checks/check.repository.interface.js";
import type {
Check,
CheckAudits,
CheckCaptureInfo,
CheckCpuInfo,
CheckDiskInfo,
CheckErrorInfo,
CheckHostInfo,
CheckMemoryInfo,
CheckMetadata,
CheckNetworkInterfaceInfo,
GotTimings,
HardwareCheckStats,
} from "@/domain/checks/check.type.js";
import type { MonitorType } from "@/domain/monitors/monitor.type.js";
import { CheckModel, type CheckDocument } from "@/domain/checks/check.model.js";
import mongoose from "mongoose";
import { getDateFormat, getDateForRange } from "@/utils/dataUtils.js";
import { ILogger } from "@/utils/logger.js";
import { toStringId, toDateString } from "@/utils/mongoMappers.js";
import { getHardwareUpChecks, getHardwareStats, getHardwareTotalChecks } from "@/domain/checks/check.hardware.aggregations.js";
import { CheckFilter, DateRange } from "@/types/query.js";
import { AppError } from "@/utils/AppError.js";
import { NETWORK_ERROR } from "@/types/network.js";
const SERVICE_NAME = "StatusService";
class MongoChecksRepository implements IChecksRepository {
static SERVICE_NAME = SERVICE_NAME;
private logger: ILogger;
constructor(logger: ILogger) {
this.logger = logger;
}
private toEntity = (doc: CheckDocument): Check => {
const mapTimings = (timings?: GotTimings): GotTimings => {
const phases = timings?.phases ?? {
wait: 0,
dns: 0,
tcp: 0,
tls: 0,
request: 0,
firstByte: 0,
download: 0,
total: 0,
};
return {
start: timings?.start ?? 0,
socket: timings?.socket ?? 0,
lookup: timings?.lookup ?? 0,
connect: timings?.connect ?? 0,
secureConnect: timings?.secureConnect ?? 0,
upload: timings?.upload ?? 0,
response: timings?.response ?? 0,
end: timings?.end ?? 0,
phases,
};
};
const mapCpu = (cpu?: CheckCpuInfo): CheckCpuInfo => ({
physical_core: cpu?.physical_core ?? 0,
logical_core: cpu?.logical_core ?? 0,
frequency: cpu?.frequency ?? 0,
temperature: cpu?.temperature ?? [],
free_percent: cpu?.free_percent ?? 0,
usage_percent: cpu?.usage_percent ?? 0,
});
const mapMemory = (memory?: CheckMemoryInfo): CheckMemoryInfo => ({
total_bytes: memory?.total_bytes ?? 0,
available_bytes: memory?.available_bytes ?? 0,
used_bytes: memory?.used_bytes ?? 0,
usage_percent: memory?.usage_percent ?? 0,
});
const mapHost = (host?: CheckHostInfo): CheckHostInfo => ({
os: host?.os ?? "",
platform: host?.platform ?? "",
kernel_version: host?.kernel_version ?? "",
pretty_name: host?.pretty_name ?? "",
});
const mapCapture = (capture?: CheckCaptureInfo): CheckCaptureInfo => ({
version: capture?.version ?? "",
mode: capture?.mode ?? "",
});
const mapDisks = (disks?: CheckDiskInfo[]): CheckDiskInfo[] =>
(disks ?? []).map((disk) => ({
device: disk?.device ?? "",
mountpoint: disk?.mountpoint ?? "",
total_bytes: disk?.total_bytes ?? 0,
free_bytes: disk?.free_bytes ?? 0,
used_bytes: disk?.used_bytes ?? 0,
usage_percent: disk?.usage_percent ?? 0,
total_inodes: disk?.total_inodes ?? 0,
free_inodes: disk?.free_inodes ?? 0,
used_inodes: disk?.used_inodes ?? 0,
inodes_usage_percent: disk?.inodes_usage_percent ?? 0,
read_bytes: disk?.read_bytes ?? 0,
write_bytes: disk?.write_bytes ?? 0,
read_time: disk?.read_time ?? 0,
write_time: disk?.write_time ?? 0,
}));
const mapErrors = (errors?: CheckErrorInfo[]): CheckErrorInfo[] =>
(errors ?? []).map((error) => ({
metric: error?.metric ?? [],
err: error?.err ?? "",
}));
const mapNet = (net?: CheckNetworkInterfaceInfo[]): CheckNetworkInterfaceInfo[] =>
(net ?? []).map((iface) => ({
name: iface?.name ?? "",
bytes_sent: iface?.bytes_sent ?? 0,
bytes_recv: iface?.bytes_recv ?? 0,
packets_sent: iface?.packets_sent ?? 0,
packets_recv: iface?.packets_recv ?? 0,
err_in: iface?.err_in ?? 0,
err_out: iface?.err_out ?? 0,
drop_in: iface?.drop_in ?? 0,
drop_out: iface?.drop_out ?? 0,
fifo_in: iface?.fifo_in ?? 0,
fifo_out: iface?.fifo_out ?? 0,
}));
const mapAudits = (audits?: CheckAudits): CheckAudits | undefined => {
if (!audits) {
return undefined;
}
return {
cls: audits.cls,
si: audits.si,
fcp: audits.fcp,
lcp: audits.lcp,
tbt: audits.tbt,
};
};
const mapMetadata = (metadata: CheckDocument["metadata"]): CheckMetadata => ({
monitorId: toStringId(metadata.monitorId),
teamId: toStringId(metadata.teamId),
type: metadata.type,
});
return {
id: toStringId(doc._id),
metadata: mapMetadata(doc.metadata),
status: doc.status ?? false,
responseTime: doc.responseTime ?? 0,
timings: mapTimings(doc.timings),
statusCode: doc.statusCode ?? 0,
message: doc.message ?? "",
cpu: mapCpu(doc.cpu),
memory: mapMemory(doc.memory),
disk: mapDisks(doc.disk),
host: mapHost(doc.host),
errors: mapErrors(doc.errors),
capture: mapCapture(doc.capture),
net: mapNet(doc.net),
accessibility: doc.accessibility,
bestPractices: doc.bestPractices,
seo: doc.seo,
performance: doc.performance,
audits: mapAudits(doc.audits),
createdAt: toDateString(doc.createdAt),
updatedAt: toDateString(doc.updatedAt),
};
};
private mapDocuments = (documents: CheckDocument[]): Check[] => {
if (!documents?.length) {
return [];
}
return documents.map((doc) => this.toEntity(doc));
};
private toDocument = (check: Partial<Check>): CheckDocument => {
// Map id to _id for MongoDB storage
const { id, metadata, ...rest } = check;
if (!metadata || !metadata.monitorId || !metadata.teamId) {
throw new AppError({
message: `Check must have valid metadata with monitorId and teamId. Got: ${JSON.stringify({ id, metadata })}`,
status: 500,
service: SERVICE_NAME,
method: "toDocument",
});
}
return {
_id: id ? new mongoose.Types.ObjectId(id) : new mongoose.Types.ObjectId(),
metadata: {
monitorId: new mongoose.Types.ObjectId(metadata.monitorId),
teamId: new mongoose.Types.ObjectId(metadata.teamId),
type: metadata.type,
},
...rest,
} as unknown as CheckDocument;
};
create = async (check: Check) => {
const savedCheck = await CheckModel.create(check);
return this.toEntity(savedCheck);
};
createChecks = async (checks: Check[]) => {
const docs = checks.map((check) => this.toDocument(check));
const inserted = await CheckModel.insertMany(docs);
return this.mapDocuments(inserted as unknown as CheckDocument[]);
};
private filterToMatch = (filter: CheckFilter | undefined): Record<string, unknown> => {
switch (filter) {
case "up":
return { status: true };
case "down":
return { status: false };
case "resolve":
return { status: false, statusCode: NETWORK_ERROR };
default:
this.logger.warn({
message: "invalid filter",
service: SERVICE_NAME,
method: "filterToMatch",
});
return {};
}
};
findByMonitorId = async (
monitorId: string,
sortOrder: string,
dateRange: DateRange,
page: number,
rowsPerPage: number,
status: boolean | undefined,
filter?: CheckFilter
) => {
// Match
const matchStage: Record<string, unknown> = {
"metadata.monitorId": new mongoose.Types.ObjectId(monitorId),
...(typeof status !== "undefined" && { status }),
createdAt: { $gte: getDateForRange(dateRange) },
...this.filterToMatch(filter),
};
//Sort
const convertedSortOrder = sortOrder === "asc" ? 1 : -1;
// Pagination
let skip = 0;
if (page && rowsPerPage) {
skip = page * rowsPerPage;
}
const [checksCount, checks] = await Promise.all([
CheckModel.countDocuments(matchStage),
CheckModel.find(matchStage).sort({ createdAt: convertedSortOrder }).skip(skip).limit(rowsPerPage).lean() as Promise<CheckDocument[]>,
]);
return { checksCount, checks: this.mapDocuments(checks) };
};
findByTeamId = async (sortOrder: string, dateRange: DateRange, page: number, rowsPerPage: number, teamId: string, filter?: CheckFilter) => {
const matchStage: Record<string, unknown> = {
"metadata.teamId": new mongoose.Types.ObjectId(teamId),
createdAt: { $gte: getDateForRange(dateRange) },
...this.filterToMatch(filter),
};
const parsedSortOrder = sortOrder === "asc" ? 1 : -1;
// pagination
let skip = 0;
if (page && rowsPerPage) {
skip = page * rowsPerPage;
}
const [checksCount, checks] = await Promise.all([
CheckModel.countDocuments(matchStage),
CheckModel.find(matchStage).sort({ createdAt: parsedSortOrder }).skip(skip).limit(rowsPerPage).lean() as Promise<CheckDocument[]>,
]);
return { checksCount, checks: this.mapDocuments(checks) };
};
findByDateRangeAndMonitorId = async (monitorId: string, dateRange: DateRange, options?: { type?: MonitorType }) => {
const monitorObjectId = new mongoose.Types.ObjectId(monitorId);
const start = getDateForRange(dateRange);
const dateString = getDateFormat(dateRange);
const end = new Date();
if (options?.type === "hardware") {
return this.findHardwareDateRangeChecks(monitorObjectId, start, end, dateString);
}
if (options?.type === "pagespeed") {
return this.findPageSpeedDateRangeChecks(monitorObjectId, start, end, dateString);
}
return this.findUptimeDateRangeChecks(options?.type ?? "http", monitorObjectId, start, end, dateString);
};
findSummaryByTeamId = async (teamId: string, dateRange: DateRange) => {
const baseMatch = {
"metadata.teamId": new mongoose.Types.ObjectId(teamId),
createdAt: { $gte: getDateForRange(dateRange) },
};
const [totalResult, downResult] = await Promise.all([
CheckModel.countDocuments(baseMatch),
CheckModel.countDocuments({ ...baseMatch, status: false }),
]);
return {
totalChecks: totalResult,
downChecks: downResult,
};
};
findUnevaluatedByMonitorId = async (monitorId: string, since: number) => {
const docs = await CheckModel.find({
"metadata.monitorId": new mongoose.Types.ObjectId(monitorId),
createdAt: { $gt: new Date(since) },
})
.sort({ createdAt: 1 })
.lean<CheckDocument[]>();
return docs.map(this.toEntity);
};
deleteByMonitorId = async (monitorId: string): Promise<number> => {
const result = await CheckModel.deleteMany({ "metadata.monitorId": new mongoose.Types.ObjectId(monitorId) });
return result.deletedCount;
};
deleteByTeamId = async (teamId: string) => {
const deleteResult = await CheckModel.deleteMany({ "metadata.teamId": teamId });
return deleteResult.deletedCount;
};
deleteByMonitorIdsNotIn = async (monitorIds: string[]): Promise<number> => {
const objectIds = monitorIds.map((id) => new mongoose.Types.ObjectId(id));
const result = await CheckModel.deleteMany({ "metadata.monitorId": { $nin: objectIds } });
return result.deletedCount ?? 0;
};
deleteOlderThan = async (cutoffDate: Date, batchDays: number = 30): Promise<number> => {
// Find the oldest check that is older than the cutoff
const oldest = await CheckModel.findOne({ createdAt: { $lt: cutoffDate } })
.sort({ createdAt: 1 })
.select({ createdAt: 1 });
if (!oldest?.createdAt) return 0;
let totalDeleted = 0;
let batchStart = new Date(oldest.createdAt);
const batchMs = batchDays * 24 * 60 * 60 * 1000;
// Delete in 30 day chunks until we reach the cutoff
while (batchStart < cutoffDate) {
// Advance startTime by batchMs to get to the end of last batch
const nextStart = batchStart.getTime() + batchMs;
const batchEnd = new Date(Math.min(nextStart, cutoffDate.getTime()));
const result = await CheckModel.deleteMany({
createdAt: { $gte: batchStart, $lt: batchEnd },
});
totalDeleted += result.deletedCount ?? 0;
batchStart = batchEnd;
}
return totalDeleted;
};
private findUptimeDateRangeChecks = async (
monitorType: Exclude<MonitorType, "hardware" | "pagespeed">,
monitorObjectId: mongoose.Types.ObjectId,
startDate: Date,
endDate: Date,
dateString: string
) => {
const matchStage = {
"metadata.monitorId": monitorObjectId,
createdAt: { $gte: startDate, $lte: endDate },
};
const [result] = await CheckModel.aggregate([
{ $match: matchStage },
{ $sort: { createdAt: 1 } },
{
$facet: {
uptimePercentage: [
{
$group: {
_id: null,
upChecks: { $sum: { $cond: [{ $eq: ["$status", true] }, 1, 0] } },
totalChecks: { $sum: 1 },
},
},
{
$project: {
_id: 0,
percentage: {
$cond: [{ $eq: ["$totalChecks", 0] }, 0, { $divide: ["$upChecks", "$totalChecks"] }],
},
},
},
],
groupedAvgResponseTime: [
{
$group: {
_id: null,
avgResponseTime: { $avg: "$responseTime" },
},
},
],
groupedChecks: [
{
$group: {
_id: {
$dateToString: { format: dateString, date: "$createdAt" },
},
avgResponseTime: { $avg: "$responseTime" },
avgDns: { $avg: { $ifNull: ["$timings.phases.dns", 0] } },
avgTcp: { $avg: { $ifNull: ["$timings.phases.tcp", 0] } },
avgTls: { $avg: { $ifNull: ["$timings.phases.tls", 0] } },
avgRequest: { $avg: { $ifNull: ["$timings.phases.request", 0] } },
avgFirstByte: { $avg: { $ifNull: ["$timings.phases.firstByte", 0] } },
avgDownload: { $avg: { $ifNull: ["$timings.phases.download", 0] } },
totalChecks: { $sum: 1 },
},
},
{ $sort: { _id: 1 } },
{
$project: {
bucketDate: "$_id",
avgResponseTime: 1,
totalChecks: 1,
avgDns: 1,
avgTcp: 1,
avgTls: 1,
avgRequest: 1,
avgFirstByte: 1,
avgDownload: 1,
_id: 0,
},
},
],
groupedUpChecks: [
{ $match: { status: true } },
{
$group: {
_id: {
$dateToString: { format: dateString, date: "$createdAt" },
},
totalChecks: { $sum: 1 },
avgResponseTime: { $avg: "$responseTime" },
},
},
{ $sort: { _id: 1 } },
{ $project: { bucketDate: "$_id", avgResponseTime: 1, totalChecks: 1, _id: 0 } },
],
groupedDownChecks: [
{ $match: { status: false } },
{
$group: {
_id: {
$dateToString: { format: dateString, date: "$createdAt" },
},
totalChecks: { $sum: 1 },
avgResponseTime: { $avg: "$responseTime" },
},
},
{ $sort: { _id: 1 } },
{ $project: { bucketDate: "$_id", avgResponseTime: 1, totalChecks: 1, _id: 0 } },
],
},
},
]);
const uptimePercentage = result?.uptimePercentage?.[0]?.percentage ?? 0;
const avgResponseTime = result?.groupedAvgResponseTime?.[0]?.avgResponseTime ?? 0;
return {
monitorType,
groupedChecks: result?.groupedChecks ?? [],
groupedUpChecks: result?.groupedUpChecks ?? [],
groupedDownChecks: result?.groupedDownChecks ?? [],
uptimePercentage,
avgResponseTime,
};
};
private findHardwareDateRangeChecks = async (monitorObjectId: mongoose.Types.ObjectId, startDate: Date, endDate: Date, dateString: string) => {
const monitorId = monitorObjectId.toHexString();
const dates = { start: startDate, end: endDate };
const [aggregateDataDoc, upChecksDoc, hardwareMetrics] = await Promise.all([
getHardwareTotalChecks(monitorId, dates),
getHardwareUpChecks(monitorId, dates),
getHardwareStats(monitorId, dates, dateString),
]);
const aggregateData = {
totalChecks: aggregateDataDoc ?? 0,
};
const upChecks = {
totalChecks: upChecksDoc?.totalChecks ?? 0,
};
const checks = (hardwareMetrics ?? []).map(
(metric): HardwareCheckStats => ({
bucketDate: metric._id,
avgCpuUsage: metric.avgCpuUsage ?? 0,
avgMemoryUsage: metric.avgMemoryUsage ?? 0,
avgTemperature: metric.avgTemperature ?? [],
disks: (metric.disks ?? []).map((disk) => ({
name: disk?.name ?? "",
readSpeed: disk?.readSpeed ?? 0,
writeSpeed: disk?.writeSpeed ?? 0,
totalBytes: disk?.totalBytes ?? 0,
freeBytes: disk?.freeBytes ?? 0,
usagePercent: disk?.usagePercent ?? 0,
})),
net: (metric.net ?? []).map((iface) => ({
name: iface?.name ?? "",
bytesSentPerSecond: iface?.bytesSentPerSecond ?? 0,
deltaBytesRecv: iface?.deltaBytesRecv ?? 0,
deltaPacketsSent: iface?.deltaPacketsSent ?? 0,
deltaPacketsRecv: iface?.deltaPacketsRecv ?? 0,
deltaErrIn: iface?.deltaErrIn ?? 0,
deltaErrOut: iface?.deltaErrOut ?? 0,
deltaDropIn: iface?.deltaDropIn ?? 0,
deltaDropOut: iface?.deltaDropOut ?? 0,
deltaFifoIn: iface?.deltaFifoIn ?? 0,
deltaFifoOut: iface?.deltaFifoOut ?? 0,
})),
})
);
return {
monitorType: "hardware" as const,
aggregateData,
upChecks,
checks,
};
};
private findPageSpeedDateRangeChecks = async (monitorObjectId: mongoose.Types.ObjectId, startDate: Date, endDate: Date, dateString: string) => {
const matchStage = {
"metadata.monitorId": monitorObjectId,
createdAt: { $gte: startDate, $lte: endDate },
};
const [result] = await CheckModel.aggregate([
{ $match: matchStage },
{ $sort: { createdAt: 1 } },
{
$facet: {
groupedChecks: [
{
$group: {
_id: {
$dateToString: { format: dateString, date: "$createdAt" },
},
avgPerformance: { $avg: "$performance" },
avgAccessibility: { $avg: "$accessibility" },
avgBestPractices: { $avg: "$bestPractices" },
avgSeo: { $avg: "$seo" },
totalChecks: { $sum: 1 },
},
},
{ $sort: { _id: 1 } },
{
$project: {
bucketDate: "$_id",
performance: "$avgPerformance",
accessibility: "$avgAccessibility",
bestPractices: "$avgBestPractices",
seo: "$avgSeo",
totalChecks: 1,
_id: 0,
},
},
],
},
},
]);
return {
monitorType: "pagespeed" as const,
groupedChecks: result?.groupedChecks ?? [],
};
};
}
export default MongoChecksRepository;