Monitoring Activepieces with Vigilmon: Health Endpoint, Dashboard, Worker TCP & SSL Alerts

Activepieces is a self-hosted open-source workflow automation platform — an alternative to Make and Zapier — that lets teams build no-code automations connecting their apps, databases, and APIs through a visual flow editor. Engineering and operations teams use Activepieces to automate repetitive workflows: syncing CRM records, sending Slack notifications from external events, processing form submissions, routing support tickets, and orchestrating multi-step business processes. When Activepieces goes down, every automation stops executing — flows are not triggered, no actions are taken, and business processes that rely on automated handoffs stall silently until someone notices that the expected output (a Slack message, a CRM update, a database record) never arrived. Activepieces separates its API server from its worker processes: the web dashboard and API can appear healthy while workers are crashed and flows are queued but never executed. Vigilmon gives you external visibility into Activepieces's health endpoint, web dashboard, worker TCP port, and SSL certificate so failures are caught within 60 seconds.

What You'll Build

• A monitor on Activepieces's /api/v1/health endpoint
• An HTTP monitor for the Activepieces web dashboard
• A TCP monitor for the Activepieces worker process port
• SSL certificate monitoring for your Activepieces domain
• An alerting setup that distinguishes API failures from worker starvation

Prerequisites

• A running Activepieces instance with a public or network-reachable domain
• HTTPS configured (e.g., https://activepieces.example.com)
• A free account at vigilmon.online

Step 1: Verify Activepieces's Health Endpoint

Activepieces exposes a health check endpoint at /api/v1/health that confirms the application server is running and its backing services are reachable:

curl -i https://activepieces.example.com/api/v1/health

A healthy instance returns HTTP 200 with a JSON body. The health check confirms that the Activepieces NestJS application server is operational and the PostgreSQL database is reachable. A non-200 response or a timeout indicates the server process has crashed, the database is unreachable, or a required environment variable is missing.

PostgreSQL dependency: Activepieces stores all flow definitions, trigger configurations, run history, authentication tokens, piece credentials, and user accounts in PostgreSQL. A database failure makes the entire platform non-functional: no flows can be triggered, no flow history is accessible, and no new flows can be created or modified. The /api/v1/health endpoint is your primary indicator of platform health.

If /api/v1/health is not available in your version of Activepieces, use the root URL as a fallback availability check:

curl -i https://activepieces.example.com/
# Expected: HTTP 200 with the Activepieces dashboard HTML

Step 2: Create a Vigilmon HTTP Monitor for the Health Endpoint

1. Log in to Vigilmon → Add Monitor → HTTP.
2. URL: https://activepieces.example.com/api/v1/health.
3. Check interval: 60 seconds.
4. Response timeout: 15 seconds.
5. Expected status: 200.
6. Label: Activepieces Health.
7. Click Save.

This monitor catches:

• Activepieces NestJS application server crashes or OOM kills
• PostgreSQL connectivity failures — the database stores all flow definitions and credentials; a database outage means no flows execute
• Redis failures (used for queuing flow run jobs between the API server and worker processes) that cause flows to queue but never dispatch to workers
• Container restart loops triggered by misconfigured environment variables (AP_DB_URL, AP_ENCRYPTION_KEY, AP_FRONTEND_URL)
• Failed database migrations after an Activepieces version upgrade that prevent the server from starting

Step 3: Monitor the Activepieces Web Dashboard

The Activepieces web dashboard is the interface where team members build flows, manage connections to external services, monitor run history, and configure triggers. Monitor it independently from the API to catch reverse proxy failures and frontend asset serving problems:

1. Add Monitor → HTTP.
2. URL: https://activepieces.example.com.
3. Check interval: 60 seconds.
4. Expected status: 200.
5. Keyword: Activepieces.
6. Label: Activepieces Dashboard.
7. Click Save.

This monitor catches nginx or reverse proxy failures, Angular frontend serving failures, and CDN misconfiguration that prevents the dashboard from loading — even when the backend API is responding. A broken dashboard means no one can create or modify flows, inspect run failures, or manage external service credentials during an incident.

Step 4: Create a TCP Monitor for the Worker Process

Activepieces separates execution into two distinct services: the API server handles HTTP requests, manages flow definitions, and enqueues runs; worker processes pull queued runs from Redis and actually execute flow steps by calling piece actions (API calls, database queries, Slack messages, etc.). The API server and dashboard can be fully healthy while all workers are crashed, leaving every queued flow run in a permanent pending state that never executes.

In the default Activepieces Docker Compose deployment, worker processes connect to Redis on port 6379 (or a configured Redis port) — but the worker processes themselves do not expose an HTTP health endpoint. A TCP check against the Redis port that the workers depend on provides an indirect worker health signal:

1. Add Monitor → TCP.
2. Host: activepieces.example.com (or the Redis host if Redis is on a separate host).
3. Port: 6379 (or your configured Redis port).
4. Check interval: 60 seconds.
5. Response timeout: 10 seconds.
6. Label: Activepieces Redis / Worker Queue.
7. Click Save.

Note: In a typical Docker Compose Activepieces deployment, Redis is an internal service not exposed on an external port. If Redis is not network-reachable from Vigilmon's monitoring probes, skip this TCP monitor and instead set up a cron heartbeat: create a simple Activepieces flow that runs on a schedule and sends an HTTP POST to a Vigilmon cron monitor URL. If the flow executes successfully, Vigilmon receives the heartbeat. If workers are crashed, the heartbeat stops — Vigilmon alerts after the expected interval passes. This end-to-end flow heartbeat is a more reliable worker health signal than a TCP port check.

Step 5: Monitor SSL Certificates

An expired SSL certificate on your Activepieces instance breaks automation infrastructure across multiple vectors:

• The web dashboard becomes inaccessible, preventing flow management and debugging
• Webhook triggers that external services POST to your Activepieces instance fail with TLS errors — flows that depend on inbound webhooks never fire
• Any flow steps that call HTTPS URLs through the Activepieces HTTP piece may fail if the certificate is involved in outbound request validation
• Any CI/CD or operational scripts that call the Activepieces API to trigger flows or check run status fail with certificate errors

1. Add Monitor → SSL Certificate.
2. Domain: activepieces.example.com.
3. Alert when expiry is within: 30 days.
4. Alert again: 14 days, 7 days, 3 days, 1 day.
5. Click Save.

Step 6: Configure Alerting

In Vigilmon under Settings → Notifications, configure your alert channels:

| Monitor | Trigger | Action | |---|---|---| | /api/v1/health | Non-200 response | Check Activepieces container; inspect PostgreSQL and Redis connectivity; review NestJS logs | | Dashboard | Non-200 or keyword missing | Check nginx/reverse proxy; verify Angular assets served; inspect container logs | | Redis TCP | Connection refused or timeout | Restart Redis container; check Redis port and network config; inspect worker logs | | SSL certificate | < 30 days to expiry | Renew certificate; verify Let's Encrypt auto-renewal is functioning |

Alert after: 2 consecutive failures for HTTP monitors. 1 failure for the TCP monitor — a crashed Redis means all flow execution is halted and no self-recovery is possible without a restart.

Silent failure pattern: The most dangerous Activepieces failure is when the API and dashboard appear healthy but workers are crashed. Flows are submitted, appear as "running" in the UI, and queue indefinitely with no error message to alert team members. The only external signal is that the expected automation outputs (Slack messages, CRM updates, emails) never arrive. A cron heartbeat flow (described above) is the most reliable detection for this failure mode. Configure it alongside your HTTP and TCP monitors for complete coverage.

Common Activepieces Failure Modes and What Vigilmon Catches

| Scenario | Vigilmon monitor | |---|---| | NestJS API server crash | Health endpoint unreachable; alert within 60 s | | PostgreSQL down | Health endpoint fails; no flows can be triggered or viewed | | Redis down | TCP monitor fires; flows queue in database but workers cannot claim them | | Worker processes crashed (OOM or panic) | API healthy; Redis accessible; flows queued but never executed; cron heartbeat stops | | Container restart loop | Health endpoint intermittently unavailable; flapping alerts | | Reverse proxy misconfiguration | Dashboard monitor fires; health endpoint may still pass via direct port | | Angular build failure after upgrade | Dashboard keyword check fails; blank page served | | Missing AP_ENCRYPTION_KEY after migration | Flows with saved credentials fail to decrypt; execution errors on credential-using steps | | Webhook trigger TLS error | Inbound webhooks fail; affected flows never fire; no dashboard alert | | SSL certificate expires | SSL monitor alerts at 30 days; inbound webhooks and dashboard blocked | | DNS misconfiguration | All monitors fire simultaneously | | Piece version incompatibility after upgrade | Individual flow steps fail; health endpoint still 200; run history shows errors | | Flow run history disk pressure | Older runs purged; active run processing may be degraded |

Workflow automation is only valuable when it executes reliably — a silent Activepieces worker failure means every scheduled automation and every inbound webhook trigger stops executing, with no error visible to anyone until a business process fails to produce its expected output. Vigilmon watches Activepieces's health endpoint, web dashboard, worker queue, and SSL certificate so you're alerted within 60 seconds of any failure, before missed automation runs become missed business processes.

Start monitoring Activepieces in under 5 minutes — register free at vigilmon.online.