Skip to content

Comprehensive Monitoring Setup Guide

Overview

This guide provides a complete monitoring strategy for your production MkDocs Material website hosted on Netlify. We'll cover everything from basic uptime monitoring to advanced user experience tracking, with both free and premium solutions.

1. Monitoring Strategy Overview

Core Monitoring Pillars

  1. Availability Monitoring - Is your site up and accessible?
  2. Performance Monitoring - How fast does your site load?
  3. User Experience Monitoring - How do real users experience your site?
  4. Error Monitoring - What's breaking and why?
  5. Security Monitoring - Are there security issues or vulnerabilities?
  6. Infrastructure Monitoring - How is your hosting platform performing?

Monitoring Tiers

  • Tier 1 (Essential): Free tools for basic monitoring

Dashboard Setup

Creating comprehensive monitoring dashboards for your MkDocs site:

Core Dashboard Components

  1. Uptime Status Dashboard
  2. Site availability percentage
  3. Response time trends
  4. Geographic availability map

  5. Alert status indicators

  6. Performance Dashboard

  7. Page load times
  8. Core Web Vitals metrics
  9. Lighthouse scores over time

  10. Resource loading performance

  11. User Experience Dashboard

  12. User journey analytics
  13. Error rate tracking
  14. Geographic performance distribution

  15. Device/browser performance breakdown

  16. Infrastructure Dashboard

  17. Netlify build status
  18. Deploy frequency and success rates
  19. CDN performance metrics
  20. Domain and SSL certificate status

Dashboard Tools

  • Free Options: Google Analytics, UptimeRobot, StatusCake
  • Premium Options: DataDog, New Relic, Pingdom
  • Custom Solutions: Grafana with Prometheus
  • Tier 2 (Enhanced): Low-cost premium features for better insights
  • Tier 3 (Advanced): Comprehensive monitoring for mission-critical sites

2. Uptime Monitoring

Free Solutions

Best for: Basic uptime monitoring with generous free tier

Setup Steps: 1. Sign up at uptimerobot.com 2. Add your website: https://www.albrittonanalytics.com 3. Configure monitoring interval: 5 minutes (free tier) 4. Set up alert contacts (email, SMS) 5. Create a public status page

Configuration: 

Monitor Type: HTTP(s)
URL: https://www.albrittonanalytics.com
Monitoring Interval: 5 minutes
Alert Contacts: your-email@domain.com
Keyword Monitoring: "Albritton Analytics" (optional)

StatusCake

Best for: More monitoring types with free tier

Setup Steps: 1. Create account at statuscake.com 2. Add website monitoring 3. Configure SSL monitoring 4. Set up domain expiry monitoring

Free Tier Features: - 10 uptime monitors - 5-minute checks - Email alerts - Basic status pages

Premium Upgrades

Pingdom ($14.95/month)

  • 1-minute monitoring intervals
  • Global monitoring locations
  • Advanced alerting
  • Performance monitoring
  • Transaction monitoring

3. Performance Monitoring

Core Web Vitals Setup

Google Analytics 4 + Core Web Vitals

Setup Steps:

  1. Enable GA4 Enhanced Measurement: 

    // Add to your site's head section
gtag('config', 'GA_MEASUREMENT_ID', {
  custom_map: {
    'custom_parameter_cwv': 'cwv_metric'
  }
});

  2. Core Web Vitals Tracking Script: 

    // Add this script to track Core Web Vitals
import {getCLS, getFID, getFCP, getLCP, getTTFB} from 'web-vitals';

function sendToGA4(metric) {
  gtag('event', metric.name, {
    event_category: 'Web Vitals',
    event_label: metric.id,
    value: Math.round(metric.value),
    non_interaction: true,
  });
}

getCLS(sendToGA4);
getFID(sendToGA4);
getFCP(sendToGA4);
getLCP(sendToGA4);
getTTFB(sendToGA4);

Google PageSpeed Insights API

Automated Monitoring Script: 

import requests
import json
from datetime import datetime

def check_pagespeed(url, api_key):
    api_url = f"https://www.googleapis.com/pagespeedonline/v5/runPagespeed"
    params = {
        'url': url,
        'key': api_key,
        'category': ['PERFORMANCE', 'ACCESSIBILITY', 'BEST_PRACTICES', 'SEO'],
        'strategy': 'MOBILE'
    }

    response = requests.get(api_url, params=params)
    return response.json()

# Run daily via cron job
url = "https://www.albrittonanalytics.com"
result = check_pagespeed(url, "YOUR_API_KEY")

Performance Monitoring Tools

DebugBear (Premium - $29/month)

Features: - Real User Monitoring (RUM) - Core Web Vitals tracking - Performance budgets - CI/CD integration

Setup: 

// Add DebugBear RUM script
<script src="https://cdn.debugbear.com/debugbear.js"
        data-site-id="YOUR_SITE_ID"></script>

GTmetrix (Free + Premium)

Free Features: - Monthly performance reports - Core Web Vitals monitoring - Performance history

4. Analytics Setup

Google Analytics 4 Configuration

Enhanced E-commerce Setup

// Enhanced e-commerce for blog engagement
gtag('config', 'GA_MEASUREMENT_ID', {
  custom_map: {
    'custom_parameter_1': 'blog_category',
    'custom_parameter_2': 'reading_time'
  }
});

// Track blog post engagement
gtag('event', 'blog_engagement', {
  blog_category: 'documentation',
  reading_time: 5,
  engagement_time_msec: 30000
});

Custom Events for MkDocs

// Track search usage
document.addEventListener('DOMContentLoaded', function() {
  const searchInput = document.querySelector('[data-md-component="search-query"]');
  if (searchInput) {
    searchInput.addEventListener('input', function() {
      gtag('event', 'search', {
        event_category: 'Site Search',
        event_label: this.value
      });
    });
  }
});

// Track navigation
document.addEventListener('click', function(e) {
  if (e.target.matches('[data-md-component="navigation"] a')) {
    gtag('event', 'navigation_click', {
      event_category: 'Navigation',
      event_label: e.target.href
    });
  }
});

Privacy-Friendly Alternatives

Plausible Analytics ($9/month)

Benefits: - GDPR compliant - No cookies - Lightweight (< 1KB)

Setup: 

<script defer data-domain="albrittonanalytics.com"
        src="https://plausible.io/js/plausible.js"></script>

5. Error Monitoring

JavaScript Error Tracking

Sentry (Free Tier: 5,000 errors/month)

Setup Steps:

  1. Install Sentry: 

    import * as Sentry from "@sentry/browser";

Sentry.init({
  dsn: "YOUR_SENTRY_DSN",
  environment: "production",
  tracesSampleRate: 0.1,
});

  2. Custom Error Tracking: 

    // Track custom errors
window.addEventListener('error', function(e) {
  Sentry.captureException(e.error);
});

// Track unhandled promise rejections
window.addEventListener('unhandledrejection', function(e) {
  Sentry.captureException(e.reason);
});

Rollbar (Free Tier: 5,000 occurrences/month)

Setup: 

var _rollbarConfig = {
    accessToken: "YOUR_ACCESS_TOKEN",
    captureUncaught: true,
    captureUnhandledRejections: true,
    payload: {
        environment: "production"
    }
};

Form Error Monitoring

Netlify Forms Monitoring

// Track form submission errors
document.addEventListener('submit', function(e) {
  if (e.target.matches('[data-netlify="true"]')) {
    fetch(e.target.action, {
      method: 'POST',
      body: new FormData(e.target)
    }).catch(error => {
      // Log to error monitoring service
      Sentry.captureException(error);

      // Track in GA4
      gtag('event', 'form_error', {
        event_category: 'Form',
        event_label: 'submission_failed'
      });
    });
  }
});

6. Security Monitoring

SSL Certificate Monitoring

SSL Labs API Monitoring

import requests
import smtplib
from datetime import datetime, timedelta

def check_ssl_grade(domain):
    api_url = f"https://api.ssllabs.com/api/v3/analyze"
    params = {
        'host': domain,
        'all': 'done',
        'fromCache': 'on'
    }

    response = requests.get(api_url, params=params)
    data = response.json()

    if data['status'] == 'READY':
        grade = data['endpoints'][0]['grade']
        return grade
    return None

# Monitor SSL grade
domain = "www.albrittonanalytics.com"
grade = check_ssl_grade(domain)

Let's Encrypt Certificate Expiry

#!/bin/bash
# SSL certificate expiry check script
DOMAIN="www.albrittonanalytics.com"
EXPIRY_DATE=$(echo | openssl s_client -servername $DOMAIN -connect $DOMAIN:443 2>/dev/null | openssl x509 -noout -dates | grep notAfter | cut -d= -f2)
EXPIRY_EPOCH=$(date -d "$EXPIRY_DATE" +%s)
CURRENT_EPOCH=$(date +%s)
DAYS_UNTIL_EXPIRY=$(( ($EXPIRY_EPOCH - $CURRENT_EPOCH) / 86400 ))

if [ $DAYS_UNTIL_EXPIRY -lt 30 ]; then
    echo "WARNING: SSL certificate expires in $DAYS_UNTIL_EXPIRY days"
    # Send alert
fi

Security Headers Monitoring

SecurityHeaders.com API

import requests

def check_security_headers(url):
    api_url = f"https://securityheaders.com/?q={url}&hide=on&followRedirects=on"
    headers = {'User-Agent': 'Security Monitor Bot'}

    response = requests.get(api_url, headers=headers)
    # Parse response for security grade
    return response.text

# Schedule daily checks
check_security_headers("https://www.albrittonanalytics.com")

7. Build and Deployment Monitoring

Netlify Build Monitoring

Webhook Setup for Build Notifications

// Netlify webhook handler (can be deployed as Netlify function)
exports.handler = async (event, context) => {
  const payload = JSON.parse(event.body);

  if (payload.state === 'error') {
    // Send alert to Slack/Discord/Email
    await sendBuildAlert({
      status: 'failed',
      site: payload.name,
      deploy_url: payload.deploy_ssl_url,
      error_message: payload.error_message
    });
  }

  return {
    statusCode: 200,
    body: JSON.stringify({ message: 'Webhook processed' })
  };
};

GitHub Actions for Build Monitoring

# .github/workflows/build-monitor.yml
name: Build Monitor
on:
  schedule:
    - cron: '0 */6 * * *'  # Every 6 hours

jobs:
  check-build:
    runs-on: ubuntu-latest
    steps:
      - name: Check Netlify Site Status
        run: |
          curl -f https://api.netlify.com/api/v1/sites/${{ secrets.NETLIFY_SITE_ID }} \
               -H "Authorization: Bearer ${{ secrets.NETLIFY_ACCESS_TOKEN }}"

8. Infrastructure Monitoring

Netlify Status Monitoring

Automated Status Checking

import requests
import json

def check_netlify_status():
    # Check Netlify status page
    status_url = "https://netlifystatus.com/api/v2/status.json"
    response = requests.get(status_url)
    status = response.json()

    if status['status']['indicator'] != 'none':
        return f"Netlify issues detected: {status['status']['description']}"

    return "All systems operational"

# Check CDN performance
def check_cdn_performance():
    test_urls = [
        "https://www.albrittonanalytics.com",
        "https://cdn.jsdelivr.net/npm/test-file.js",  # Test CDN
    ]

    results = {}
    for url in test_urls:
        start_time = time.time()
        response = requests.get(url)
        end_time = time.time()

        results[url] = {
            'status_code': response.status_code,
            'response_time': end_time - start_time
        }

    return results

DNS Monitoring

DNS Resolution Monitoring

import dns.resolver
import time

def check_dns_resolution(domain):
    try:
        start_time = time.time()
        answers = dns.resolver.resolve(domain, 'A')
        end_time = time.time()

        return {
            'status': 'success',
            'response_time': end_time - start_time,
            'ip_addresses': [str(answer) for answer in answers]
        }
    except Exception as e:
        return {
            'status': 'error',
            'error': str(e)
        }

# Monitor DNS
result = check_dns_resolution("www.albrittonanalytics.com")

9. User Experience Monitoring

Real User Monitoring (RUM)

Custom RUM Implementation

// Custom RUM script
(function() {
  const metrics = {};

  // Performance timing
  window.addEventListener('load', function() {
    const perfData = performance.getEntriesByType('navigation')[0];

    metrics.pageLoadTime = perfData.loadEventEnd - perfData.fetchStart;
    metrics.domContentLoaded = perfData.domContentLoadedEventEnd - perfData.fetchStart;
    metrics.timeToFirstByte = perfData.responseStart - perfData.fetchStart;

    // Send to analytics
    gtag('event', 'page_timing', {
      event_category: 'Performance',
      page_load_time: Math.round(metrics.pageLoadTime),
      dom_content_loaded: Math.round(metrics.domContentLoaded),
      ttfb: Math.round(metrics.timeToFirstByte)
    });
  });

  // Track user interactions
  let lastInteraction = Date.now();
  ['click', 'keydown', 'scroll'].forEach(event => {
    document.addEventListener(event, function() {
      lastInteraction = Date.now();
    });
  });

  // Track session duration
  window.addEventListener('beforeunload', function() {
    const sessionDuration = Date.now() - performance.timing.navigationStart;
    gtag('event', 'session_end', {
      event_category: 'Engagement',
      session_duration: Math.round(sessionDuration / 1000)
    });
  });
})();

Synthetic Testing

Puppeteer-based Testing

// automated-testing.js
const puppeteer = require('puppeteer');

async function testSitePerformance() {
  const browser = await puppeteer.launch();
  const page = await browser.newPage();

  // Enable performance monitoring
  await page.setCacheEnabled(false);

  const response = await page.goto('https://www.albrittonanalytics.com', {
    waitUntil: 'networkidle2'
  });

  // Collect metrics
  const metrics = await page.evaluate(() => {
    const perfData = performance.getEntriesByType('navigation')[0];
    return {
      loadTime: perfData.loadEventEnd - perfData.fetchStart,
      domContentLoaded: perfData.domContentLoadedEventEnd - perfData.fetchStart,
      firstContentfulPaint: performance.getEntriesByName('first-contentful-paint')[0]?.startTime
    };
  });

  // Test critical functionality
  await page.type('[data-md-component="search-query"]', 'test search');
  await page.waitForSelector('[data-md-component="search-result"]');

  await browser.close();

  return {
    status: response.status(),
    metrics: metrics,
    timestamp: new Date().toISOString()
  };
}

// Run every 15 minutes
setInterval(testSitePerformance, 15 * 60 * 1000);

10. Alerting Configuration

Smart Alerting Strategy

Alert Prioritization

Critical Alerts (Immediate):
  - Site completely down (>5 minutes)
  - SSL certificate expired
  - Security vulnerabilities detected
  - Build failures blocking deployments

Warning Alerts (Within 1 hour):
  - Performance degradation (>3 seconds load time)
  - Error rate >1%
  - SSL certificate expiring in <7 days
  - CDN issues affecting regions

Info Alerts (Daily digest):
  - Performance trends
  - Usage statistics
  - Security scan results
  - Build summaries

Multi-Channel Alerting

// alerting-system.js
const alertChannels = {
  critical: ['sms', 'phone', 'slack', 'email'],
  warning: ['slack', 'email'],
  info: ['email']
};

async function sendAlert(level, message, details) {
  const channels = alertChannels[level] || ['email'];

  for (const channel of channels) {
    switch (channel) {
      case 'slack':
        await sendSlackAlert(message, details);
        break;
      case 'email':
        await sendEmailAlert(message, details);
        break;
      case 'sms':
        await sendSMSAlert(message);
        break;
    }
  }
}

async function sendSlackAlert(message, details) {
  const webhook = process.env.SLACK_WEBHOOK_URL;
  await fetch(webhook, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      text: message,
      attachments: [{
        color: 'danger',
        fields: Object.entries(details).map(([key, value]) => ({
          title: key,
          value: value,
          short: true
        }))
      }]
    })
  });
}

11. Dashboard Setup

Grafana Dashboard (Self-hosted)

Docker Compose Setup

# docker-compose.yml
version: '3.8'
services:
  grafana:
    image: grafana/grafana:latest
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
    volumes:
      - grafana-data:/var/lib/grafana
      - ./grafana/provisioning:/etc/grafana/provisioning

  prometheus:
    image: prom/prometheus:latest
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus-data:/prometheus

volumes:
  grafana-data:
  prometheus-data:

Key Metrics Dashboard

{
  "dashboard": {
    "title": "Website Monitoring Dashboard",
    "panels": [
      {
        "title": "Site Uptime",
        "type": "stat",
        "targets": [
          {
            "expr": "up{job=\"website-monitor\"}",
            "legendFormat": "Uptime"
          }
        ]
      },
      {
        "title": "Response Time",
        "type": "graph",
        "targets": [
          {
            "expr": "http_request_duration_seconds{job=\"website-monitor\"}",
            "legendFormat": "Response Time"
          }
        ]
      },
      {
        "title": "Error Rate",
        "type": "graph",
        "targets": [
          {
            "expr": "rate(http_requests_total{status=~\"5..\"}[5m])",
            "legendFormat": "5xx Errors"
          }
        ]
      }
    ]
  }
}

Google Data Studio (Free)

Connecting Multiple Data Sources

// Data Studio connector for custom metrics
function getData(request) {
  const data = {
    uptime: getUptimeData(),
    performance: getPerformanceData(),
    errors: getErrorData()
  };

  return {
    schema: getSchema(),
    rows: formatDataForDataStudio(data)
  };
}

function getSchema() {
  return [
    { name: 'date', label: 'Date', dataType: 'STRING' },
    { name: 'uptime_percentage', label: 'Uptime %', dataType: 'NUMBER' },
    { name: 'avg_response_time', label: 'Avg Response Time', dataType: 'NUMBER' },
    { name: 'error_count', label: 'Error Count', dataType: 'NUMBER' }
  ];
}

12. Cost-Effective Solutions

Free Tier Maximization Strategy

Service Combinations for Maximum Coverage

Free Tier Stack:
  Uptime Monitoring: UptimeRobot (50 monitors)
  Performance: Google PageSpeed Insights API
  Analytics: Google Analytics 4
  Error Tracking: Sentry (5,000 errors/month)
  Status Page: StatusPage.io (1 page)
  SSL Monitoring: SSL Labs API

Total Monthly Cost: $0
Coverage: 80% of monitoring needs

Low-Cost Premium Upgrades ($50/month total)

Enhanced Stack:
  Uptime: Pingdom ($14.95/month)
  Performance: DebugBear ($29/month)
  Analytics: Plausible ($9/month)

Total: $52.95/month
Coverage: 95% of monitoring needs

ROI Calculation

Downtime Cost Analysis

// Calculate cost of downtime
function calculateDowntimeCost(revenuePerDay, downtimeMinutes) {
  const revenuePerMinute = revenuePerDay / (24 * 60);
  const directCost = revenuePerMinute * downtimeMinutes;

  // Reputation cost multiplier
  const reputationMultiplier = downtimeMinutes > 60 ? 3 : 1.5;

  return directCost * reputationMultiplier;
}

// For a $1000/day revenue site:
// 1 hour downtime = $62.50 direct + reputation cost = ~$187.50
// Monthly monitoring cost of $50 pays for itself with just 16 minutes saved downtime per month

13. Integration Recommendations

Slack Integration

Webhook Setup

// netlify-functions/slack-alerts.js
exports.handler = async (event, context) => {
  const { type, message, severity } = JSON.parse(event.body);

  const slackMessage = {
    text: `🚨 ${severity.toUpperCase()}: ${message}`,
    channel: '#alerts',
    username: 'Monitoring Bot',
    icon_emoji: severity === 'critical' ? ':rotating_light:' : ':warning:'
  };

  await fetch(process.env.SLACK_WEBHOOK_URL, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(slackMessage)
  });

  return { statusCode: 200, body: 'Alert sent' };
};

Discord Integration

Bot Setup for Alerts

const Discord = require('discord.js');
const client = new Discord.Client();

client.on('ready', () => {
  console.log('Monitoring bot is ready!');
});

async function sendDiscordAlert(message, severity) {
  const channel = client.channels.cache.get(process.env.DISCORD_CHANNEL_ID);

  const embed = new Discord.MessageEmbed()
    .setTitle(`${severity.toUpperCase()} Alert`)
    .setDescription(message)
    .setColor(severity === 'critical' ? '#ff0000' : '#ffaa00')
    .setTimestamp();

  await channel.send(embed);
}

client.login(process.env.DISCORD_BOT_TOKEN);

Email Alerting

SMTP Configuration

import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText

def send_email_alert(subject, message, severity='info'):
    smtp_server = "smtp.gmail.com"
    port = 587
    sender_email = "monitoring@yourdomain.com"
    password = "your-app-password"

    msg = MIMEMultipart()
    msg['From'] = sender_email
    msg['To'] = "alerts@yourdomain.com"
    msg['Subject'] = f"[{severity.upper()}] {subject}"

    html_body = f"""
    <html>
      <body>
        <h2 style="color: {'red' if severity == 'critical' else 'orange'}">
          {severity.title()} Alert
        </h2>
        <p>{message}</p>
        <p><small>Sent at: {datetime.now().isoformat()}</small></p>
      </body>
    </html>
    """

    msg.attach(MIMEText(html_body, 'html'))

    with smtplib.SMTP(smtp_server, port) as server:
        server.starttls()
        server.login(sender_email, password)
        server.send_message(msg)

14. Monitoring Automation

Automated Health Checks

Comprehensive Site Health Script

#!/usr/bin/env python3
import requests
import time
import json
from datetime import datetime
import ssl
import socket
from urllib.parse import urlparse

class SiteHealthChecker:
    def __init__(self, base_url):
        self.base_url = base_url
        self.results = {}

    def check_uptime(self):
        try:
            response = requests.get(self.base_url, timeout=10)
            self.results['uptime'] = {
                'status': response.status_code,
                'response_time': response.elapsed.total_seconds(),
                'success': response.status_code == 200
            }
        except Exception as e:
            self.results['uptime'] = {
                'status': 'error',
                'error': str(e),
                'success': False
            }

    def check_ssl_certificate(self):
        try:
            parsed_url = urlparse(self.base_url)
            hostname = parsed_url.hostname

            context = ssl.create_default_context()
            with socket.create_connection((hostname, 443)) as sock:
                with context.wrap_socket(sock, server_hostname=hostname) as ssock:
                    cert = ssock.getpeercert()

            not_after = datetime.strptime(cert['notAfter'], '%b %d %H:%M:%S %Y %Z')
            days_until_expiry = (not_after - datetime.now()).days

            self.results['ssl'] = {
                'valid': True,
                'expires': cert['notAfter'],
                'days_until_expiry': days_until_expiry,
                'issuer': cert['issuer']
            }
        except Exception as e:
            self.results['ssl'] = {
                'valid': False,
                'error': str(e)
            }

    def check_performance(self):
        # Check key pages
        pages = ['/', '/blog/', '/features/', '/getting-started/']
        performance_results = {}

        for page in pages:
            url = f"{self.base_url.rstrip('/')}{page}"
            try:
                start_time = time.time()
                response = requests.get(url, timeout=30)
                end_time = time.time()

                performance_results[page] = {
                    'load_time': end_time - start_time,
                    'status_code': response.status_code,
                    'content_length': len(response.content)
                }
            except Exception as e:
                performance_results[page] = {
                    'error': str(e)
                }

        self.results['performance'] = performance_results

    def check_security_headers(self):
        try:
            response = requests.get(self.base_url)
            headers = response.headers

            security_headers = {
                'X-Frame-Options': headers.get('X-Frame-Options'),
                'X-Content-Type-Options': headers.get('X-Content-Type-Options'),
                'X-XSS-Protection': headers.get('X-XSS-Protection'),
                'Strict-Transport-Security': headers.get('Strict-Transport-Security'),
                'Content-Security-Policy': headers.get('Content-Security-Policy')
            }

            self.results['security_headers'] = security_headers
        except Exception as e:
            self.results['security_headers'] = {'error': str(e)}

    def run_all_checks(self):
        self.check_uptime()
        self.check_ssl_certificate()
        self.check_performance()
        self.check_security_headers()

        self.results['timestamp'] = datetime.now().isoformat()
        return self.results

# Usage
if __name__ == "__main__":
    checker = SiteHealthChecker("https://www.albrittonanalytics.com")
    results = checker.run_all_checks()

    # Save results
    with open(f"health_check_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json", 'w') as f:
        json.dump(results, f, indent=2)

    # Send alerts if issues detected
    if not results['uptime']['success']:
        send_critical_alert("Site is down!", results)
    elif results['ssl']['days_until_expiry'] < 7:
        send_warning_alert("SSL certificate expiring soon!", results)

Cron Job Setup

Automated Monitoring Schedule

# /etc/cron.d/site-monitoring
# Run health check every 5 minutes
*/5 * * * * /usr/bin/python3 /opt/monitoring/health_check.py

# Run comprehensive check every hour
0 * * * * /usr/bin/python3 /opt/monitoring/comprehensive_check.py

# Daily report generation
0 8 * * * /usr/bin/python3 /opt/monitoring/daily_report.py

# Weekly security scan
0 2 * * 0 /usr/bin/python3 /opt/monitoring/security_scan.py

Self-Healing Procedures

Automated Recovery Actions

class AutoRecovery:
    def __init__(self):
        self.recovery_actions = {
            'high_response_time': self.clear_cache,
            'ssl_issue': self.regenerate_ssl,
            'build_failure': self.retry_deployment
        }

    def clear_cache(self):
        # Trigger Netlify cache clear
        requests.post(
            f"https://api.netlify.com/api/v1/sites/{NETLIFY_SITE_ID}/cache",
            headers={"Authorization": f"Bearer {NETLIFY_ACCESS_TOKEN}"}
        )

    def regenerate_ssl(self):
        # Trigger SSL certificate renewal
        requests.post(
            f"https://api.netlify.com/api/v1/sites/{NETLIFY_SITE_ID}/ssl",
            headers={"Authorization": f"Bearer {NETLIFY_ACCESS_TOKEN}"}
        )

    def retry_deployment(self):
        # Trigger rebuild from latest commit
        requests.post(
            f"https://api.netlify.com/api/v1/sites/{NETLIFY_SITE_ID}/builds",
            headers={"Authorization": f"Bearer {NETLIFY_ACCESS_TOKEN}"}
        )

Implementation Checklist

Phase 1: Essential Monitoring (Week 1)

  • Set up UptimeRobot for basic uptime monitoring
  • Configure Google Analytics 4 with enhanced measurement
  • Implement basic error tracking with Sentry
  • Set up SSL certificate monitoring
  • Create basic alerting via email

Phase 2: Enhanced Monitoring (Week 2)

  • Add Core Web Vitals tracking
  • Set up performance monitoring with DebugBear or similar
  • Configure Slack/Discord integrations
  • Implement security headers monitoring
  • Create status page

Phase 3: Advanced Monitoring (Week 3-4)

  • Deploy comprehensive health check scripts
  • Set up automated testing with Puppeteer
  • Configure advanced dashboards
  • Implement self-healing procedures
  • Create detailed reporting system

Phase 4: Optimization (Ongoing)

  • Fine-tune alerting thresholds
  • Optimize monitoring frequency
  • Expand test coverage
  • Regular security audits
  • Performance budget reviews

Conclusion

This comprehensive monitoring setup provides multiple layers of oversight for your production MkDocs Material website. Start with the free tier solutions to establish baseline monitoring, then gradually add premium features as your requirements grow.

The key to successful monitoring is: 1. Start Simple: Begin with basic uptime and performance monitoring 2. Iterate Gradually: Add more sophisticated monitoring over time 3. Focus on Actionability: Only alert on issues you can and will fix 4. Automate Where Possible: Reduce manual overhead with scripts and automation 5. Review Regularly: Monthly reviews of monitoring effectiveness and costs

Remember to regularly test your monitoring setup to ensure alerts are working correctly and adjust thresholds based on your site's normal performance patterns.