Monitoring Jeedom with Vigilmon

Jeedom is an open-source home automation platform with an extensive plugin ecosystem supporting ZigBee, Z-Wave, RFLink, and dozens more protocols. It runs on PHP/Apache and stores everything in MySQL. When it goes wrong — a crashed PHP-FPM worker, a dead plugin daemon, a MySQL lock — your automations stop silently, and you find out when the lights don't respond. Vigilmon gives you a real-time monitoring layer across every critical Jeedom component so you know immediately, not hours later.

What You'll Set Up

• HTTP availability monitor for the Jeedom web interface
• PHP-FPM process pool health check
• MySQL database connectivity heartbeat
• Plugin daemon health monitoring (ZigBee, Z-Wave, RFLink)
• Automation scenario execution engine verification
• Cron task scheduler monitoring
• MQTT server integration status
• Push notification delivery service check
• Mobile app API endpoint monitoring
• Backup job execution heartbeat

Prerequisites

• Jeedom 4.x running on Apache/Nginx + PHP-FPM
• MySQL accessible locally
• A free Vigilmon account

Step 1: Monitor the Jeedom Web Interface

Jeedom's web interface on port 80 (or 443 behind TLS) is your control panel for all devices, scenarios, and plugins. If Apache or PHP-FPM crashes, this goes down first.

1. Log in to vigilmon.online and click Add Monitor.
2. Set Type to HTTP / HTTPS.
3. Enter: http://your-jeedom-host (or https://jeedom.yourdomain.com behind a reverse proxy).
4. Set Check interval to 1 minute.
5. Set Expected HTTP status to 200.
6. Set Expected response body contains to Jeedom to verify the page rendered properly.
7. Click Save.

Jeedom exposes a lightweight health API — use it for a more meaningful check:

http://your-jeedom-host/core/api/jeeApi.php?apikey=YOUR_API_KEY&type=health

This returns a JSON health status including database connectivity and plugin status.

Step 2: Monitor PHP-FPM Process Health

Jeedom runs on PHP-FPM. If the worker pool is exhausted (all workers stuck on long-running requests), new requests queue up and eventually time out — the web UI appears down even though Apache is running.

Monitor PHP-FPM via its status endpoint. Enable it in your PHP-FPM pool config (/etc/php/8.x/fpm/pool.d/www.conf):

pm.status_path = /fpm-status

Add the status route to Apache or Nginx, then monitor it:

1. Click Add Monitor → HTTP / HTTPS.
2. URL: http://your-jeedom-host/fpm-status.
3. Set Expected response body contains to active processes.
4. Interval: 1 minute.

Alternatively, check PHP-FPM from the host directly:

#!/bin/bash
php-fpm8.2 -t 2>/dev/null || exit 1
# Check process count
WORKERS=$(pgrep -c php-fpm)
if [ "$WORKERS" -gt 1 ]; then
  curl -s https://vigilmon.online/heartbeat/PHPFPM_HEARTBEAT_ID
fi

Step 3: Monitor MySQL Database Connectivity

Jeedom stores all configuration, device states, plugin data, and scenario definitions in MySQL. A lost database connection means Jeedom can't read device states, save commands, or execute scenarios.

#!/bin/bash
mysqladmin -h localhost -u jeedom -pYOUR_MYSQL_PASSWORD ping 2>/dev/null | grep -q "alive"
if [ $? -eq 0 ]; then
  curl -s https://vigilmon.online/heartbeat/MYSQL_HEARTBEAT_ID
fi

Create a Cron Heartbeat in Vigilmon:

1. Click Add Monitor → Cron Heartbeat.
2. Set expected interval to 5 minutes.
3. Add to cron: */5 * * * * /opt/checks/jeedom-db.sh

Also monitor MySQL's TCP port:

1. Click Add Monitor → TCP Port.
2. Host and port 3306.
3. Interval: 1 minute.

Step 4: Monitor Plugin Daemon Health

Jeedom's protocol plugins (ZigBee, Z-Wave, RFLink, Bluetooth) each run as daemons that maintain the connection to their hardware interfaces. A crashed daemon means the protocol goes silent — devices stop responding and states freeze.

Use the Jeedom API to check daemon status for each plugin:

#!/bin/bash
API_KEY="YOUR_JEEDOM_API_KEY"
JEEDOM_URL="http://your-jeedom-host"

check_daemon() {
  local plugin="$1"
  local heartbeat="$2"
  STATUS=$(curl -s "${JEEDOM_URL}/core/api/jeeApi.php?apikey=${API_KEY}&type=plugin&id=${plugin}&action=daemon_info" \
    | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('launchable', 'ko'))" 2>/dev/null)
  if [ "$STATUS" = "ok" ]; then
    curl -s "https://vigilmon.online/heartbeat/$heartbeat"
  fi
}

check_daemon "zigbee" "ZIGBEE_DAEMON_HEARTBEAT_ID"
check_daemon "openzwave" "ZWAVE_DAEMON_HEARTBEAT_ID"
check_daemon "rflink" "RFLINK_DAEMON_HEARTBEAT_ID"

Create a separate Vigilmon heartbeat monitor for each plugin daemon with a 5-minute expected interval. Add the script to cron: */5 * * * * /opt/checks/jeedom-daemons.sh

Step 5: Monitor the Automation Scenario Engine

Jeedom scenarios are the core automation engine — triggering lights, reading sensors, sending notifications. The scenario engine runs within the PHP process pool. If it stalls, all time-based and event-based automation stops.

Verify the scenario engine is processing by creating a test scenario in Jeedom:

1. In Jeedom, create a scenario named vigilmon_watchdog triggered every minute.
2. Add an action block: Run script → curl -s https://vigilmon.online/heartbeat/SCENARIO_HEARTBEAT_ID
3. Enable the scenario.

In Vigilmon, set the heartbeat interval to 3 minutes. If the scenario engine stalls, the heartbeat stops arriving and you get an alert.

Alternatively, trigger the scenario via the API and verify it ran:

#!/bin/bash
API_KEY="YOUR_JEEDOM_API_KEY"
SCENARIO_ID="YOUR_SCENARIO_ID"
JEEDOM_URL="http://your-jeedom-host"

# Trigger the watchdog scenario
curl -s "${JEEDOM_URL}/core/api/jeeApi.php?apikey=${API_KEY}&type=scenario&id=${SCENARIO_ID}&action=start" > /dev/null

# The scenario itself will ping the heartbeat URL if it runs

Step 6: Monitor the Cron Task Scheduler

Jeedom relies heavily on its internal cron system for scheduled device polling, periodic data refresh, and maintenance tasks. The Jeedom cron runs via the system cron calling jeedom.php. If the system cron is misconfigured or Jeedom's cron service crashes, polling stops.

Check that the Jeedom cron process is active:

#!/bin/bash
# Verify Jeedom cron daemon is running
pgrep -f "php.*cron" > /dev/null 2>&1
if [ $? -eq 0 ]; then
  curl -s https://vigilmon.online/heartbeat/CRON_HEARTBEAT_ID
fi

Also verify cron is actually executing by checking a Jeedom cron log timestamp:

#!/bin/bash
LOG_FILE="/var/www/html/log/cron"
if [ -f "$LOG_FILE" ]; then
  LAST_RUN=$(stat -c %Y "$LOG_FILE")
  NOW=$(date +%s)
  AGE=$((NOW - LAST_RUN))
  # Alert if cron log hasn't been updated in 10 minutes
  if [ $AGE -lt 600 ]; then
    curl -s https://vigilmon.online/heartbeat/CRON_HEARTBEAT_ID
  fi
fi

Step 7: Monitor MQTT Server Integration

Many Jeedom setups integrate with Mosquitto or an external MQTT broker for cross-platform device communication (especially with jMQTT plugin). A broken MQTT connection means MQTT-based devices lose their state updates.

Add a TCP monitor for your MQTT broker:

1. Click Add Monitor → TCP Port.
2. Host and port 1883 (or 8883 for TLS).
3. Interval: 1 minute.

Verify Jeedom's jMQTT plugin connection status via the daemon check in Step 4 (add jmqtt to the daemon check list).

Step 8: Monitor Push Notification Delivery

Jeedom sends push notifications through plugins (Pushbullet, Telegram, email, SMS). If the notification daemon or API credentials expire, you lose all alert delivery without knowing it.

Create a test scenario that sends a notification and logs success:

#!/bin/bash
API_KEY="YOUR_JEEDOM_API_KEY"
JEEDOM_URL="http://your-jeedom-host"

# Trigger a test notification scenario
RESULT=$(curl -s "${JEEDOM_URL}/core/api/jeeApi.php?apikey=${API_KEY}&type=cmd&id=YOUR_NOTIFY_CMD_ID&action=execCmd")
if echo "$RESULT" | grep -q "ok"; then
  curl -s https://vigilmon.online/heartbeat/NOTIFY_HEARTBEAT_ID
fi

Set the Vigilmon heartbeat interval to 24 hours and run the check daily. If your notification path breaks, you'll know within a day — before a real emergency tests it for you.

Step 9: Monitor the Mobile App API Endpoint

Jeedom's mobile API is what the iOS and Android apps call to control devices remotely. If this endpoint is unreachable (e.g., reverse proxy misconfiguration after a server update), mobile control stops working.

1. Click Add Monitor → HTTP / HTTPS.
2. URL: http://your-jeedom-host/core/api/jeeApi.php?type=ping.
3. Set Expected response body contains to pong.
4. Interval: 2 minutes.

The type=ping endpoint requires no authentication and is safe to probe repeatedly.

Step 10: Monitor Backup Job Execution

Jeedom can run automated backups of its configuration and database. If the backup job fails, your recovery point is stale — a crash after a week of backup failures means a week of lost configuration.

Create a backup verification heartbeat:

#!/bin/bash
BACKUP_DIR="/var/www/html/backup"
# Check the most recent backup was created within the last 25 hours
LATEST=$(ls -t "$BACKUP_DIR"/*.tar.gz 2>/dev/null | head -1)
if [ -n "$LATEST" ]; then
  AGE=$(( $(date +%s) - $(stat -c %Y "$LATEST") ))
  if [ $AGE -lt 90000 ]; then  # 25 hours in seconds
    curl -s https://vigilmon.online/heartbeat/BACKUP_HEARTBEAT_ID
  fi
fi

Create a Cron Heartbeat in Vigilmon with a 25 hour interval. Run the check every hour:

0 * * * * /opt/checks/jeedom-backup.sh

Step 11: Configure Alert Channels

1. Go to Alert Channels in Vigilmon and add Slack, email, or a webhook.
2. For plugin daemon heartbeats, set Consecutive failures to 2 — a brief daemon restart takes 30–60 seconds.
3. For the MySQL heartbeat, set Consecutive failures to 1 — a database failure is immediately critical.
4. Group monitors in Vigilmon by severity:
   • Critical: web UI, MySQL, PHP-FPM
   • Warning: plugin daemons, scenario engine, notifications

Enable SSL monitoring on your Jeedom domain if you use HTTPS:

1. Open the HTTP monitor for https://jeedom.yourdomain.com.
2. Enable Monitor SSL certificate.
3. Set Alert when expires in less than 21 days.

Summary

| Monitor | Target | What It Catches | |---|---|---| | HTTP | / with body check | Jeedom web UI down | | HTTP | /core/api/jeeApi.php?type=ping | Mobile API broken | | HTTP | /fpm-status | PHP-FPM pool exhausted | | TCP | :3306 | MySQL port unreachable | | TCP | :1883 | MQTT broker crash | | Heartbeat | MySQL ping | Database connection lost | | Heartbeat | ZigBee daemon check | ZigBee coordinator down | | Heartbeat | Z-Wave daemon check | Z-Wave stick disconnected | | Heartbeat | RFLink daemon check | RF receiver offline | | Heartbeat | Watchdog scenario | Scenario engine stalled | | Heartbeat | Cron process check | Scheduler dead | | Heartbeat | Notification test | Push alerts broken | | Heartbeat | Backup timestamp check | Backups stopped running |

Jeedom's plugin architecture makes it incredibly flexible — but that same flexibility means a single broken plugin daemon or exhausted PHP-FPM pool can knock out an entire protocol while everything else looks fine. With Vigilmon watching each layer independently, you catch the ZigBee coordinator failure before half your home goes dark.