ProcessWire Monitoring with Vigilmon: Web Server, Admin Panel & Database Health Checks

Your ProcessWire site served a database error page for two hours before anyone noticed. A MySQL slow query had held an open transaction long enough to exhaust the connection pool. The PHP-FPM process pool filled up waiting for connections that never closed. Every visitor got a 500 page. Your admin panel was unreachable. And the image resizing service had silently stopped generating thumbnails the day before because a write permission on the assets directory was accidentally revoked.

ProcessWire is an open-source PHP CMS and web application framework known for its flexible field system and powerful API. It runs on port 80 (or 443 with TLS) behind a web server like Apache or Nginx, backed by MySQL or MariaDB. Self-hosting ProcessWire gives you full control over your content and templates — and full responsibility for detecting when the web server, database, or any of the supporting services fail.

Vigilmon monitors your ProcessWire installation from outside, the same way a real visitor would. If the site goes down, if the admin panel becomes unreachable, or if the database layer starts returning errors, Vigilmon alerts you before it impacts your editors or your end users.

What You'll Build

• An HTTP monitor on the ProcessWire site
• An admin panel uptime check
• A database connectivity probe via the site's response
• An image processing service health check
• A module loading health monitor
• An API endpoint response time monitor
• Alert channels for your web operations team

Prerequisites

• A self-hosted ProcessWire installation (v3.x recommended)
• Running on port 80 (HTTP) or port 443 (HTTPS)
• A free account at vigilmon.online

Step 1: Monitor Web Server Availability

The first thing to monitor is whether the web server (Apache or Nginx) and PHP-FPM are responding at all. A missing response here means the site is completely offline for all visitors.

Test the root URL:

curl -s -o /dev/null -w "%{http_code}" http://your-processwire-site.com/

Expected: a 200 response (or 301/302 if you redirect www or HTTPS). The page content should include identifiable text from your site.

Set up the Vigilmon monitor:

1. Log in to Vigilmon and click New Monitor → HTTP.
2. Set URL to http://your-processwire-site.com/ (or your HTTPS URL).
3. Set Check interval to 60 seconds.
4. Set Expected status code to 200.
5. Under Advanced → Keyword check, add:
   • Keyword present: a unique phrase from your site's homepage (e.g., your site name)
6. Save the monitor.

This catches PHP-FPM crashes, web server process failures, and infrastructure-level outages.

Step 2: Monitor the Admin Panel

ProcessWire's admin panel at /processwire/ (or your custom admin path) is where all content editing happens. It can go down independently of the public site — for example, if a session handling module crashes or if admin-specific PHP code throws an uncaught exception.

Test the admin login page:

curl -s -o /dev/null -w "%{http_code}" http://your-processwire-site.com/processwire/

Expected: a 200 response with the login form. The page includes ProcessWire in its HTML.

Set up the Vigilmon monitor:

1. Click New Monitor → HTTP in Vigilmon.
2. Set URL to http://your-processwire-site.com/processwire/ (replace with your custom admin path if changed).
3. Set Expected status code to 200.
4. Under Advanced → Keyword check, add:
   • Keyword present: ProcessWire
5. Set Check interval to 120 seconds.
6. Save the monitor.

Step 3: Monitor Database Connectivity

ProcessWire requires MySQL or MariaDB for all content storage. If the database becomes unreachable or the connection pool is exhausted, ProcessWire throws a fatal error or returns a blank page — depending on your error reporting configuration.

The most reliable way to probe database connectivity externally is to request a page that requires a non-trivial database query. Create a lightweight health check page in your ProcessWire templates that makes a simple database call and returns a JSON response:

<?php
// health-check.php template (assign to a page at /health/)
header('Content-Type: application/json');
try {
    $count = $pages->count("template=home");
    echo json_encode(['status' => 'ok', 'pages' => $count]);
} catch (Exception $e) {
    http_response_code(503);
    echo json_encode(['status' => 'error', 'message' => $e->getMessage()]);
}

Publish this template and assign it to a page accessible at /health/.

Test it:

curl -s http://your-processwire-site.com/health/

Expected: {"status":"ok","pages":1} with a 200 response. A 503 or error status indicates a database failure.

Set up the Vigilmon monitor:

1. Click New Monitor → HTTP in Vigilmon.
2. Set URL to http://your-processwire-site.com/health/.
3. Set Expected status code to 200.
4. Under Advanced → Keyword check, add:
   • Keyword present: "status":"ok"
5. Set Check interval to 60 seconds.
6. Save the monitor.

Step 4: Monitor the Image Processing Service

ProcessWire's image processing (via GD or Imagick) resizes and crops images on demand and caches them in the site assets directory. If the assets directory loses write permission, if disk space runs out, or if the PHP image extension crashes, new image variants stop being generated. Existing cached images still serve, masking the failure until a new image is requested.

Add a simple image processing probe to your health check template:

<?php
// Add to your health-check template
$testPage = $pages->get("template=home");
$img = $testPage->images->first();
if ($img) {
    $resized = $img->size(10, 10); // tiny resize to confirm processing works
    $status['image_processing'] = $resized->url ? 'ok' : 'error';
} else {
    $status['image_processing'] = 'no_image';
}

Alternatively, monitor the assets directory by checking a known cached image URL:

curl -s -o /dev/null -w "%{http_code}" \
  http://your-processwire-site.com/site/assets/files/1/your-image.100x100.jpg

Expected: 200. A 404 means the cached variant doesn't exist (image processing may have failed on generation). A 403 means a permission problem with the assets directory.

Set up the Vigilmon monitor:

1. Click New Monitor → HTTP in Vigilmon.
2. Set URL to your health check endpoint (from Step 3, extended to include image checks).
3. Under Advanced → Keyword check, add:
   • Keyword present: image_processing
   • Keyword absent: error
4. Set Check interval to 300 seconds.
5. Save the monitor.

Step 5: Monitor Module Loading Health

ProcessWire modules extend nearly every part of the system — form builders, caching layers, API helpers, and authentication modules. A broken module can prevent the admin panel from loading, break specific site functionality, or cause PHP fatal errors on page render. Monitor module loading health by extending your health check template:

<?php
// Check that critical modules are loaded
$modules = wire('modules');
$criticalModules = ['ProcessPageList', 'InputfieldText', 'MarkupCache'];
$moduleStatus = [];
foreach ($criticalModules as $moduleName) {
    $moduleStatus[$moduleName] = $modules->isInstalled($moduleName) ? 'ok' : 'missing';
}
$status['modules'] = $moduleStatus;

A healthy response includes "ok" for all critical module names. A missing or broken module returns "missing" or causes a PHP exception that returns a 500.

Set up the Vigilmon monitor using your /health/ endpoint. Ensure the keyword check includes ProcessPageList (a core module) to catch module system failures:

1. Click New Monitor → HTTP in Vigilmon.
2. Set URL to http://your-processwire-site.com/health/.
3. Under Advanced → Keyword check, add:
   • Keyword present: ProcessPageList
4. Set Check interval to 300 seconds.
5. Save the monitor.

Step 6: Monitor API Endpoint Response Time

ProcessWire can serve as a headless CMS through its JSON API features or custom template endpoints. Slow database queries or PHP-FPM pool exhaustion often manifest as increased response times before causing outright failures. Vigilmon tracks response time and can alert on latency spikes.

Test your API endpoint baseline:

time curl -s http://your-processwire-site.com/api/pages/?template=blog-post

Note your baseline response time. A healthy ProcessWire JSON API endpoint should respond in under 500ms. Response times above 2–3 seconds indicate database or PHP-FPM stress.

Set up the Vigilmon monitor:

1. Click New Monitor → HTTP in Vigilmon.
2. Set URL to your ProcessWire API endpoint (e.g., http://your-processwire-site.com/api/pages/).
3. Set Expected status code to 200.
4. Under Advanced → Response time threshold, set your alert threshold (e.g., 3000ms).
5. Set Check interval to 60 seconds.
6. Save the monitor.

Vigilmon graphs response times over time — use this to spot gradual degradation before it becomes a full outage.

Step 7: Alert Channels

Go to Notifications → New Channel in Vigilmon and configure:

• Email — immediate alerts to your site administrator or dev team
• Webhook — Slack or Discord for editorial and engineering awareness

A failing database alert in Slack looks like:

🔴 DOWN: processwire-db-health (HTTP monitor)
Expected keyword "status":"ok" not found
Region: EU-West
Triggered: 2026-05-30 04:10 UTC

When the database recovers:

✅ RECOVERED: processwire-db-health
Downtime: 33 minutes

Set critical severity for the web server availability and database monitors. Use warning severity for the admin panel, image processing, and module loading monitors. Enable Alerting → Escalation to page your on-call contact if the site is completely down for more than 5 minutes.

What You've Built

| Scenario | How Vigilmon catches it | |---|---| | Web server / PHP-FPM crash | Root URL monitor returns connection refused or non-200 | | Admin panel module failure | Admin path monitor returns 500 or missing ProcessWire keyword | | MySQL connection pool exhausted | Health check endpoint returns "status":"error" | | Database host unreachable | Health check endpoint returns 503 | | Image assets directory permission revoked | Image health check returns error or 404 on variant URL | | Core module broken or missing | Module health check shows missing for ProcessPageList | | API response time degradation | Response time monitor exceeds configured threshold | | Disk space exhaustion | Image processing fails, health check returns error |

ProcessWire's flexibility is a strength — and a risk surface. External monitoring with Vigilmon gives you eyes on the web server, database, module system, and image pipeline from outside your infrastructure, so failures surface as alerts rather than as editor support tickets or missed content deadlines.

Start monitoring your ProcessWire site today — register free at vigilmon.online.