Monitoring Rallly with Vigilmon: Root Path Check, tRPC API Endpoint, SSL Alerts & Uptime Monitoring

Rallly is a self-hosted group scheduling tool — a Doodle alternative — that lets teams coordinate meeting times without depending on third-party calendar services. When Rallly goes down during an active scheduling round, participants can't submit their availability, organizers can't see responses, and meeting coordination stalls entirely. Because Rallly is often used at a specific moment — "everyone fill out this poll by Friday" — downtime during that window has a real impact even if total uptime is excellent. Vigilmon watches Rallly's web UI, tRPC API endpoint, and SSL certificate so you know about failures before your participants encounter them.

What You'll Build

• An HTTP monitor for Rallly's root path (200 response = app is running)
• An HTTP monitor for the /api/trpc/whoami endpoint (JSON response = API layer alive)
• An SSL certificate monitor for your Rallly domain
• An alerting setup for a scheduling platform where timing matters

Prerequisites

• A running Rallly instance with a public or network-reachable domain (e.g., https://rallly.example.com)
• HTTPS configured with a valid certificate
• A free account at vigilmon.online

Step 1: Understand Rallly's Health Signals

Rallly is a Next.js application. It exposes two external health signals you can monitor:

Root path (/): Returns HTTP 200 with the Rallly home or sign-in page. This confirms the Next.js server is running, the web server is forwarding requests, and the application is serving pages.

tRPC whoami endpoint (/api/trpc/whoami): Returns JSON — for an unauthenticated visitor, this returns the anonymous user context. This endpoint goes through the full Next.js API route stack, including database connectivity:

curl https://rallly.example.com/api/trpc/whoami

A healthy Rallly returns a JSON response. This is your API-layer liveness check — it confirms the tRPC routing layer, Next.js API routes, and database connection are all functioning.

Step 2: Create a Vigilmon Monitor for the Root Path

1. Log in to Vigilmon → Add Monitor → HTTP.
2. URL: https://rallly.example.com/.
3. Check interval: 60 seconds.
4. Response timeout: 10 seconds.
5. Expected status: 200.
6. Keyword: Rallly.
7. Label: Rallly Web UI.
8. Click Save.

This monitor catches:

• Next.js server crashes or restarts
• Container or VM failures
• Web server (nginx, Caddy) misconfigurations that break request forwarding
• Build failures after upgrades that leave Rallly in a broken state

A 60-second polling interval means you're alerted within a minute of the application going down — in time to investigate before a scheduling round closes.

Step 3: Create a Monitor for the tRPC API Endpoint

1. Add Monitor → HTTP.
2. URL: https://rallly.example.com/api/trpc/whoami.
3. Check interval: 2 minutes.
4. Response timeout: 10 seconds.
5. Expected status: 200.
6. Keyword: user (the response includes a user object regardless of auth state).
7. Label: Rallly tRPC API.
8. Click Save.

This monitor validates the full API stack independently of whether the HTML UI is loading. It's particularly useful because:

• Next.js can serve cached/static pages even when the API layer is broken
• tRPC route failures would prevent participants from submitting availability, even if the page renders
• Database connectivity is validated through the API layer on every check

If this monitor fires while the root path monitor stays green, the problem is in Rallly's API backend or database — not the web server layer.

Step 4: Monitor SSL Certificates

Rallly polls are shared as links — via email, Slack, or calendar invitations. If the SSL certificate expires:

• Every participant who clicks the poll link sees a browser certificate warning
• Most participants will not click through a certificate error for a scheduling tool they're not familiar with
• The organizer's poll responses drop to zero with no explanation

1. Add Monitor → SSL Certificate.
2. Domain: rallly.example.com.
3. Alert when expiry is within: 30 days.
4. Alert again: 14 days, 7 days, 3 days, 1 day.
5. Click Save.

If you use Let's Encrypt auto-renewal (certbot, Caddy, or Traefik), a 30-day warning means the renewal process has silently failed. The 14-day and 7-day follow-up alerts add urgency without requiring you to act immediately on the first warning.

Step 5: Configure Alerting

In Vigilmon under Settings → Notifications, configure your alert channels:

| Monitor | Trigger | Action | |---|---|---| | Web UI | Non-200 or keyword missing | Check Next.js process; inspect container/service logs | | tRPC API | Non-200 or user missing | Check database connectivity; restart Rallly if DB is up | | SSL Certificate | < 30 days to expiry | Renew immediately; check ACME renewal automation |

Alert after: 2 failures for HTTP monitors (to avoid false positives from momentary network blips). 1 failure for SSL certificate alerts.

Timing awareness: Rallly is used most heavily when a poll is active and closing. Set up a calendar reminder to manually verify availability after any scheduled Rallly maintenance — don't rely solely on reactive monitoring when participants are actively filling in a poll.

Common Rallly Failure Modes and What Vigilmon Catches

| Scenario | Vigilmon monitor | |---|---| | Next.js process crash | Root path returns 502/503; alert within 60 s | | Database connection failure | tRPC API returns error JSON; API monitor fires | | Container OOM killed | Root path unreachable; alert within 60 s | | Reverse proxy misconfiguration | Root path monitor fires; API monitor follows | | SSL certificate expires | SSL monitor alerts at 30-day threshold; participant browsers show error | | Rallly upgrade breaks routing | tRPC API returns 404 or 500; API monitor fires | | Email service failure | Web UI and API stay up; poll invitations stop sending | | Database migration failure after upgrade | tRPC API returns errors; API monitor catches it | | Disk full | Rallly may fail to write responses; database errors surface in API | | DNS misconfiguration | All HTTP and SSL monitors fire simultaneously |

Rallly downtime during an active scheduling round is particularly impactful because polls have deadlines — every hour of downtime during the response window is hours of lost participation you can't recover. Vigilmon monitors Rallly's web UI and tRPC API with 60-second checks and adds 30-day SSL certificate alerts, giving you enough lead time to fix issues before participants encounter them.

Start monitoring Rallly in under 5 minutes — register free at vigilmon.online.