Monitoring Pelican Panel and Wings Game Servers with Vigilmon

Pelican Panel lets you manage dozens of game servers — Minecraft, CS2, Valheim, Terraria — from a single web UI. But the stack is layered: a PHP/Laravel panel behind nginx, MySQL, Redis, and then Wings daemons running on each physical game node that manage the actual Docker containers. Any of these can fail independently. A Wings daemon crash on node 2 takes down every game server on that machine while the panel web UI looks healthy. Vigilmon lets you watch the panel, each Wings node, and individual game servers so you know exactly what's down and where.

What You'll Set Up

• HTTP monitor for the Pelican Panel web UI and API
• TCP monitors for MySQL and Redis
• HTTP monitors for Wings daemon health on each game node
• Cron heartbeats for Wings-to-Panel connectivity
• TCP monitors for individual game server allocation ports
• HTTP monitor for the file upload service
• TLS certificate expiry monitor
• Alerting configuration for the full stack

Prerequisites

• Pelican Panel installed (nginx + PHP-FPM serving the panel, port 443)
• MySQL running (default port 3306)
• Redis running (default port 6379)
• Wings daemon running on each node (default API port 8080 or 8443 with TLS)
• A free Vigilmon account

Step 1: Monitor the Pelican Panel Web UI

The panel web UI is the control surface for everything. If nginx or PHP-FPM crashes, your team loses the ability to start, stop, or reconfigure any game server.

1. Log in to vigilmon.online and click Add Monitor.
2. Set Type to HTTP / HTTPS.
3. Enter your panel URL: https://panel.yourdomain.com.
4. Set Check interval to 1 minute.
5. Set Expected HTTP status to 200.
6. Enable Monitor SSL certificate with a 21-day expiry alert.
7. Click Save.

For a more robust probe that avoids caching headers, use the panel's API health endpoint:

# Verify the API is responding
curl -s https://panel.yourdomain.com/api/client \
  -H "Authorization: Bearer YOUR_API_KEY" | jq .meta

Add a second HTTP monitor targeting https://panel.yourdomain.com/api/client with the Authorization header configured in Vigilmon's Custom headers field.

Step 2: Monitor MySQL

MySQL stores every panel entity: servers, users, nodes, allocations, resource limits, and access control. A MySQL failure causes PHP-FPM to return 500 errors on every authenticated request even if the web server itself is running.

1. Click Add Monitor → TCP Port.
2. Set Host to your MySQL server.
3. Set Port to 3306.
4. Set Check interval to 1 minute.
5. Click Save.

Pair with a cron heartbeat for a query-level check:

# /etc/cron.d/pelican-mysql-check
* * * * * root mysqladmin -u pelican -p"$DB_PASS" ping --silent \
  && curl -s https://vigilmon.online/heartbeat/YOUR_MYSQL_HEARTBEAT_ID

Set the environment variable DB_PASS via a secrets file or systemd credentials — never hardcode passwords in crontabs.

Step 3: Monitor Redis

Pelican Panel uses Redis for queue processing (deployment jobs), session storage, and caching. If Redis goes down, queue workers stop processing server start/stop commands, and sessions expire immediately.

1. Click Add Monitor → TCP Port.
2. Set Host to your Redis server.
3. Set Port to 6379.
4. Set Check interval to 1 minute.
5. Click Save.

Cron heartbeat for a logic-level check:

* * * * * root redis-cli ping | grep -q PONG \
  && curl -s https://vigilmon.online/heartbeat/YOUR_REDIS_HEARTBEAT_ID

Step 4: Monitor Wings Daemons on Each Game Node

Wings (github.com/pelican-dev/wings) is the Node.js daemon running on each physical machine that manages game server containers. It communicates with the panel over HTTPS and exposes a health API. If Wings crashes on a node, every game server on that node goes unreachable — the panel marks them offline, but players are already disconnected.

For each Wings node, add an HTTP monitor:

1. Click Add Monitor → HTTP / HTTPS.
2. Set URL to https://node1.yourdomain.com:8443 (or http://node1.yourdomain.com:8080 if no TLS on Wings).
3. Set Expected HTTP status to 200 (Wings returns 200 on the root endpoint when healthy).
4. Set Check interval to 1 minute.
5. Click Save.

Wings also exposes a healthcheck route:

# Check Wings health
curl -s https://node1.yourdomain.com:8443/api/system \
  -H "Authorization: Bearer YOUR_WINGS_TOKEN" | jq .version

If your Wings setup exposes /api/system, add a second HTTP monitor targeting that endpoint with the Wings bearer token in Custom headers.

Repeat for each Wings node. With multiple nodes, name each monitor Wings Node 1, Wings Node 2, etc. so alerts identify the affected machine immediately.

Step 5: Monitor Wings-to-Panel Connectivity

Wings must authenticate and maintain connectivity with the Panel API. If a network partition isolates a node from the panel, Wings continues running game servers locally but cannot receive new commands or report status. This appears as all game servers on that node showing "offline" in the panel while actually still running.

Use a cron job on each Wings node that verifies it can reach the panel:

#!/bin/bash
# /usr/local/bin/wings-connectivity-check.sh
PANEL_URL="https://panel.yourdomain.com"

STATUS=$(curl -s -o /dev/null -w "%{http_code}" \
  --connect-timeout 10 "${PANEL_URL}/api/client")

if [ "$STATUS" -eq 200 ] || [ "$STATUS" -eq 401 ]; then
  # 401 = panel is reachable but this endpoint needs auth — that's fine
  curl -s https://vigilmon.online/heartbeat/YOUR_WINGS_CONNECTIVITY_HEARTBEAT_NODE1
fi

Schedule every minute and create a Cron Heartbeat in Vigilmon per node.

Step 6: Monitor Game Server Allocation Ports

Each game server is assigned a TCP/UDP port allocation from your node's IP. Players connect directly to these ports. If a port conflict arises (another service grabbed the port) or the container failed to bind, players cannot connect even when the panel shows the server as "running."

For your most critical game servers, add TCP port monitors:

1. Click Add Monitor → TCP Port.
2. Set Host to the node's public IP.
3. Set Port to the game server's allocated port (e.g., 25565 for Minecraft Java, 27015 for CS2).
4. Set Check interval to 2 minutes.
5. Click Save.

Name each monitor with the server name and port: Minecraft Survival - :25565. When a game server crashes or its container fails to start, the TCP monitor catches it within 2 minutes.

Step 7: Monitor the File Upload Service

Pelican Panel includes a file manager that lets server owners upload mods, world saves, and configuration files via the web UI. This goes through Wings' file API. If Wings is healthy but its file upload handler fails (permissions issue, disk full, or connection timeout), uploads silently fail in the UI.

Add a Wings file API health check:

#!/bin/bash
# /usr/local/bin/wings-file-check.sh
NODE_URL="https://node1.yourdomain.com:8443"
WINGS_TOKEN="your-wings-token"
SERVER_UUID="your-test-server-uuid"  # use a dedicated monitoring server

STATUS=$(curl -s -o /dev/null -w "%{http_code}" \
  "${NODE_URL}/api/servers/${SERVER_UUID}/files/list?directory=/" \
  -H "Authorization: Bearer ${WINGS_TOKEN}")

if [ "$STATUS" -eq 200 ]; then
  curl -s https://vigilmon.online/heartbeat/YOUR_FILE_API_HEARTBEAT_ID
fi

Schedule every 5 minutes and create a matching Cron Heartbeat.

Step 8: Monitor TLS Certificate Expiry

Pelican Panel, Wings nodes, and any game servers with custom domains all need valid TLS. An expired Wings certificate causes the panel to lose its connection to the node entirely — the same catastrophic failure as a Wings crash.

Add a certificate monitor for each HTTPS endpoint:

1. Panel: https://panel.yourdomain.com (covered in Step 1)
2. Each Wings node: https://node1.yourdomain.com:8443

For Wings node certificates:

1. Click Add Monitor → HTTP / HTTPS.
2. Set URL to https://node1.yourdomain.com:8443.
3. Enable Monitor SSL certificate with 21-day expiry alert.
4. Click Save.

If Wings uses Let's Encrypt via Caddy or certbot, also add a post-renewal heartbeat:

# /etc/letsencrypt/renewal-hooks/post/vigilmon-notify.sh
curl -s https://vigilmon.online/heartbeat/YOUR_CERT_RENEWAL_HEARTBEAT_ID

Step 9: Configure Alert Channels

1. Go to Alert Channels in Vigilmon and add Slack, Discord (via webhook), email, or PagerDuty.
2. Set Wings daemon monitors to alert on 1 failure — a single failed Wings check means players on that node may be disconnecting.
3. Set MySQL and Redis TCP monitors to alert on 1 failure.
4. Set game server allocation port monitors to alert after 2 consecutive failures to avoid alerting on brief game server restarts.
5. Set TLS certificate monitors to alert on 1 failure.
6. Create an on-call escalation: Discord/Slack immediately, email after 3 minutes, PagerDuty after 8 minutes for Wings failures.

Summary

| Monitor | Target | What It Catches | |---|---|---| | Panel web UI | https://panel.domain | nginx/PHP-FPM crash, panel inaccessible | | Panel API | /api/client | API broken, queue workers can't report status | | MySQL TCP | :3306 | Database down, all panel operations fail | | Redis TCP | :6379 | Queue/session failure, commands not processing | | Wings Node 1 HTTP | :8443 | All game servers on node 1 unreachable | | Wings Node 2 HTTP | :8443 | All game servers on node 2 unreachable | | Wings connectivity heartbeat | Cron per node | Node isolated from panel | | Game server port | Node IP:allocated port | Server crashed, container not listening | | File upload API heartbeat | Wings file API | File manager broken for that node | | Panel TLS cert | https://panel.domain | Certificate expiry | | Wings node TLS cert | https://nodeN.domain:8443 | Wings TLS failure, node disconnected from panel |

Pelican Panel makes game server management straightforward, but the distributed Wings architecture means a node failure is invisible at the panel level. With Vigilmon watching Wings daemons, allocation ports, and the panel-to-node connection, you'll know exactly which node is down and why — before your players open a support ticket.