Files
Checkmate/server/src/service/network/HttpProvider.ts
T

175 lines
4.9 KiB
TypeScript
Raw Normal View History

2026-03-04 23:24:48 +00:00
import { type Got, HTTPError, RequestError } from "got";
2026-06-09 12:34:15 -07:00
import { IAdvancedMatcher } from "@/service/network/AdvancedMatcher.js";
import { IStatusProvider } from "@/service/network/IStatusProvider.js";
2026-03-04 23:24:48 +00:00
import { HttpStatusPayload } from "@/types/network.js";
import { MonitorStatusResponse } from "@/types/network.js";
import { Agent as HttpsAgent } from "https";
import { Agent as HttpAgent } from "http";
2026-06-09 12:34:15 -07:00
import { Monitor, MonitorType } from "@/domain/monitors/monitor.types.js";
import { NETWORK_ERROR, isStatusUp } from "@/service/network/utils.js";
2026-03-05 19:34:57 +00:00
import CacheableLookup from "cacheable-lookup";
2026-03-04 23:24:48 +00:00
export class HttpProvider implements IStatusProvider<HttpStatusPayload> {
readonly type = "http";
// Shared, pooled agents reused across every check
private readonly httpAgent: HttpAgent;
private readonly httpsAgent: HttpsAgent;
private readonly httpsAgentInsecure: HttpsAgent;
2026-03-04 23:24:48 +00:00
constructor(
private got: Got,
2026-03-20 11:29:44 -07:00
private advancedMatcher: IAdvancedMatcher
2026-03-05 19:34:57 +00:00
) {
const cacheable = new CacheableLookup({ maxTtl: 300, errorTtl: 30 });
2026-03-05 19:34:57 +00:00
this.got = got.extend({
dnsCache: cacheable,
timeout: {
request: 30000,
},
retry: { limit: 1 },
});
const agentOptions = { keepAlive: true, maxSockets: 256, maxFreeSockets: 256 };
this.httpAgent = new HttpAgent(agentOptions);
this.httpsAgent = new HttpsAgent({ ...agentOptions, rejectUnauthorized: true });
this.httpsAgentInsecure = new HttpsAgent({ ...agentOptions, rejectUnauthorized: false });
2026-03-05 19:34:57 +00:00
}
2026-03-04 23:24:48 +00:00
2026-03-05 17:54:16 +00:00
supports(type: MonitorType) {
2026-03-04 23:24:48 +00:00
return type === "http";
}
private buildResponse<T>(
monitor: Monitor,
opts: {
body: string;
contentType: string;
statusCode: number;
statusUp: boolean;
message: string;
responseTime: number;
timings?: MonitorStatusResponse<T>["timings"];
}
): MonitorStatusResponse<T> {
const { body, contentType, statusCode, statusUp, message, responseTime, timings } = opts;
const isJson = contentType.includes("application/json");
if (monitor.jsonPath && !isJson) {
return {
monitorId: monitor.id,
teamId: monitor.teamId,
type: monitor.type,
status: false,
code: statusCode,
message: "Response is not JSON",
responseTime,
timings,
payload: body,
};
}
let payload: T | string;
if (isJson) {
try {
payload = JSON.parse(body) as T;
} catch {
payload = body;
}
} else {
payload = body;
}
const matchResult = this.advancedMatcher.validate<T | string>(payload, monitor);
return {
monitorId: monitor.id,
teamId: monitor.teamId,
type: monitor.type,
status: statusUp && matchResult.ok,
code: statusCode,
message: matchResult.ok ? message : matchResult.message,
responseTime,
timings,
payload,
extracted: matchResult.extracted,
};
}
2026-03-04 23:24:48 +00:00
private handleHttpError<T>(error: unknown, monitor: Monitor): MonitorStatusResponse<T> {
if (error instanceof HTTPError || error instanceof RequestError) {
const statusCode = error.response?.statusCode;
const statusUp = isStatusUp(statusCode, monitor.customUpCodes);
const responseTime = error.timings?.phases?.firstByte ?? error.timings?.phases?.total ?? 0;
if (!statusUp) {
return {
monitorId: monitor.id,
teamId: monitor.teamId,
type: monitor.type,
status: false,
code: statusCode ?? NETWORK_ERROR,
message: error.message,
responseTime,
timings: error.timings,
payload: null as T,
};
}
return this.buildResponse<T>(monitor, {
body: (error.response?.body ?? "") as string,
contentType: error.response?.headers?.["content-type"] || "",
statusCode: statusCode ?? NETWORK_ERROR,
statusUp,
message: error.message,
responseTime,
2026-03-04 23:24:48 +00:00
timings: error.timings,
});
2026-03-04 23:24:48 +00:00
}
return {
monitorId: monitor.id,
teamId: monitor.teamId,
type: monitor.type,
status: false,
code: NETWORK_ERROR,
message: error instanceof Error ? error.message : String(error),
responseTime: 0,
payload: null as T,
};
}
async handle<T>(monitor: Monitor): Promise<MonitorStatusResponse<T>> {
const { url, secret, ignoreTlsErrors } = monitor;
2026-03-04 23:36:36 +00:00
if (!url) {
throw new Error("URL is required for HTTP monitor");
}
2026-03-04 23:24:48 +00:00
const options: Record<string, unknown> = {
headers: monitor.secret ? { Authorization: `Bearer ${secret}` } : undefined,
};
options.agent = {
http: this.httpAgent,
https: ignoreTlsErrors ? this.httpsAgentInsecure : this.httpsAgent,
2026-03-04 23:24:48 +00:00
};
try {
const response = await this.got<string>(url, options);
const statusUp = isStatusUp(response.statusCode, monitor.customUpCodes);
return this.buildResponse<T>(monitor, {
body: response.body,
contentType: response.headers["content-type"] || "",
statusCode: response.statusCode,
statusUp,
message: response.statusMessage ?? "OK",
responseTime: response.timings.phases.firstByte ?? 0,
2026-03-04 23:24:48 +00:00
timings: response.timings,
});
2026-03-04 23:24:48 +00:00
} catch (error: unknown) {
return this.handleHttpError(error, monitor);
}
}
}