Uptime Monitoring: Track Availability

Why Uptime Monitoring Matters

Your application can have zero code errors and still be down. DNS issues, SSL certificate expiration, infrastructure failures, deployment mistakes, and resource exhaustion can all take your service offline without triggering a single application error.

Uptime monitoring checks your service from the outside, simulating what your users experience. If your service is not responding, you want to know before your users do.

How Uptime Monitoring Works

Uptime monitoring is conceptually simple:

1. A monitoring service sends HTTP requests to your endpoints at regular intervals
2. It checks the response status code, response time, and optionally the response body
3. If the check fails, it retries from a different location to avoid false positives
4. If the check still fails, it triggers an alert

Setting Up Uptime Monitoring

Step 1: Identify Critical Endpoints

Do not monitor every URL. Focus on endpoints that indicate service health:

• Homepage or landing page: Basic availability check
• API health endpoint: Checks that the backend is running
• Authentication endpoint: Verifies the auth system is working
• Critical API endpoints: Key endpoints that drive core functionality

A good health check endpoint verifies dependencies too:

# FastAPI example
@app.get("/health")
async def health_check():
    checks = {}

    # Check database
    try:
        await db.execute("SELECT 1")
        checks["database"] = "ok"
    except Exception:
        checks["database"] = "error"

    # Check cache
    try:
        await redis.ping()
        checks["cache"] = "ok"
    except Exception:
        checks["cache"] = "error"

    status = "ok" if all(v == "ok" for v in checks.values()) else "degraded"
    status_code = 200 if status == "ok" else 503

    return JSONResponse(
        content={"status": status, "checks": checks},
        status_code=status_code,
    )

Step 2: Configure Monitors

In Bugsly (or your monitoring tool), set up monitors for each endpoint:

• URL: https://api.yourapp.com/health
• Method: GET
• Interval: Every 1-5 minutes
• Timeout: 10 seconds
• Expected status: 200
• Regions: Check from multiple geographic locations

Step 3: Set Up Alerting

Configure alerts that are actionable but not noisy:

• Alert after: 2-3 consecutive failures (avoids false positives from transient network issues)
• Alert channels: Slack for the team, PagerDuty/OpsGenie for on-call
• Recovery notification: Alert when the service comes back up
• Escalation: If not acknowledged in 15 minutes, escalate to the next on-call

Advanced Checks

SSL Certificate Monitoring

SSL certificate expiration is one of the most preventable causes of downtime. Monitor certificates and alert 30 days before expiration:

Monitor: SSL Certificate - api.yourapp.com
Alert when: Certificate expires within 30 days

Response Time Monitoring

Even if your service is technically "up," slow responses degrade user experience. Set thresholds:

• Warning: Response time > 2 seconds
• Critical: Response time > 5 seconds

Content Verification

Check that the response contains expected content, not just a 200 status:

Expected response body contains: "status":"ok"

This catches cases where your load balancer returns a 200 but your application is actually serving an error page.

Status Pages

A public status page builds trust with users by showing service availability. When an outage occurs, users can check the status page instead of flooding your support team.

Key components of a good status page:

• Current status of each service component
• Uptime percentage over the last 90 days
• Incident history with root cause analysis
• Scheduled maintenance announcements

Uptime Monitoring and Error Tracking Together

Uptime monitoring and error tracking complement each other:

• Error tracking catches bugs in your code
• Uptime monitoring catches infrastructure and availability issues

When your uptime monitor triggers an alert, check your error tracker for a spike in errors that correlates with the downtime. Together, they give you a complete picture of your application's health.

Bugsly provides both error tracking and uptime monitoring in a single platform, so you can correlate downtime events with error spikes and get AI-powered analysis of what went wrong.