Files
Checkmate/server/src/services/infrastructure/NetworkService.ts
T

312 lines
9.0 KiB
TypeScript
Raw Normal View History

2025-11-13 13:47:26 -08:00
import { Got, HTTPError } from "got";
import ping from "ping";
2025-11-21 20:03:03 +00:00
import net from "net";
2025-11-13 13:47:26 -08:00
import { IMonitor } from "@/db/models/index.js";
import { GotTimings } from "@/db/models/checks/Check.js";
import type { Response } from "got";
import type {
ISystemInfo,
ICaptureInfo,
ILighthouseResult,
} from "@/db/models/index.js";
import { MonitorType, MonitorStatus } from "@/db/models/monitors/Monitor.js";
import ApiError from "@/utils/ApiError.js";
import { config } from "@/config/index.js";
import CacheableLookup from "cacheable-lookup";
2025-11-21 20:03:03 +00:00
import { getChildLogger } from "@/logger/Logger.js";
2025-11-13 13:47:26 -08:00
const SERVICE_NAME = "NetworkService";
2025-11-21 20:03:03 +00:00
const logger = getChildLogger(SERVICE_NAME);
2025-11-13 13:47:26 -08:00
export interface INetworkService {
requestHttp: (monitor: IMonitor) => Promise<StatusResponse>;
requestInfrastructure: (monitor: IMonitor) => Promise<StatusResponse>;
requestStatus: (monitor: IMonitor) => Promise<StatusResponse>;
requestPagespeed: (monitor: IMonitor) => Promise<StatusResponse>;
requestPing: (monitor: IMonitor) => Promise<StatusResponse>;
2025-11-21 20:03:03 +00:00
requestPort: (monitor: IMonitor) => Promise<StatusResponse>;
2025-11-13 13:47:26 -08:00
}
export interface ICapturePayload {
data: ISystemInfo;
capture: ICaptureInfo;
}
export interface ILighthousePayload {
lighthouseResult: ILighthouseResult;
}
export interface StatusResponse<TPayload = unknown> {
monitorId: string;
teamId: string;
type: MonitorType;
code?: number;
status: MonitorStatus;
message: string;
responseTime: number;
timings?: GotTimings;
payload?: TPayload;
}
class NetworkService implements INetworkService {
public SERVICE_NAME = SERVICE_NAME;
2025-11-14 19:10:34 +00:00
private client: Got;
2025-11-13 13:47:26 -08:00
private NETWORK_ERROR: number;
2025-11-14 19:10:34 +00:00
constructor(got: Got) {
2025-11-13 13:47:26 -08:00
this.SERVICE_NAME = SERVICE_NAME;
this.NETWORK_ERROR = 5000;
const cacheable = new CacheableLookup();
2025-11-14 19:10:34 +00:00
this.client = got.extend({
2025-11-13 13:47:26 -08:00
dnsCache: cacheable,
timeout: {
request: 30000,
},
retry: { limit: 1 },
});
}
private buildStatusResponse = <T>(
monitor: IMonitor,
response: Response<T> | null,
error: any | null
): StatusResponse<T> => {
if (error) {
const statusResponse: StatusResponse<T> = {
monitorId: monitor._id.toString(),
teamId: monitor.teamId.toString(),
type: monitor.type,
status: "down" as MonitorStatus,
code: this.NETWORK_ERROR,
message: error.message || "Network error",
responseTime: 0,
timings: { phases: {} } as GotTimings,
};
if (error instanceof HTTPError) {
statusResponse.code = error?.response?.statusCode || this.NETWORK_ERROR;
statusResponse.message = error.message || "HTTP error";
statusResponse.responseTime = error.timings?.phases?.total || 0;
statusResponse.timings = error.timings;
}
return statusResponse;
}
const statusResponse: StatusResponse<T> = {
monitorId: monitor._id.toString(),
teamId: monitor.teamId.toString(),
type: monitor.type,
code: response?.statusCode || this.NETWORK_ERROR,
status: response?.ok === true ? "up" : "down",
message: response?.statusMessage || "",
responseTime: response?.timings?.phases?.total || 0,
timings: response?.timings || ({ phases: {} } as GotTimings),
};
return statusResponse;
};
requestHttp = async (monitor: IMonitor) => {
try {
const url = monitor.url;
if (!url) {
throw new Error("No URL provided");
}
try {
2025-11-14 19:10:34 +00:00
const response: Response = await this.client(url);
2025-11-13 13:47:26 -08:00
return this.buildStatusResponse(monitor, response, null);
} catch (error) {
return this.buildStatusResponse(monitor, null, error);
}
} catch (error) {
throw error;
}
};
requestInfrastructure = async (monitor: IMonitor) => {
const url = monitor.url;
if (!url) {
throw new Error("No URL provided");
}
const secret = monitor.secret;
if (!secret) {
throw new Error("No secret provided for infrastructure monitor");
}
let statusResponse: StatusResponse<ICapturePayload>;
try {
2025-11-14 19:10:34 +00:00
const response: Response<ICapturePayload> | null = await this.client(
url,
{
headers: { Authorization: `Bearer ${secret}` },
responseType: "json",
}
);
2025-11-13 13:47:26 -08:00
statusResponse = this.buildStatusResponse(monitor, response, null);
if (!response?.body) {
throw new ApiError(
"No payload received from infrastructure monitor",
500
);
}
statusResponse.payload = response?.body;
return statusResponse;
} catch (error) {
statusResponse = this.buildStatusResponse(monitor, null, error);
}
return statusResponse;
};
requestPagespeed = async (monitor: IMonitor) => {
const apiKey = config.PAGESPEED_API_KEY;
if (!apiKey) {
throw new Error("No API key provided for pagespeed monitor");
}
const url = monitor.url;
if (!url) {
throw new Error("No URL provided");
}
let statusResponse: StatusResponse<ILighthousePayload>;
try {
2025-11-14 19:10:34 +00:00
const response: Response = await this.client(url);
2025-11-13 13:47:26 -08:00
statusResponse = this.buildStatusResponse(
monitor,
response,
null
) as StatusResponse<ILighthousePayload>;
} catch (error) {
statusResponse = this.buildStatusResponse(monitor, null, error);
}
const pagespeedUrl = `https://pagespeedonline.googleapis.com/pagespeedonline/v5/runPagespeed?url=${url}&category=seo&category=accessibility&category=best-practices&category=performance&key=${apiKey}`;
2025-11-14 19:10:34 +00:00
const pagespeedResponse = await this.client<ILighthousePayload>(
pagespeedUrl,
{
responseType: "json",
}
);
2025-11-13 13:47:26 -08:00
const payload = pagespeedResponse.body;
if (payload) {
statusResponse.payload = payload;
return statusResponse;
} else {
throw new ApiError("No payload received from pagespeed monitor", 500);
}
};
requestPing = async (monitor: IMonitor) => {
const response = await ping.promise.probe(monitor.url);
const status = response?.alive === true ? "up" : "down";
const rawTime =
typeof response?.time === "string"
? parseFloat(response.time)
: Number(response?.time);
const responseTime = Number.isFinite(rawTime) ? rawTime : 0;
return {
monitorId: monitor._id.toString(),
teamId: monitor.teamId.toString(),
type: monitor.type,
status: status as MonitorStatus,
message: "Ping successful",
responseTime,
timings: { phases: {} } as GotTimings,
};
};
2025-11-21 20:03:03 +00:00
requestPort = async (monitor: IMonitor) => {
const response = {
monitorId: monitor._id.toString(),
teamId: monitor.teamId.toString(),
type: monitor.type,
status: "down" as MonitorStatus,
message: "Port check failed",
responseTime: 0,
timings: { phases: {} } as GotTimings,
};
try {
const host = monitor.url;
const port = monitor.port;
if (!port) {
throw new Error("No port provided for port monitor");
}
const { status, responseTime, message } = await new Promise<{
status: MonitorStatus;
responseTime: number;
message: string;
}>((resolve) => {
const start = performance.now();
const socket = net.createConnection({
host,
port,
});
socket.setTimeout(5000);
socket.on("connect", () => {
socket.destroy();
const duration = performance.now() - start;
resolve({
status: "up",
responseTime: duration,
message: "Port is open",
});
});
socket.on("error", (err) => {
socket.destroy();
const duration = performance.now() - start;
resolve({
status: "down",
responseTime: duration,
message: err.message,
});
});
socket.on("timeout", () => {
socket.destroy();
const duration = performance.now() - start;
resolve({
status: "down",
responseTime: duration,
message: "Port check timed out",
});
});
});
response.status = status;
response.responseTime = responseTime;
response.message = message;
} catch (error) {
console.error(error);
} finally {
return response;
}
};
2025-11-13 13:47:26 -08:00
requestStatus = async (monitor: IMonitor) => {
switch (monitor?.type) {
case "http":
return await this.requestHttp(monitor); // uses GOT
case "https":
return await this.requestHttp(monitor); // uses GOT
case "infrastructure":
return await this.requestInfrastructure(monitor); // uses GOT
case "pagespeed":
return await this.requestPagespeed(monitor); // uses GOT
case "ping":
return await this.requestPing(monitor); // uses PING
2025-11-21 20:03:03 +00:00
case "port":
return await this.requestPort(monitor);
2025-11-13 13:47:26 -08:00
default:
throw new Error("Not implemented");
}
};
}
export default NetworkService;