Compare commits

..
Author SHA1 Message Date
Alexander Holliday e3ecfe6ad8 Merge pull request #3323 from bluewave-labs/develop
develop -> master
2026-02-20 12:38:33 -08:00
Alexander Holliday f4664eec16 Merge pull request #3321 from bluewave-labs/develop
develop->master
2026-02-20 12:20:49 -08:00
Alexander Holliday 56f601e34b Merge pull request #3319 from bluewave-labs/develop
develop -> master
2026-02-20 12:07:29 -08:00
Alexander Holliday 1244ff6d93 Merge pull request #3212 from bluewave-labs/develop
develop -> master
2026-01-27 13:58:48 -08:00
Alexander Holliday c0ea804c98 Merge pull request #3209 from bluewave-labs/develop
develop -> master
2026-01-27 13:40:25 -08:00
Alexander Holliday c21cf29db6 Merge pull request #3207 from bluewave-labs/develop
develop -> master
2026-01-27 13:20:18 -08:00
Alexander Holliday 3d0da70ce6 Merge pull request #3204 from bluewave-labs/develop
develop -> master
2026-01-27 13:09:47 -08:00
Alexander Holliday feb061240b Merge pull request #3042 from bluewave-labs/develop
develp->master
2025-10-27 12:09:00 -07:00
Alexander Holliday a924227805 Merge pull request #2964 from bluewave-labs/develop
develop -> master
2025-09-18 13:40:45 -07:00
Alexander Holliday 2144d3f8c0 Merge pull request #2962 from bluewave-labs/develop
develop -> master
2025-09-18 12:04:51 -07:00
Alexander Holliday fcd6786149 Merge pull request #2936 from bluewave-labs/develop
develop -> master
2025-09-08 20:43:21 -07:00
Alexander Holliday ea968ebf3c Merge pull request #2933 from bluewave-labs/develop
develop -> master
2025-09-08 20:33:35 -07:00
Alexander Holliday 8a7b852974 Merge pull request #2929 from bluewave-labs/develop
develop -> master
2025-09-08 07:24:16 -07:00
Alexander Holliday c8d3e3b70c Merge pull request #2921 from bluewave-labs/develop
develop -> master
2025-09-04 15:46:30 -07:00
Alexander Holliday 7a90a6f9f4 Merge pull request #2915 from bluewave-labs/develop
develop->master
2025-09-01 10:33:09 -07:00
22 changed files with 117 additions and 745 deletions

No files matched your search

@@ -12,7 +12,7 @@ import {
import { HistogramPageSpeedScoresTooltip } from "@/Components/monitors"; import { HistogramPageSpeedScoresTooltip } from "@/Components/monitors";
import { useTheme } from "@mui/material/styles"; import { useTheme } from "@mui/material/styles";
import type { PageSpeedGroupedCheck } from "@/Types/Check"; import type { CheckSnapshot } from "@/Types/Check";
import type { Palette } from "@mui/material/styles"; import type { Palette } from "@mui/material/styles";
type PaletteColorKey = Extract< type PaletteColorKey = Extract<
keyof Palette, keyof Palette,
@@ -52,7 +52,7 @@ export const HistogramPageSpeedDetails = ({
checks, checks,
range, range,
}: { }: {
checks: PageSpeedGroupedCheck[]; checks: CheckSnapshot[];
range: string; range: string;
}) => { }) => {
const theme = useTheme(); const theme = useTheme();
@@ -73,7 +73,7 @@ export const HistogramPageSpeedDetails = ({
> >
<AreaChart data={checks}> <AreaChart data={checks}>
<XAxis <XAxis
dataKey={"bucketDate"} dataKey={"createdAt"}
tick={(props) => ( tick={(props) => (
<XTick <XTick
{...props} {...props}
-3
View File
@@ -14,9 +14,6 @@ const getBaseDefaults = (data?: Monitor | null) => ({
notifications: data?.notifications || [], notifications: data?.notifications || [],
statusWindowSize: data?.statusWindowSize || 5, statusWindowSize: data?.statusWindowSize || 5,
statusWindowThreshold: data?.statusWindowThreshold || 60, statusWindowThreshold: data?.statusWindowThreshold || 60,
geoCheckEnabled: data?.geoCheckEnabled || false,
geoCheckLocations: data?.geoCheckLocations || [],
geoCheckInterval: data?.geoCheckInterval || 300000,
}); });
export const useMonitorForm = ({ export const useMonitorForm = ({
-85
View File
@@ -30,7 +30,6 @@ import {
import { useGet, usePost, usePatch, useDelete } from "@/Hooks/UseApi"; import { useGet, usePost, usePatch, useDelete } from "@/Hooks/UseApi";
import { useMonitorForm } from "@/Hooks/useMonitorForm"; import { useMonitorForm } from "@/Hooks/useMonitorForm";
import type { Monitor, MonitorType, GamesMap } from "@/Types/Monitor"; import type { Monitor, MonitorType, GamesMap } from "@/Types/Monitor";
import { GeoCheckLocations } from "@/Types/Monitor";
import type { Notification } from "@/Types/Notification"; import type { Notification } from "@/Types/Notification";
import type { MonitorFormData } from "@/Validation/monitor"; import type { MonitorFormData } from "@/Validation/monitor";
@@ -166,7 +165,6 @@ const CreateMonitorPage = () => {
const watchedType = watch("type") as MonitorType; const watchedType = watch("type") as MonitorType;
const watchedUseAdvancedMatching = watch("useAdvancedMatching") as boolean; const watchedUseAdvancedMatching = watch("useAdvancedMatching") as boolean;
const watchGeoCheckEnabled = watch("geoCheckEnabled") as boolean;
useEffect(() => { useEffect(() => {
clearErrors(); clearErrors();
@@ -825,89 +823,6 @@ const CreateMonitorPage = () => {
/> />
)} )}
{/* Geo-distributed Checks Configuration */}
{watchedType === "http" && (
<ConfigBox
title={t("pages.createMonitor.form.geoChecks.title")}
subtitle={t("pages.createMonitor.form.geoChecks.description")}
rightContent={
<Stack spacing={theme.spacing(8)}>
<Controller
name="geoCheckEnabled"
control={control}
render={({ field }) => (
<Stack
direction="row"
alignItems="center"
spacing={theme.spacing(2)}
>
<Switch
checked={field.value ?? false}
onChange={(e) => field.onChange(e.target.checked)}
/>
<Typography>
{t("pages.createMonitor.form.geoChecks.option.enabled.label")}
</Typography>
</Stack>
)}
/>
{watchGeoCheckEnabled && (
<Stack spacing={theme.spacing(8)}>
<Controller
name="geoCheckLocations"
control={control}
render={({ field }) => {
const locationOptions = GeoCheckLocations.map((loc) => ({
id: loc,
name: t(
`pages.createMonitor.form.geoChecks.option.locations.options.${loc}`
),
}));
const selectedLocations = locationOptions.filter((loc) =>
(field.value ?? []).includes(loc.id)
);
return (
<Autocomplete
multiple={true}
options={locationOptions}
value={selectedLocations}
getOptionLabel={(option) => option.name}
onChange={(_, newValue: typeof locationOptions) => {
field.onChange(newValue.map((loc) => loc.id));
}}
isOptionEqualToValue={(option, value) => option.id === value.id}
fieldLabel={t(
"pages.createMonitor.form.geoChecks.option.locations.label"
)}
/>
);
}}
/>
<Controller
name="geoCheckInterval"
control={control}
render={({ field }) => (
<Select
value={field.value ?? 300000}
onChange={(e) => field.onChange(Number(e.target.value))}
fieldLabel={t(
"pages.createMonitor.form.geoChecks.option.interval.label"
)}
>
<MenuItem value={300000}>5 min</MenuItem>
<MenuItem value={600000}>10 min</MenuItem>
<MenuItem value={900000}>15 min</MenuItem>
<MenuItem value={1800000}>30 min</MenuItem>
</Select>
)}
/>
</Stack>
)}
</Stack>
}
/>
)}
<Stack <Stack
direction="row" direction="row"
justifyContent="flex-end" justifyContent="flex-end"
+4 -24
View File
@@ -1,5 +1,4 @@
import { BasePage } from "@/Components/design-elements"; import { BasePage } from "@/Components/design-elements";
import { HeaderTimeRange } from "@/Components/common";
import type { PageSpeedDetailsResponse } from "@/Types/Monitor"; import type { PageSpeedDetailsResponse } from "@/Types/Monitor";
import Stack from "@mui/material/Stack"; import Stack from "@mui/material/Stack";
import { import {
@@ -14,36 +13,23 @@ import { useIsAdmin } from "@/Hooks/useIsAdmin";
import { useGet } from "@/Hooks/UseApi"; import { useGet } from "@/Hooks/UseApi";
import { useParams } from "react-router-dom"; import { useParams } from "react-router-dom";
import { useTheme } from "@mui/material"; import { useTheme } from "@mui/material";
import { useState, useMemo } from "react";
const PageSpeedDetails = () => { const PageSpeedDetails = () => {
const { monitorId } = useParams(); const { monitorId } = useParams();
const isAdmin = useIsAdmin(); const isAdmin = useIsAdmin();
const theme = useTheme(); const theme = useTheme();
const [dateRange, setDateRange] = useState<string>("day");
const monitorDetailsUrl = useMemo(() => {
if (!monitorId) {
return null;
}
const params = new URLSearchParams();
params.append("dateRange", dateRange);
return `/monitors/pagespeed/details/${monitorId}?${params.toString()}`;
}, [monitorId, dateRange]);
const { const {
data: monitorData, data: monitorData,
isLoading, isLoading,
error, error,
refetch, refetch,
} = useGet<PageSpeedDetailsResponse>( } = useGet<PageSpeedDetailsResponse>(
monitorDetailsUrl, monitorId ? `/monitors/pagespeed/details/${monitorId}?dateRange=day` : null,
{}, {},
{ keepPreviousData: true, refreshInterval: 30000 } { keepPreviousData: true, refreshInterval: 30000 }
); );
const monitor = monitorData?.monitorData?.monitor; const monitor = monitorData?.monitor;
const groupedChecks = monitorData?.monitorData?.groupedChecks || [];
const monitorStats = monitorData?.monitorStats || null; const monitorStats = monitorData?.monitorStats || null;
return ( return (
@@ -61,15 +47,9 @@ const PageSpeedDetails = () => {
monitor={monitor} monitor={monitor}
monitorStats={monitorStats} monitorStats={monitorStats}
/> />
<HeaderTimeRange
isLoading={isLoading}
hasDateRange={true}
dateRange={dateRange}
setDateRange={setDateRange}
/>
<HistogramPageSpeedDetails <HistogramPageSpeedDetails
checks={groupedChecks} checks={monitor?.recentChecks || []}
range={dateRange} range="day"
/> />
<Stack <Stack
direction={{ xs: "column", md: "row" }} direction={{ xs: "column", md: "row" }}
+4 -55
View File
@@ -8,7 +8,6 @@ import { useTranslation } from "react-i18next";
import { useSelector, useDispatch } from "react-redux"; import { useSelector, useDispatch } from "react-redux";
import DummyChart from "@/Pages/Settings/DummyChart"; import DummyChart from "@/Pages/Settings/DummyChart";
import { useGet, usePatch, usePost, useLazyGet } from "@/Hooks/UseApi"; import { useGet, usePatch, usePost, useLazyGet } from "@/Hooks/UseApi";
import { useToast } from "@/Hooks/UseToast";
import { useSettingsForm } from "@/Hooks/useSettingsForm"; import { useSettingsForm } from "@/Hooks/useSettingsForm";
import { useIsAdmin } from "@/Hooks/useIsAdmin.js"; import { useIsAdmin } from "@/Hooks/useIsAdmin.js";
import type { SettingsFormData } from "@/Validation/settings"; import type { SettingsFormData } from "@/Validation/settings";
@@ -45,13 +44,10 @@ export const SettingsPage = () => {
const { t, i18n } = useTranslation(); const { t, i18n } = useTranslation();
const dispatch = useDispatch(); const dispatch = useDispatch();
const isAdmin = useIsAdmin(); const isAdmin = useIsAdmin();
const { toastError } = useToast();
// Local state for demo monitors dialog // Local state for demo monitors dialog
const [isDemoMonitorsDialogOpen, setIsDemoMonitorsDialogOpen] = useState(false); const [isDemoMonitorsDialogOpen, setIsDemoMonitorsDialogOpen] = useState(false);
const { post: postDemoMonitors, loading: isPostingDemoMonitors } = usePost(); const { post: postDemoMonitors, loading: isPostingDemoMonitors } = usePost();
const { deleteFn: deleteAllMonitors, loading: isDeletingAllMonitors } = useDelete(); const { deleteFn: deleteAllMonitors, loading: isDeletingAllMonitors } = useDelete();
// Import monitors functionality
const { post: importMonitors, loading: isImportingMonitors } = usePost();
// Fetch settings data from API // Fetch settings data from API
const { data: fetchedSettings } = useGet<SettingsResponse>("/settings"); const { data: fetchedSettings } = useGet<SettingsResponse>("/settings");
@@ -206,36 +202,6 @@ export const SettingsPage = () => {
URL.revokeObjectURL(url); URL.revokeObjectURL(url);
}; };
const handleFileSelect = async (event: React.ChangeEvent<HTMLInputElement>) => {
const file = event.target.files?.[0];
if (!file) {
return;
}
if (file.type !== "application/json") {
toastError("Please select a valid JSON file");
event.target.value = "";
}
try {
const text = await file.text();
const monitors = JSON.parse(text);
if (!Array.isArray(monitors)) {
toastError("Invalid file format: expected an array of monitors");
event.target.value = "";
return;
}
await importMonitors("/monitors/import/json", { monitors });
event.target.value = "";
} catch (error) {
toastError("Error parsing JSON file. Please check the file format.");
event.target.value = "";
}
};
const onSubmit = async (data: SettingsFormData) => { const onSubmit = async (data: SettingsFormData) => {
// Don't send pagespeedApiKey if it's already set and user hasn't clicked reset // Don't send pagespeedApiKey if it's already set and user hasn't clicked reset
const dataToSend = { ...data }; const dataToSend = { ...data };
@@ -900,34 +866,17 @@ export const SettingsPage = () => {
{/* Export Monitors - Admin Only */} {/* Export Monitors - Admin Only */}
{isAdmin && ( {isAdmin && (
<ConfigBox <ConfigBox
title={t("pages.settings.form.importExportMonitors.title")} title={t("pages.settings.form.exportMonitors.title")}
subtitle={t("pages.settings.form.importExportMonitors.description")} subtitle={t("pages.settings.form.exportMonitors.description")}
rightContent={ rightContent={
<Stack <Box>
gap={theme.spacing(4)}
direction={"row"}
>
<input
id="monitor-import-input"
type="file"
accept=".json"
style={{ display: "none" }}
onChange={handleFileSelect}
/>
<Button
variant="contained"
onClick={() => document.getElementById("monitor-import-input")?.click()}
disabled={isImportingMonitors}
>
{t("common.buttons.importFromJSON")}
</Button>
<Button <Button
variant="contained" variant="contained"
onClick={handleExportMonitors} onClick={handleExportMonitors}
> >
{t("common.buttons.exportToJSON")} {t("common.buttons.exportToJSON")}
</Button> </Button>
</Stack> </Box>
} }
/> />
)} )}
-18
View File
@@ -151,23 +151,6 @@ export interface GroupedCheck {
totalChecks: number; totalChecks: number;
} }
export interface PageSpeedGroupedCheck {
bucketDate: string;
performance: number;
accessibility: number;
bestPractices: number;
seo: number;
totalChecks: number;
}
export interface GroupedGeoCheck {
bucketDate: string;
continent: string;
avgResponseTime: number;
totalChecks: number;
uptimePercentage: number;
}
export interface LatestCheck { export interface LatestCheck {
status: boolean; status: boolean;
responseTime: number; responseTime: number;
@@ -244,7 +227,6 @@ export interface UptimeChecksResult {
groupedDownChecks: GroupedCheck[]; groupedDownChecks: GroupedCheck[];
uptimePercentage: number; uptimePercentage: number;
avgResponseTime: number; avgResponseTime: number;
groupedGeoChecks?: GroupedGeoCheck[];
} }
export interface ChecksSummary { export interface ChecksSummary {
+1 -11
View File
@@ -1,5 +1,4 @@
import type { GroupedCheck, CheckSnapshot } from "@/Types/Check"; import type { GroupedCheck, CheckSnapshot } from "@/Types/Check";
import type { PageSpeedGroupedCheck } from "@/Types/Check";
export const MonitorTypes = [ export const MonitorTypes = [
"http", "http",
@@ -25,9 +24,6 @@ export type MonitorStatus = (typeof MonitorStatuses)[number];
export type MonitorMatchMethod = "equal" | "include" | "regex" | ""; export type MonitorMatchMethod = "equal" | "include" | "regex" | "";
export const GeoCheckLocations = ["EU", "NA", "AS", "SA", "AF", "OC"] as const;
export type GeoCheckLocation = (typeof GeoCheckLocations)[number];
export interface Monitor { export interface Monitor {
id: string; id: string;
userId: string; userId: string;
@@ -62,9 +58,6 @@ export interface Monitor {
selectedDisks: string[]; selectedDisks: string[];
gameId?: string; gameId?: string;
group: string | null; group: string | null;
geoCheckEnabled?: boolean;
geoCheckLocations?: GeoCheckLocation[];
geoCheckInterval?: number;
recentChecks: CheckSnapshot[]; recentChecks: CheckSnapshot[];
createdAt: string; createdAt: string;
updatedAt: string; updatedAt: string;
@@ -119,10 +112,7 @@ export interface MonitorDetailsResponse {
} }
export interface PageSpeedDetailsResponse { export interface PageSpeedDetailsResponse {
monitorData: { monitor: MonitorWithChecks;
monitor: Monitor;
groupedChecks: PageSpeedGroupedCheck[];
};
monitorStats: MonitorStats | null; monitorStats: MonitorStats | null;
} }
-3
View File
@@ -20,9 +20,6 @@ const baseSchema = z.object({
.number({ message: "Threshold percentage is required" }) .number({ message: "Threshold percentage is required" })
.min(1, "Incident percentage must be at least 1") .min(1, "Incident percentage must be at least 1")
.max(100, "Incident percentage must be at most 100"), .max(100, "Incident percentage must be at most 100"),
geoCheckEnabled: z.boolean().optional(),
geoCheckLocations: z.array(z.enum(["EU", "NA", "AS", "SA", "AF", "OC"])).optional(),
geoCheckInterval: z.number().min(5, "Interval must be at least 5 minutes").optional(),
}); });
// HTTP monitor schema // HTTP monitor schema
+3 -32
View File
@@ -44,8 +44,7 @@
"addDemo": "Add demo monitors", "addDemo": "Add demo monitors",
"removeMonitors": "Remove monitors", "removeMonitors": "Remove monitors",
"sendTestEmail": "Send test email", "sendTestEmail": "Send test email",
"exportToJSON": "Export to JSON", "exportToJSON": "Export to JSON"
"importFromJSON": "Import from JSON"
}, },
"charts": { "charts": {
"labels": { "labels": {
@@ -431,31 +430,6 @@
}, },
"title": "Advanced settings" "title": "Advanced settings"
}, },
"geoChecks": {
"title": "Geo-distributed checks",
"description": "Run checks from multiple geographic locations to monitor global availability and performance.",
"option": {
"enabled": {
"label": "Enable geo-distributed checks"
},
"locations": {
"label": "Locations",
"placeholder": "Select locations",
"options": {
"EU": "Europe",
"NA": "North America",
"AS": "Asia",
"SA": "South America",
"AF": "Africa",
"OC": "Oceania"
}
},
"interval": {
"label": "Check interval (minutes)",
"helper": "Minimum 5 minutes between geo checks"
}
}
},
"frequency": { "frequency": {
"description": "How often do you want to check the status of this monitor?", "description": "How often do you want to check the status of this monitor?",
"option": { "option": {
@@ -1112,11 +1086,8 @@
} }
}, },
"exportMonitors": { "exportMonitors": {
"title": "Export monitors" "title": "Export monitors",
}, "description": "Export your monitors data as a JSON file for backup or transfer."
"importExportMonitors": {
"title": "Import / Export monitors",
"description": "Import or export your monitors data as a JSON file for backup or transfer."
}, },
"about": { "about": {
"title": "About", "title": "About",
+10 -12
View File
@@ -23,7 +23,6 @@ import {
parseMonitorTypeFilter, parseMonitorTypeFilter,
parseSortOrder, parseSortOrder,
requireTeamId, requireTeamId,
requireUserId,
} from "./controllerUtils.js"; } from "./controllerUtils.js";
import { AppError } from "@/utils/AppError.js"; import { AppError } from "@/utils/AppError.js";
import { IMonitorService } from "@/service/index.js"; import { IMonitorService } from "@/service/index.js";
@@ -173,23 +172,22 @@ class MonitorController {
} }
}; };
importMonitorsFromJSON = async (req: Request, res: Response, next: NextFunction) => { createBulkMonitors = async (req: Request, res: Response, next: NextFunction) => {
try { try {
const teamId = requireTeamId(req?.user?.teamId); const userId = req.user?.id;
const userId = requireUserId(req?.user?.id); if (!userId) {
throw new AppError({ message: "User ID is required", status: 400 });
const { monitors } = req.body;
if (!monitors || !Array.isArray(monitors)) {
throw new AppError({ message: "Invalid request: monitors array is required", status: 400 });
} }
const result = await this.monitorService.importMonitorsFromJSON({ teamId, userId, monitors }); const teamId = requireTeamId(req?.user?.teamId);
const data = req.body;
const monitors = await this.monitorService.createBulkMonitors(data, userId, teamId);
return res.status(200).json({ return res.status(200).json({
success: true, success: true,
msg: `Successfully imported ${result.imported} monitor(s)`, msg: "Bulk monitors created successfully",
data: result, data: monitors,
}); });
} catch (error) { } catch (error) {
next(error); next(error);
-34
View File
@@ -11,8 +11,6 @@ import type {
CheckMemoryInfo, CheckMemoryInfo,
CheckMetadata, CheckMetadata,
CheckNetworkInterfaceInfo, CheckNetworkInterfaceInfo,
GeoCheckResult,
GeoCheckTimings,
GotTimings, GotTimings,
ILighthouseAudit, ILighthouseAudit,
} from "@/types/check.js"; } from "@/types/check.js";
@@ -177,34 +175,6 @@ const auditsSchema = new Schema<CheckAudits>(
{ _id: false } { _id: false }
); );
const geoCheckTimingsSchema = new Schema<GeoCheckTimings>(
{
total: { type: Number, required: true },
dns: { type: Number },
tcp: { type: Number },
tls: { type: Number },
firstByte: { type: Number },
download: { type: Number },
},
{ _id: false }
);
const geoCheckResultSchema = new Schema<GeoCheckResult>(
{
continent: { type: String, required: true },
region: { type: String },
country: { type: String, required: true },
state: { type: String },
city: { type: String, required: true },
longitude: { type: Number, required: true },
latitude: { type: Number, required: true },
status: { type: Boolean, required: true },
statusCode: { type: Number, required: true },
timings: { type: geoCheckTimingsSchema, required: true },
},
{ _id: false }
);
const metadataSchema = new Schema<CheckMetadataDocument>( const metadataSchema = new Schema<CheckMetadataDocument>(
{ {
monitorId: { monitorId: {
@@ -311,10 +281,6 @@ const CheckSchema = new Schema<CheckDocument>(
type: auditsSchema, type: auditsSchema,
default: undefined, default: undefined,
}, },
geoResults: {
type: [geoCheckResultSchema],
default: undefined,
},
}, },
{ {
timestamps: true, timestamps: true,
+2 -15
View File
@@ -1,6 +1,6 @@
import { Schema, model, Types } from "mongoose"; import { Schema, model, Types, type UpdateQuery } from "mongoose";
import type { Monitor, MonitorMatchMethod, CheckSnapshot } from "@/types/monitor.js"; import type { Monitor, MonitorMatchMethod, CheckSnapshot } from "@/types/monitor.js";
import { MonitorTypes, MonitorStatuses, GeoCheckLocations } from "@/types/monitor.js"; import { MonitorTypes, MonitorStatuses } from "@/types/monitor.js";
type CheckSnapshotDocument = Omit<CheckSnapshot, "createdAt"> & { createdAt: Date }; type CheckSnapshotDocument = Omit<CheckSnapshot, "createdAt"> & { createdAt: Date };
@@ -169,19 +169,6 @@ const MonitorSchema = new Schema<MonitorDocument>(
return value && value.trim() ? value.trim() : null; return value && value.trim() ? value.trim() : null;
}, },
}, },
geoCheckEnabled: {
type: Boolean,
default: false,
},
geoCheckLocations: {
type: [String],
enum: GeoCheckLocations,
default: [],
},
geoCheckInterval: {
type: Number,
default: 300000,
},
recentChecks: { recentChecks: {
type: [checkSnapshotSchema], type: [checkSnapshotSchema],
default: [], default: [],
@@ -10,8 +10,6 @@ import type {
CheckMemoryInfo, CheckMemoryInfo,
CheckMetadata, CheckMetadata,
CheckNetworkInterfaceInfo, CheckNetworkInterfaceInfo,
GeoCheckResult,
GeoCheckTimings,
GotTimings, GotTimings,
MonitorType, MonitorType,
} from "@/types/index.js"; } from "@/types/index.js";
@@ -167,33 +165,6 @@ class MongoChecksRepository implements IChecksRepository {
}; };
}; };
const mapGeoTimings = (timings?: GeoCheckTimings): GeoCheckTimings => ({
total: timings?.total ?? 0,
dns: timings?.dns,
tcp: timings?.tcp,
tls: timings?.tls,
firstByte: timings?.firstByte,
download: timings?.download,
});
const mapGeoResults = (geoResults?: GeoCheckResult[]): GeoCheckResult[] | undefined => {
if (!geoResults?.length) {
return undefined;
}
return geoResults.map((result) => ({
continent: result.continent ?? "",
region: result.region,
country: result.country ?? "",
state: result.state,
city: result.city ?? "",
longitude: result.longitude ?? 0,
latitude: result.latitude ?? 0,
status: result.status ?? false,
statusCode: result.statusCode ?? 0,
timings: mapGeoTimings(result.timings),
}));
};
const mapMetadata = (metadata: CheckDocument["metadata"]): CheckMetadata => ({ const mapMetadata = (metadata: CheckDocument["metadata"]): CheckMetadata => ({
monitorId: toStringId(metadata.monitorId), monitorId: toStringId(metadata.monitorId),
teamId: toStringId(metadata.teamId), teamId: toStringId(metadata.teamId),
@@ -223,7 +194,6 @@ class MongoChecksRepository implements IChecksRepository {
seo: doc.seo, seo: doc.seo,
performance: doc.performance, performance: doc.performance,
audits: mapAudits(doc.audits), audits: mapAudits(doc.audits),
geoResults: mapGeoResults(doc.geoResults),
__v: doc.__v ?? 0, __v: doc.__v ?? 0,
createdAt: toDateString(doc.createdAt), createdAt: toDateString(doc.createdAt),
updatedAt: toDateString(doc.updatedAt), updatedAt: toDateString(doc.updatedAt),
@@ -408,7 +378,7 @@ class MongoChecksRepository implements IChecksRepository {
return this.findHardwareDateRangeChecks(monitorObjectId, startDate, endDate, dateString); return this.findHardwareDateRangeChecks(monitorObjectId, startDate, endDate, dateString);
} }
if (options?.type === "pagespeed") { if (options?.type === "pagespeed") {
return this.findPageSpeedDateRangeChecks(monitorObjectId, startDate, endDate, dateString); return this.findPageSpeedDateRangeChecks(monitorObjectId, startDate, endDate);
} }
return this.findUptimeDateRangeChecks(options?.type ?? "http", monitorObjectId, startDate, endDate, dateString); return this.findUptimeDateRangeChecks(options?.type ?? "http", monitorObjectId, startDate, endDate, dateString);
}; };
@@ -457,131 +427,85 @@ class MongoChecksRepository implements IChecksRepository {
endDate: Date, endDate: Date,
dateString: string dateString: string
) => { ) => {
// Match stage for primary checks (exclude geo checks) const matchStage = {
const primaryCheckMatchStage = {
"metadata.monitorId": monitorObjectId, "metadata.monitorId": monitorObjectId,
createdAt: { $gte: startDate, $lte: endDate }, createdAt: { $gte: startDate, $lte: endDate },
geoResults: { $exists: false },
}; };
const [result] = await CheckModel.aggregate([
// Match stage for geo checks only { $match: matchStage },
const geoCheckMatchStage = { { $sort: { createdAt: 1 } },
"metadata.monitorId": monitorObjectId, {
createdAt: { $gte: startDate, $lte: endDate }, $facet: {
geoResults: { $exists: true, $ne: null }, uptimePercentage: [
}; {
$group: {
// Run two separate aggregations - one for primary checks, one for geo checks _id: null,
// TODO, only do this if the monitor has geochecks enabled, otherwise we only need one aggregation upChecks: { $sum: { $cond: [{ $eq: ["$status", true] }, 1, 0] } },
const [primaryResult, geoResults] = await Promise.all([ totalChecks: { $sum: 1 },
CheckModel.aggregate([
{ $match: primaryCheckMatchStage },
{ $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" },
totalChecks: { $sum: 1 },
},
},
{ $sort: { _id: 1 } },
{ $project: { bucketDate: "$_id", avgResponseTime: 1, totalChecks: 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 } },
],
},
},
]),
CheckModel.aggregate([
{ $match: geoCheckMatchStage },
{ $sort: { createdAt: 1 } },
{ $unwind: "$geoResults" },
{
$group: {
_id: {
date: { $dateToString: { format: dateString, date: "$createdAt" } },
continent: "$geoResults.continent",
}, },
avgResponseTime: { $avg: "$geoResults.timings.total" }, {
totalChecks: { $sum: 1 }, $project: {
upChecks: { $sum: { $cond: [{ $eq: ["$geoResults.status", true] }, 1, 0] } }, _id: 0,
}, percentage: {
}, $cond: [{ $eq: ["$totalChecks", 0] }, 0, { $divide: ["$upChecks", "$totalChecks"] }],
{ },
$project: { },
_id: 0,
bucketDate: "$_id.date",
continent: "$_id.continent",
avgResponseTime: 1,
totalChecks: 1,
uptimePercentage: {
$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" },
totalChecks: { $sum: 1 },
},
},
{ $sort: { _id: 1 } },
{ $project: { bucketDate: "$_id", avgResponseTime: 1, totalChecks: 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 } },
],
}, },
{ $sort: { bucketDate: 1, continent: 1 } }, },
]),
]); ]);
const [result] = primaryResult;
const groupedGeoChecks = geoResults ?? [];
const uptimePercentage = result?.uptimePercentage?.[0]?.percentage ?? 0; const uptimePercentage = result?.uptimePercentage?.[0]?.percentage ?? 0;
const avgResponseTime = result?.groupedAvgResponseTime?.[0]?.avgResponseTime ?? 0; const avgResponseTime = result?.groupedAvgResponseTime?.[0]?.avgResponseTime ?? 0;
@@ -592,7 +516,6 @@ class MongoChecksRepository implements IChecksRepository {
groupedDownChecks: result?.groupedDownChecks ?? [], groupedDownChecks: result?.groupedDownChecks ?? [],
uptimePercentage, uptimePercentage,
avgResponseTime, avgResponseTime,
groupedGeoChecks,
}; };
}; };
@@ -649,50 +572,16 @@ class MongoChecksRepository implements IChecksRepository {
}; };
}; };
private findPageSpeedDateRangeChecks = async (monitorObjectId: mongoose.Types.ObjectId, startDate: Date, endDate: Date, dateString: string) => { private findPageSpeedDateRangeChecks = async (monitorObjectId: mongoose.Types.ObjectId, startDate: Date, endDate: Date) => {
const matchStage = { const matchStage = {
"metadata.monitorId": monitorObjectId, "metadata.monitorId": monitorObjectId,
createdAt: { $gte: startDate, $lte: endDate }, createdAt: { $gte: startDate, $lte: endDate },
}; };
const [result] = await CheckModel.aggregate([ const checks = await CheckModel.find(matchStage).sort({ createdAt: -1 }).limit(25).lean();
{ $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 { return {
monitorType: "pagespeed" as const, monitorType: "pagespeed" as const,
groupedChecks: result?.groupedChecks ?? [], checks: this.mapDocuments(checks),
}; };
}; };
@@ -17,7 +17,7 @@ export interface SummaryConfig {
export interface IMonitorsRepository { export interface IMonitorsRepository {
// create // create
create(monitor: Monitor, teamId: string, userId: string): Promise<Monitor | null>; create(monitor: Monitor, teamId: string, userId: string): Promise<Monitor | null>;
createMonitors(monitors: Monitor[]): Promise<Monitor[]>; createBulkMonitors(monitors: Monitor[]): Promise<Monitor[]>;
// single fetch // single fetch
findById(monitorId: string, teamId: string): Promise<Monitor>; findById(monitorId: string, teamId: string): Promise<Monitor>;
@@ -12,23 +12,13 @@ class MongoMonitorsRepository implements IMonitorsRepository {
return this.toEntity(saved); return this.toEntity(saved);
}; };
createMonitors = async (monitors: Monitor[]): Promise<Monitor[]> => { createBulkMonitors = async (monitors: Monitor[]): Promise<Monitor[]> => {
if (!monitors.length) { if (!monitors.length) {
return []; return [];
} }
const payload = monitors.map((monitor) => ({ ...monitor, notifications: undefined })); const payload = monitors.map((monitor) => ({ ...monitor, notifications: undefined }));
try { const inserted = await MonitorModel.insertMany(payload, { ordered: false });
const inserted = await MonitorModel.insertMany(payload, { ordered: false }); return this.mapDocuments(inserted);
return this.mapDocuments(inserted);
} catch (error: any) {
if (error.name === "MongoBulkWriteError" || error.name === "BulkWriteError") {
const insertedDocs = error.insertedDocs || [];
if (insertedDocs.length > 0) {
return this.mapDocuments(insertedDocs);
}
}
throw error;
}
}; };
findById = async (monitorId: string, teamId: string): Promise<Monitor> => { findById = async (monitorId: string, teamId: string): Promise<Monitor> => {
@@ -353,9 +343,6 @@ class MongoMonitorsRepository implements IMonitorsRepository {
selectedDisks: doc.selectedDisks ?? [], selectedDisks: doc.selectedDisks ?? [],
gameId: doc.gameId ?? undefined, gameId: doc.gameId ?? undefined,
group: doc.group ?? null, group: doc.group ?? null,
geoCheckEnabled: doc.geoCheckEnabled ?? false,
geoCheckLocations: doc.geoCheckLocations ?? [],
geoCheckInterval: doc.geoCheckInterval ?? 5,
recentChecks: (doc.recentChecks ?? []).map((check: any) => this.toCheckSnapshot(check)), recentChecks: (doc.recentChecks ?? []).map((check: any) => this.toCheckSnapshot(check)),
createdAt: toDateString(doc.createdAt), createdAt: toDateString(doc.createdAt),
updatedAt: toDateString(doc.updatedAt), updatedAt: toDateString(doc.updatedAt),
@@ -411,9 +398,6 @@ class MongoMonitorsRepository implements IMonitorsRepository {
selectedDisks: doc.selectedDisks ?? [], selectedDisks: doc.selectedDisks ?? [],
gameId: doc.gameId ?? undefined, gameId: doc.gameId ?? undefined,
group: doc.group ?? null, group: doc.group ?? null,
geoCheckEnabled: doc.geoCheckEnabled ?? false,
geoCheckLocations: doc.geoCheckLocations ?? [],
geoCheckInterval: doc.geoCheckInterval ?? 5,
recentChecks: (doc.recentChecks ?? []).map((check: any) => this.toCheckSnapshot(check)), recentChecks: (doc.recentChecks ?? []).map((check: any) => this.toCheckSnapshot(check)),
createdAt: toDateString(doc.createdAt), createdAt: toDateString(doc.createdAt),
updatedAt: toDateString(doc.updatedAt), updatedAt: toDateString(doc.updatedAt),
+1 -3
View File
@@ -26,7 +26,6 @@ class MonitorRoutes {
// Hardware routes // Hardware routes
this.router.get("/hardware/details/:monitorId", this.monitorController.getHardwareDetailsById); this.router.get("/hardware/details/:monitorId", this.monitorController.getHardwareDetailsById);
// PageSpeed routes // PageSpeed routes
this.router.get("/pagespeed/details/:monitorId", this.monitorController.getPageSpeedDetailsById); this.router.get("/pagespeed/details/:monitorId", this.monitorController.getPageSpeedDetailsById);
@@ -45,8 +44,7 @@ class MonitorRoutes {
// Other static routes // Other static routes
this.router.post("/demo", isAllowed(["admin", "superadmin"]), this.monitorController.addDemoMonitors); this.router.post("/demo", isAllowed(["admin", "superadmin"]), this.monitorController.addDemoMonitors);
this.router.get("/export/json", isAllowed(["admin", "superadmin"]), this.monitorController.exportMonitorsToJSON); this.router.get("/export/json", isAllowed(["admin", "superadmin"]), this.monitorController.exportMonitorsToJSON);
this.router.post("/import/json", isAllowed(["admin", "superadmin"]), this.monitorController.importMonitorsFromJSON); this.router.post("/bulk", isAllowed(["admin", "superadmin"]), upload.single("csvFile"), this.monitorController.createBulkMonitors);
this.router.post("/test-email", isAllowed(["admin", "superadmin"]), this.monitorController.sendTestEmail); this.router.post("/test-email", isAllowed(["admin", "superadmin"]), this.monitorController.sendTestEmail);
this.router.get("/games", this.monitorController.getAllGames); this.router.get("/games", this.monitorController.getAllGames);
+8 -46
View File
@@ -29,7 +29,7 @@ export interface IMonitorService {
// create // create
createMonitor(teamId: string, userId: string, body: Monitor): Promise<void>; createMonitor(teamId: string, userId: string, body: Monitor): Promise<void>;
createMonitors(monitors: Array<Monitor>, userId: string, teamId: string): Promise<Monitor[] | null>; createBulkMonitors(monitors: Array<Monitor>, userId: string, teamId: string): Promise<Monitor[] | null>;
addDemoMonitors(args: { userId: string; teamId: string }): Promise<Monitor[]>; addDemoMonitors(args: { userId: string; teamId: string }): Promise<Monitor[]>;
// read // read
@@ -72,7 +72,6 @@ export interface IMonitorService {
// other // other
sendTestEmail(args: { to: string }): Promise<string>; sendTestEmail(args: { to: string }): Promise<string>;
exportMonitorsToJSON(args: { teamId: string }): Promise<Monitor[]>; exportMonitorsToJSON(args: { teamId: string }): Promise<Monitor[]>;
importMonitorsFromJSON(args: { teamId: string; userId: string; monitors: any[] }): Promise<{ imported: number; errors: string[] }>;
} }
export class MonitorService implements IMonitorService { export class MonitorService implements IMonitorService {
@@ -158,10 +157,10 @@ export class MonitorService implements IMonitorService {
this.jobQueue.addJob(monitor.id, monitor); this.jobQueue.addJob(monitor.id, monitor);
}; };
createMonitors = async (monitors: Array<Monitor>, userId: string, teamId: string): Promise<Monitor[] | null> => { createBulkMonitors = async (monitors: Array<Monitor>, userId: string, teamId: string): Promise<Monitor[] | null> => {
const createdMonitors = await this.monitorsRepository.createMonitors(monitors); const createdMonitors = await this.monitorsRepository.createBulkMonitors(monitors);
if (!monitors || monitors.length === 0) { if (!monitors || monitors.length === 0) {
throw new AppError({ message: "Failed to create monitors", status: 500, service: SERVICE_NAME, method: "createMonitors" }); throw new AppError({ message: "Failed to create monitors", status: 500, service: SERVICE_NAME, method: "createBulkMonitors" });
} }
await Promise.all(createdMonitors.map((monitor) => this.jobQueue.addJob(monitor.id, monitor))); await Promise.all(createdMonitors.map((monitor) => this.jobQueue.addJob(monitor.id, monitor)));
@@ -185,7 +184,7 @@ export class MonitorService implements IMonitorService {
interval: 60000, interval: 60000,
}; };
}); });
const demoMonitors = await this.monitorsRepository.createMonitors(monitors); const demoMonitors = await this.monitorsRepository.createBulkMonitors(monitors);
await Promise.all(demoMonitors.map((monitor) => this.jobQueue.addJob(monitor.id, monitor))); await Promise.all(demoMonitors.map((monitor) => this.jobQueue.addJob(monitor.id, monitor)));
return demoMonitors; return demoMonitors;
@@ -308,9 +307,9 @@ export class MonitorService implements IMonitorService {
const monitorStats = await this.monitorStatsRepository.findByMonitorId(monitor.id); const monitorStats = await this.monitorStatsRepository.findByMonitorId(monitor.id);
return { return {
monitorData: { monitor: {
monitor, ...monitor,
groupedChecks: checksData.groupedChecks, checks: checksData.checks,
}, },
monitorStats, monitorStats,
}; };
@@ -487,41 +486,4 @@ export class MonitorService implements IMonitorService {
return monitors; return monitors;
}; };
importMonitorsFromJSON = async ({
teamId,
userId,
monitors,
}: {
teamId: string;
userId: string;
monitors: any[];
}): Promise<{ imported: number; errors: string[] }> => {
const errors: string[] = [];
const cleanedMonitors = monitors.map((monitor) => {
const cleanData = { ...monitor };
delete cleanData.id;
delete cleanData._id;
delete cleanData.createdAt;
delete cleanData.updatedAt;
delete cleanData.recentChecks;
// Monitors must belong to current team
cleanData.teamId = teamId;
return cleanData;
});
const createdMonitors = await this.createMonitors(cleanedMonitors, userId, teamId);
if (!createdMonitors || createdMonitors.length === 0) {
throw new AppError({
message: "Failed to import any monitors. Please check the file format and try again.",
service: SERVICE_NAME,
method: "importMonitorsFromJSON",
status: 400,
});
}
return { imported: createdMonitors.length, errors };
};
} }
@@ -97,7 +97,6 @@ class SuperSimpleQueue implements ISuperSimpleQueue {
this.scheduler.start(); this.scheduler.start();
this.scheduler.addTemplate("monitor-job", this.helper.getMonitorJob()); this.scheduler.addTemplate("monitor-job", this.helper.getMonitorJob());
this.scheduler.addTemplate("geo-check-job", this.helper.getGeoCheckJob());
this.scheduler.addTemplate("cleanup-orphaned", this.helper.getCleanupOrphanedJob()); this.scheduler.addTemplate("cleanup-orphaned", this.helper.getCleanupOrphanedJob());
const monitors = await this.monitorsRepository.findAll(); const monitors = await this.monitorsRepository.findAll();
if (!monitors) { if (!monitors) {
@@ -132,28 +131,14 @@ class SuperSimpleQueue implements ISuperSimpleQueue {
active: monitor.isActive, active: monitor.isActive,
data: monitor, data: monitor,
}); });
// Add geo check job if enabled
if (monitor.geoCheckEnabled && monitor.type === "http") {
this.scheduler.addJob({
id: `${monitorId}-geo`,
template: "geo-check-job",
repeat: monitor.geoCheckInterval,
active: monitor.isActive,
data: monitor,
});
}
}; };
deleteJob = async (monitor: any) => { deleteJob = async (monitor: any) => {
this.scheduler.removeJob(monitor.id); this.scheduler.removeJob(monitor.id);
this.scheduler.removeJob(`${monitor.id}-geo`);
}; };
pauseJob = async (monitor: any) => { pauseJob = async (monitor: any) => {
const result = await this.scheduler.pauseJob(monitor.id); const result = await this.scheduler.pauseJob(monitor.id);
// Also pause geo check job if it exists
await this.scheduler.pauseJob(`${monitor.id}-geo`);
if (result === false) { if (result === false) {
throw new Error("Failed to resume monitor"); throw new Error("Failed to resume monitor");
} }
@@ -166,8 +151,6 @@ class SuperSimpleQueue implements ISuperSimpleQueue {
resumeJob = async (monitor: any) => { resumeJob = async (monitor: any) => {
const result = await this.scheduler.resumeJob(monitor.id); const result = await this.scheduler.resumeJob(monitor.id);
// Also resume geo check job if it exists
await this.scheduler.resumeJob(`${monitor.id}-geo`);
if (result === false) { if (result === false) {
throw new Error("Failed to resume monitor"); throw new Error("Failed to resume monitor");
} }
@@ -180,29 +163,6 @@ class SuperSimpleQueue implements ISuperSimpleQueue {
updateJob = async (monitor: any) => { updateJob = async (monitor: any) => {
this.scheduler.updateJob(monitor.id, { repeat: monitor.interval, data: monitor }); this.scheduler.updateJob(monitor.id, { repeat: monitor.interval, data: monitor });
// Handle geo check job
const geoJobId = `${monitor.id}-geo`;
const geoJobExists = await this.scheduler.getJob(geoJobId);
if (monitor.geoCheckEnabled && monitor.type === "http") {
if (geoJobExists) {
// Update existing geo job
this.scheduler.updateJob(geoJobId, { repeat: monitor.geoCheckInterval, data: monitor, active: monitor.isActive });
} else {
// Add new geo job
this.scheduler.addJob({
id: geoJobId,
template: "geo-check-job",
repeat: monitor.geoCheckInterval,
active: monitor.isActive,
data: monitor,
});
}
} else if (geoJobExists) {
// Remove geo job if it exists but is no longer enabled
this.scheduler.removeJob(geoJobId);
}
}; };
shutdown = async () => { shutdown = async () => {
@@ -176,98 +176,6 @@ class SuperSimpleQueueHelper {
}; };
}; };
getGeoCheckJob = () => {
return async (monitor: Monitor) => {
try {
const monitorId = monitor.id;
const teamId = monitor.teamId;
if (!monitorId) {
throw new AppError({ message: "No monitor id", service: SERVICE_NAME, method: "getGeoCheckJob" });
}
// Safety checks
if (!monitor.geoCheckEnabled || monitor.type !== "http") {
this.logger.debug({
message: `Geo check skipped for monitor ${monitorId} - not enabled or not HTTP type`,
service: SERVICE_NAME,
method: "getGeoCheckJob",
});
return;
}
if (!monitor.geoCheckLocations || monitor.geoCheckLocations.length === 0) {
this.logger.warn({
message: `Geo check skipped for monitor ${monitorId} - no locations configured`,
service: SERVICE_NAME,
method: "getGeoCheckJob",
});
return;
}
// Check for maintenance window
const maintenanceWindowActive = await this.isInMaintenanceWindow(monitorId, teamId);
if (maintenanceWindowActive) {
this.logger.debug({
message: `Geo check skipped for monitor ${monitorId} - in maintenance window`,
service: SERVICE_NAME,
method: "getGeoCheckJob",
});
return;
}
this.logger.debug({
message: `Starting geo check for monitor ${monitorId}`,
service: SERVICE_NAME,
method: "getGeoCheckJob",
});
// TODO: Implement GlobalPing API integration
// Step 1: Create measurement via GlobalPing API
// const measurementId = await this.globalPingService.createMeasurement(
// monitor.url,
// monitor.geoCheckLocations
// );
// Step 2: Poll for results (blocks 2-30s, but doesn't affect primary monitor checks)
// const geoResults = await this.globalPingService.pollForResults(measurementId);
// Step 3: Create check document with only geo results
// const check = {
// metadata: {
// monitorId: monitor.id,
// teamId: monitor.teamId,
// type: monitor.type,
// },
// status: true,
// responseTime: 0,
// statusCode: 200,
// message: "Geo check",
// geoResults,
// ack: false,
// };
// Step 4: Save check
// await this.checksRepository.create([check]);
this.logger.info({
message: `Geo check completed for monitor ${monitorId}`,
service: SERVICE_NAME,
method: "getGeoCheckJob",
});
} catch (error: any) {
this.logger.error({
message: error.message,
service: SERVICE_NAME,
method: "getGeoCheckJob",
details: error,
stack: error.stack,
});
throw error;
}
};
};
getCleanupOrphanedJob = () => { getCleanupOrphanedJob = () => {
return async () => { return async () => {
try { try {
+1 -42
View File
@@ -90,28 +90,6 @@ export interface ILighthouseAudit {
numericUnit?: string; numericUnit?: string;
} }
export interface GeoCheckTimings {
total: number;
dns?: number;
tcp?: number;
tls?: number;
firstByte?: number;
download?: number;
}
export interface GeoCheckResult {
continent: string;
region?: string;
country: string;
state?: string;
city: string;
longitude: number;
latitude: number;
status: boolean;
statusCode: number;
timings: GeoCheckTimings;
}
export interface Check { export interface Check {
id: string; id: string;
metadata: CheckMetadata; metadata: CheckMetadata;
@@ -135,7 +113,6 @@ export interface Check {
seo?: number; seo?: number;
performance?: number; performance?: number;
audits?: CheckAudits; audits?: CheckAudits;
geoResults?: GeoCheckResult[];
__v: number; __v: number;
createdAt: string; createdAt: string;
updatedAt: string; updatedAt: string;
@@ -147,7 +124,7 @@ export interface ChecksQueryResult {
export interface PageSpeedChecksResult { export interface PageSpeedChecksResult {
monitorType: "pagespeed"; monitorType: "pagespeed";
groupedChecks: PageSpeedGroupedCheck[]; checks: Check[];
} }
export interface HardwareChecksResult { export interface HardwareChecksResult {
@@ -193,23 +170,6 @@ export interface GroupedCheck {
totalChecks: number; totalChecks: number;
} }
export interface PageSpeedGroupedCheck {
bucketDate: string;
performance: number;
accessibility: number;
bestPractices: number;
seo: number;
totalChecks: number;
}
export interface GroupedGeoCheck {
bucketDate: string;
continent: string;
avgResponseTime: number;
totalChecks: number;
uptimePercentage: number;
}
export interface UptimeChecksResult { export interface UptimeChecksResult {
monitorType: Exclude<MonitorType, "hardware" | "pagespeed">; monitorType: Exclude<MonitorType, "hardware" | "pagespeed">;
groupedChecks: GroupedCheck[]; groupedChecks: GroupedCheck[];
@@ -217,7 +177,6 @@ export interface UptimeChecksResult {
groupedDownChecks: GroupedCheck[]; groupedDownChecks: GroupedCheck[];
uptimePercentage: number; uptimePercentage: number;
avgResponseTime: number; avgResponseTime: number;
groupedGeoChecks?: GroupedGeoCheck[];
} }
export interface ChecksSummary { export interface ChecksSummary {
+2 -9
View File
@@ -7,9 +7,6 @@ export type MonitorType = (typeof MonitorTypes)[number];
export const MonitorStatuses = ["up", "down", "paused", "initializing", "maintenance", "breached"] as const; export const MonitorStatuses = ["up", "down", "paused", "initializing", "maintenance", "breached"] as const;
export type MonitorStatus = (typeof MonitorStatuses)[number]; export type MonitorStatus = (typeof MonitorStatuses)[number];
export const GeoCheckLocations = ["EU", "NA", "AS", "SA", "AF", "OC"] as const;
export type GeoCheckLocation = (typeof GeoCheckLocations)[number];
export type MonitorMatchMethod = "equal" | "include" | "regex" | ""; export type MonitorMatchMethod = "equal" | "include" | "regex" | "";
export interface Monitor { export interface Monitor {
@@ -46,9 +43,6 @@ export interface Monitor {
selectedDisks: string[]; selectedDisks: string[];
gameId?: string; gameId?: string;
group: string | null; group: string | null;
geoCheckEnabled?: boolean;
geoCheckLocations?: GeoCheckLocation[];
geoCheckInterval?: number;
recentChecks: CheckSnapshot[]; recentChecks: CheckSnapshot[];
createdAt: string; createdAt: string;
updatedAt: string; updatedAt: string;
@@ -131,9 +125,8 @@ export interface HardwareDetailsResult {
} }
export interface PageSpeedDetailsResult { export interface PageSpeedDetailsResult {
monitorData: { monitor: Monitor & {
monitor: Monitor; checks: import("./check.js").Check[];
groupedChecks: import("./check.js").PageSpeedGroupedCheck[];
}; };
monitorStats: import("./monitorStats.js").MonitorStats | null; monitorStats: import("./monitorStats.js").MonitorStats | null;
} }
-13
View File
@@ -1,6 +1,5 @@
import joi, { type CustomHelpers } from "joi"; import joi, { type CustomHelpers } from "joi";
import { type UserRole, UserRoles } from "@/types/user.js"; import { type UserRole, UserRoles } from "@/types/user.js";
import { GeoCheckLocations } from "@/types/monitor.js";
//**************************************** //****************************************
// Custom Validators // Custom Validators
@@ -173,12 +172,6 @@ const createMonitorBodyValidation = joi.object({
gameId: joi.string().allow(""), gameId: joi.string().allow(""),
selectedDisks: joi.array().items(joi.string()).optional(), selectedDisks: joi.array().items(joi.string()).optional(),
group: joi.string().max(50).trim().allow(null, "").optional(), group: joi.string().max(50).trim().allow(null, "").optional(),
geoCheckEnabled: joi.boolean().optional(),
geoCheckLocations: joi
.array()
.items(joi.string().valid(...GeoCheckLocations))
.optional(),
geoCheckInterval: joi.number().min(300000).optional(),
}); });
const createMonitorsBodyValidation = joi.array().items( const createMonitorsBodyValidation = joi.array().items(
@@ -210,12 +203,6 @@ const editMonitorBodyValidation = joi
gameId: joi.string().allow(""), gameId: joi.string().allow(""),
selectedDisks: joi.array().items(joi.string()).optional(), selectedDisks: joi.array().items(joi.string()).optional(),
group: joi.string().max(50).trim().allow(null, "").optional(), group: joi.string().max(50).trim().allow(null, "").optional(),
geoCheckEnabled: joi.boolean().optional(),
geoCheckLocations: joi
.array()
.items(joi.string().valid(...GeoCheckLocations))
.optional(),
geoCheckInterval: joi.number().min(5).optional(),
}) })
.options({ stripUnknown: true }); .options({ stripUnknown: true });