feat: global monitors

Author: izadoesdev

apps/dashboard/app/(main)/websites/[id]/pulse/_components/monitor-dialog.tsx

@@ -29,6 +29,7 @@ import {
 	TooltipContent,
 	TooltipTrigger,
 } from "@/components/ui/tooltip";
+import { useWebsite } from "@/hooks/use-websites";
 import { orpc } from "@/lib/orpc";
 
 const granularityOptions = [
@@ -71,6 +72,7 @@ export function MonitorDialog({
 }: MonitorDialogProps) {
 	const formRef = useRef<HTMLFormElement>(null);
 	const isEditing = !!schedule;
+	const { data: website } = useWebsite(websiteId);
 
 	const form = useForm<MonitorFormData>({
 		resolver: zodResolver(monitorFormSchema),
@@ -136,8 +138,19 @@ export function MonitorDialog({
 				});
 				toast.success("Monitor updated successfully");
 			} else {
+				if (!website?.domain) {
+					toast.error("Website domain not found");
+					return;
+				}
+				
+				const url = website.domain.startsWith("http")
+					? website.domain
+					: `https://${website.domain}`;
+
 				await createMutation.mutateAsync({
 					websiteId,
+					url,
+					name: website.name ?? undefined,
 					granularity: data.granularity,
 				});
 				toast.success("Monitor created successfully");

apps/dashboard/app/(main)/websites/[id]/pulse/page.tsx

@@ -5,6 +5,7 @@ import {
 	PauseIcon,
 	PencilIcon,
 	PlayIcon,
+	TrashIcon,
 } from "@phosphor-icons/react";
 import { useMutation, useQuery } from "@tanstack/react-query";
 import dayjs from "dayjs";
@@ -13,6 +14,16 @@ import { useParams } from "next/navigation";
 import { useMemo, useState } from "react";
 import { toast } from "sonner";
 import { EmptyState } from "@/components/empty-state";
+import {
+	AlertDialog,
+	AlertDialogAction,
+	AlertDialogCancel,
+	AlertDialogContent,
+	AlertDialogDescription,
+	AlertDialogFooter,
+	AlertDialogHeader,
+	AlertDialogTitle,
+} from "@/components/ui/alert-dialog";
 import { Badge } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
 import { useDateFilters } from "@/hooks/use-date-filters";
@@ -46,6 +57,7 @@ export default function PulsePage() {
 		granularity: string;
 	} | null>(null);
 	const [isRefreshing, setIsRefreshing] = useState(false);
+	const [isDeleteDialogOpen, setIsDeleteDialogOpen] = useState(false);
 
 	const {
 		data: schedule,
@@ -63,6 +75,9 @@ export default function PulsePage() {
 	const resumeMutation = useMutation({
 		...orpc.uptime.resumeSchedule.mutationOptions(),
 	});
+	const deleteMutation = useMutation({
+		...orpc.uptime.deleteSchedule.mutationOptions(),
+	});
 
 	const [isPausing, setIsPausing] = useState(false);
 	const hasMonitor = !!schedule;
@@ -173,6 +188,23 @@ export default function PulsePage() {
 		await refetchSchedule();
 	};
 
+	const handleDeleteMonitor = async () => {
+		if (!schedule) {
+			return;
+		}
+
+		try {
+			await deleteMutation.mutateAsync({ scheduleId: schedule.id });
+			toast.success("Monitor deleted successfully");
+			await refetchSchedule();
+			setIsDeleteDialogOpen(false);
+		} catch (error) {
+			const errorMessage =
+				error instanceof Error ? error.message : "Failed to delete monitor";
+			toast.error(errorMessage);
+		}
+	};
+
 	const handleRefresh = async () => {
 		setIsRefreshing(true);
 		try {
@@ -267,6 +299,15 @@ export default function PulsePage() {
 				<PencilIcon size={16} weight="duotone" />
 				Configure
 			</Button>
+			<Button
+				disabled={deleteMutation.isPending}
+				onClick={() => setIsDeleteDialogOpen(true)}
+				size="sm"
+				variant="outline"
+			>
+				<TrashIcon size={16} weight="duotone" />
+				Delete
+			</Button>
 		</>
 	) : undefined;
 
@@ -337,6 +378,32 @@ export default function PulsePage() {
 				schedule={editingSchedule}
 				websiteId={websiteId as string}
 			/>
+
+			<AlertDialog
+				onOpenChange={setIsDeleteDialogOpen}
+				open={isDeleteDialogOpen}
+			>
+				<AlertDialogContent>
+					<AlertDialogHeader>
+						<AlertDialogTitle>Delete Monitor</AlertDialogTitle>
+						<AlertDialogDescription>
+							Are you sure you want to delete this uptime monitor? This action
+							cannot be undone and all historical data will be preserved but no
+							new checks will be performed.
+						</AlertDialogDescription>
+					</AlertDialogHeader>
+					<AlertDialogFooter>
+						<AlertDialogCancel>Cancel</AlertDialogCancel>
+						<AlertDialogAction
+							className="bg-destructive text-destructive-foreground hover:bg-destructive/90"
+							disabled={deleteMutation.isPending}
+							onClick={handleDeleteMonitor}
+						>
+							{deleteMutation.isPending ? "Deleting..." : "Delete Monitor"}
+						</AlertDialogAction>
+					</AlertDialogFooter>
+				</AlertDialogContent>
+			</AlertDialog>
 		</div>
 	);
 }

apps/uptime/src/actions.ts

@@ -1,7 +1,6 @@
 import { createHash } from "node:crypto";
 import { connect } from "node:tls";
-// import { chQuery } from "@databuddy/db";
-import { websiteService } from "@databuddy/services/websites";
+import { db, eq, uptimeSchedules } from "@databuddy/db";
 import { captureError, record } from "./lib/tracing";
 import type { ActionResult, UptimeData } from "./types";
 import { MonitorStatus } from "./types";
@@ -41,20 +40,29 @@ type FetchFailure = {
 // 	streak: number;
 // };
 
-export function lookupWebsite(
+export function lookupSchedule(
 	id: string
-): Promise<ActionResult<{ id: string; domain: string }>> {
-	return record("uptime.lookup_website", async () => {
+): Promise<ActionResult<{ id: string; url: string; websiteId: string | null }>> {
+	return record("uptime.lookup_schedule", async () => {
 		try {
-			const site = await websiteService.getById(id);
+			const schedule = await db.query.uptimeSchedules.findFirst({
+				where: eq(uptimeSchedules.id, id),
+			});
 
-			if (!site) {
-				return { success: false, error: `Website ${id} not found` };
+			if (!schedule) {
+				return { success: false, error: `Schedule ${id} not found` };
 			}
 
-			return { success: true, data: { id: site.id, domain: site.domain } };
+			return {
+				success: true,
+				data: {
+					id: schedule.id,
+					url: schedule.url,
+					websiteId: schedule.websiteId,
+				},
+			};
 		} catch (error) {
-			console.error("Database lookup failed:", error);
+			console.error("Schedule lookup failed:", error);
 			return {
 				success: false,
 				error: error instanceof Error ? error.message : "Database error",

apps/uptime/src/index.ts

@@ -1,6 +1,7 @@
 import { Receiver } from "@upstash/qstash";
 import Elysia from "elysia";
-import { checkUptime, lookupWebsite } from "./actions";
+import { z } from "zod";
+import { checkUptime, lookupSchedule } from "./actions";
 import { sendUptimeEvent } from "./lib/producer";
 import {
 	captureError,
@@ -84,13 +85,23 @@ const app = new Elysia()
 	.get("/health", () => ({ status: "ok" }))
 	.post("/", async ({ headers, body }) => {
 		try {
-			const siteId = headers["x-website-id"];
-			const signature = headers["upstash-signature"];
+			const headerSchema = z.object({
+				"upstash-signature": z.string(),
+				"x-schedule-id": z.string(),
+				"x-max-retries": z.string().optional(),
+			});
+
+			const parsed = headerSchema.safeParse(headers);
+			if (!parsed.success) {
+				return new Response("Missing required headers", { status: 400 });
+			}
+
+			const { "upstash-signature": signature, "x-schedule-id": scheduleId } =
+				parsed.data;
 
 			const isValid = await receiver.verify({
 				// @ts-expect-error, this doesn't require type assertions
 				body,
-				// @ts-expect-error, these don't require type assertions
 				signature,
 				url: "https://uptime.databuddy.cc",
 			});
@@ -99,39 +110,31 @@ const app = new Elysia()
 				return new Response("Invalid signature", { status: 401 });
 			}
 
-			if (!siteId || typeof siteId !== "string") {
-				return new Response("Website ID is required", { status: 400 });
+			const schedule = await lookupSchedule(scheduleId);
+			if (!schedule.success) {
+				captureError(schedule.error);
+				return new Response("Schedule not found", { status: 404 });
 			}
 
-			const site = await lookupWebsite(siteId);
+			const monitorId = schedule.data.websiteId || scheduleId;
 
-			if (!site.success) {
-				captureError(site.error);
-				return new Response("Website not found", { status: 404 });
-			}
-
-			const maxRetriesHeader = headers["x-max-retries"];
-			const maxRetries = maxRetriesHeader
-				? Number.parseInt(maxRetriesHeader as string, 10)
+			const maxRetries = parsed.data["x-max-retries"]
+				? Number.parseInt(parsed.data["x-max-retries"], 10)
 				: 3;
 
-			const result = await checkUptime(siteId, site.data.domain, 1, maxRetries);
+			const result = await checkUptime(monitorId, schedule.data.url, 1, maxRetries);
 
 			if (!result.success) {
 				console.error("Uptime check failed:", result.error);
 				captureError(result.error);
 				return new Response("Failed to check uptime", { status: 500 });
 			}
 
-			const { data } = result;
-
-			// Send event to Redpanda for ingestion via Vector
 			try {
-				await sendUptimeEvent(data, data.site_id);
+				await sendUptimeEvent(result.data, monitorId);
 			} catch (error) {
-				console.error("Failed to send uptime event to Redpanda:", error);
+				console.error("Failed to send uptime event:", error);
 				captureError(error);
-				// continue execution even if redpanda send fails
 			}
 
 			return new Response("Uptime check complete", { status: 200 });

packages/db/src/drizzle/schema.ts

@@ -782,7 +782,10 @@ export const uptimeSchedules = pgTable(
 	"uptime_schedules",
 	{
 		id: text().primaryKey().notNull(),
-		websiteId: text("website_id").notNull(),
+		websiteId: text("website_id"),
+		userId: text("user_id").notNull(),
+		url: text().notNull(),
+		name: text(),
 		granularity: text("granularity").notNull(),
 		cron: text().notNull(),
 		isPaused: boolean("is_paused").default(false).notNull(),
@@ -794,12 +797,27 @@ export const uptimeSchedules = pgTable(
 			"btree",
 			table.websiteId.asc().nullsLast().op("text_ops")
 		),
+		index("uptime_schedules_user_id_idx").using(
+			"btree",
+			table.userId.asc().nullsLast().op("text_ops")
+		),
+		index("uptime_schedules_url_idx").using(
+			"btree",
+			table.url.asc().nullsLast().op("text_ops")
+		),
 		foreignKey({
 			columns: [table.websiteId],
 			foreignColumns: [websites.id],
 			name: "uptime_schedules_website_id_fkey",
 		})
 			.onUpdate("cascade")
 			.onDelete("cascade"),
+		foreignKey({
+			columns: [table.userId],
+			foreignColumns: [user.id],
+			name: "uptime_schedules_user_id_fkey",
+		})
+			.onUpdate("cascade")
+			.onDelete("cascade"),
 	]
 );