Monitoring Joget Low-Code BPM with Vigilmon

Joget is an open source, Java-based low-code/no-code application development and workflow platform — widely used in government agencies, universities, and enterprises across Southeast Asia for building e-government services, HR workflows, procurement approvals, and student management processes. When you self-host Joget, you're running a Spring-based Java application on Apache Tomcat, backed by MySQL, with a plugin architecture that extends the platform with custom form elements, workflow actions, and data list columns. Any layer can fail silently: Tomcat JVM OOM, MySQL connectivity failure, a plugin activation error that breaks published apps, or a stalled workflow process that goes unnoticed for days. Vigilmon gives you full-stack monitoring across every Joget component.

What You'll Set Up

• HTTP uptime monitor for the Joget/Tomcat web application
• MySQL database connectivity and query latency monitor
• Active workflow process health and stall detection
• Form submission success rate monitor
• Joget App Builder UI availability check
• Plugin load health verification
• JVM heap memory and GC health monitor
• Active user session count monitor
• Workflow task completion rate and overdue task alert
• Joget/Java version currency check

Prerequisites

• Joget DX (8 or 9) running on Apache Tomcat
• MySQL database accessible (default port 3306)
• Joget web interface accessible via HTTP/HTTPS
• A free Vigilmon account

Step 1: Monitor the Joget/Tomcat Web Application

The Joget web interface is how your users access published apps, submit workflow forms, and track their tasks. An HTTP monitor on the Joget login page immediately detects Tomcat crashes and application errors.

1. Log in to vigilmon.online and click Add Monitor.
2. Set Type to HTTP / HTTPS.
3. Enter the Joget URL: https://joget.yourdomain.com/jw/web/userview/ (or http://your-server-ip:8080/jw/web/userview/).
4. Set Check interval to 1 minute.
5. Set Expected HTTP status to 200.
6. Under Keyword check, enter Joget to verify the app portal loads correctly.
7. Enable Monitor SSL certificate and set the expiry alert to 21 days.
8. Click Save.

For a deeper check, use Joget's built-in API health endpoint:

1. Add a second monitor with URL: https://joget.yourdomain.com/jw/web/json/workflow/currentUsername.
2. Expected HTTP status: 200 (returns {"username":"anonymous"} for unauthenticated calls).
3. Keyword check: username

This verifies the Joget workflow engine is running and responding to API requests, not just that Tomcat's default page is up.

Step 2: Monitor MySQL Database Health

MySQL (or MariaDB) stores everything Joget manages — app definitions, form schemas, workflow process instances and task states, form submission data, user/role data, and audit logs. A MySQL failure is a complete Joget outage.

Add a TCP monitor for MySQL connectivity:

1. Click Add Monitor → TCP Port.
2. Host: your-server-ip.
3. Port: 3306 (MySQL default).
4. Check interval: 1 minute.
5. Click Save.

For a richer check that verifies Joget can query the workflow database:

#!/bin/bash
# /opt/joget/scripts/mysql-health-check.sh

RESULT=$(mysql -u joget -p"$JOGET_DB_PASSWORD" jwdb \
  --skip-column-names -s \
  -e "SELECT COUNT(*) FROM app_package;" 2>/dev/null)

if [ -n "$RESULT" ]; then
  curl -fsS "https://vigilmon.online/api/push/YOUR_MYSQL_TOKEN"
fi

* * * * * /opt/joget/scripts/mysql-health-check.sh

Step 3: Monitor Active Workflow Processes

Joget's workflow engine drives all automated processes — HR onboarding, procurement approvals, compliance workflows, and student registrations. Stalled workflow processes mean tasks never reach their assignees, approvals never complete, and forms never get processed.

Query for stalled processes via the Joget API or directly against MySQL:

-- Stalled workflow processes: running > 24 hours without completion
SELECT COUNT(*) AS stalled_processes
FROM wf_process_instance
WHERE state = 'started'
  AND created_date < DATE_SUB(NOW(), INTERVAL 24 HOUR);

#!/bin/bash
# /opt/joget/scripts/workflow-health-check.sh

STALLED=$(mysql -u joget -p"$JOGET_DB_PASSWORD" jwdb \
  --skip-column-names -s \
  -e "SELECT COUNT(*) FROM wf_process_instance WHERE state = 'started' AND created_date < DATE_SUB(NOW(), INTERVAL 24 HOUR);" 2>/dev/null)

# Alert (by stopping heartbeat) if stalled processes exceed threshold
if [ -n "$STALLED" ] && [ "$STALLED" -lt 5 ]; then
  curl -fsS "https://vigilmon.online/api/push/YOUR_WORKFLOW_TOKEN"
else
  echo "Stalled workflow count: ${STALLED:-unknown}"
fi

*/10 * * * * /opt/joget/scripts/workflow-health-check.sh

Tune the 5 threshold to match your organization's tolerance — some long-running processes (multi-day approval chains) may legitimately exceed 24 hours.

Step 4: Monitor Form Submission Success

Form submissions are the primary data entry mechanism in Joget low-code apps. If the form submission pipeline is broken — due to a MySQL write failure, a plugin error, or an app configuration issue — users silently lose their submitted data.

Use the Joget API to submit a synthetic form and verify the response:

#!/bin/bash
# /opt/joget/scripts/form-submit-health-check.sh

# Get auth token
TOKEN=$(curl -sf -X POST "https://joget.yourdomain.com/jw/web/json/v2/user/login" \
  -d "username=monitor&password=$MONITOR_PASSWORD" \
  | jq -r '.token')

if [ -z "$TOKEN" ] || [ "$TOKEN" = "null" ]; then
  echo "Auth failed"
  exit 1
fi

# Check form listing API (non-destructive)
STATUS=$(curl -sf -o /dev/null -w "%{http_code}" \
  -H "api_id: $JOGET_API_ID" \
  -H "api_key: $JOGET_API_KEY" \
  "https://joget.yourdomain.com/jw/web/json/app/health-monitor/form/health_check_form/data")

if [ "$STATUS" = "200" ]; then
  curl -fsS "https://vigilmon.online/api/push/YOUR_FORM_TOKEN"
fi

Create a minimal health_check_form app in Joget specifically for monitoring — a single-field form that verifies the full form engine stack without polluting real app data.

Step 5: Monitor the App Builder UI

Joget's App Builder is the drag-and-drop interface used to create and modify apps. If the builder is unavailable, your developers can't update published apps or create new workflows. Monitor it separately from the user-facing app portal:

1. Click Add Monitor → HTTP / HTTPS.
2. URL: https://joget.yourdomain.com/jw/web/console/apps.
3. Check interval: 5 minutes (builder issues are less urgent than portal outages).
4. Expected HTTP status: 200 (redirects to login are acceptable — check for 302 to login).
5. Keyword check: Joget or App Center.
6. Click Save.

A 500 error on the App Builder console while the portal returns 200 usually indicates a specific Java plugin or Spring component failure.

Step 6: Monitor Plugin Load Health

Joget's plugin architecture extends the platform with custom form elements, process tools, and data list columns. A plugin that fails to activate can break published apps that depend on it — causing form rendering failures, data list errors, or workflow step failures.

Check plugin status via the Joget API:

#!/bin/bash
# /opt/joget/scripts/plugin-health-check.sh

# List all plugins and check for any in error state
PLUGIN_STATUS=$(curl -sf \
  -H "api_id: $JOGET_API_ID" \
  -H "api_key: $JOGET_API_KEY" \
  "https://joget.yourdomain.com/jw/web/json/plugin/list" 2>/dev/null)

# Count plugins in error state
ERROR_COUNT=$(echo "$PLUGIN_STATUS" | jq '[.[] | select(.status == "ERROR")] | length' 2>/dev/null)

if [ -n "$ERROR_COUNT" ] && [ "$ERROR_COUNT" -eq 0 ]; then
  curl -fsS "https://vigilmon.online/api/push/YOUR_PLUGIN_TOKEN"
else
  echo "Plugin errors detected: ${ERROR_COUNT:-unknown}"
fi

*/15 * * * * /opt/joget/scripts/plugin-health-check.sh

Step 7: Monitor JVM Heap Memory

Joget runs on Tomcat, and Java heap exhaustion is a common failure mode for Java web applications under load. Heap OOM causes OutOfMemoryError exceptions that can corrupt in-flight form submissions and crash Tomcat.

Add a cron heartbeat that monitors JVM heap and only pings Vigilmon when heap usage is below 85%:

1. Create a Cron / Heartbeat monitor named Joget JVM Heap Health with a 5-minute interval.
2. Copy the heartbeat URL.

Script:

#!/bin/bash
# /opt/joget/scripts/jvm-heap-check.sh

TOMCAT_PID=$(pgrep -f "catalina\|tomcat" | head -1)

if [ -z "$TOMCAT_PID" ]; then
  echo "Tomcat not running"
  exit 1
fi

# Get heap usage percentage via jstat
HEAP_PCT=$(jstat -gc "$TOMCAT_PID" | awk 'NR==2 {
  used=$3+$4+$6+$8
  total=$5+$7+$9
  printf "%.0f", (used/total)*100
}')

if [ "$HEAP_PCT" -lt 85 ]; then
  curl -fsS "https://vigilmon.online/api/push/YOUR_JVM_TOKEN"
else
  echo "JVM heap at ${HEAP_PCT}% — alert threshold exceeded"
fi

*/5 * * * * /opt/joget/scripts/jvm-heap-check.sh

Ensure JAVA_HOME is set in the cron environment, or use the full path to jstat:

JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64
PATH=$JAVA_HOME/bin:$PATH
*/5 * * * * /opt/joget/scripts/jvm-heap-check.sh

Step 8: Monitor Active User Sessions

Active session count reflects platform usage. A sudden drop during business hours (from normal 50 to 0 sessions) indicates a login failure or Tomcat session manager issue. A sudden spike can indicate a session leak or unusual traffic.

-- Active Tomcat sessions in Joget (if using DB session store)
-- Or check Tomcat manager API
SELECT COUNT(*) AS active_sessions
FROM app_session
WHERE created_date > DATE_SUB(NOW(), INTERVAL 8 HOUR);

Alternatively, query Tomcat's manager application for session count:

#!/bin/bash
# /opt/joget/scripts/session-count-check.sh

SESSION_INFO=$(curl -sf -u admin:"$TOMCAT_MANAGER_PASSWORD" \
  "http://localhost:8080/manager/text/list" 2>/dev/null | grep "jw")

ACTIVE_SESSIONS=$(echo "$SESSION_INFO" | grep -oP '\d+(?= active sessions)')

# Alert if sessions are anomalously high (e.g., > 500)
if [ -n "$ACTIVE_SESSIONS" ] && [ "$ACTIVE_SESSIONS" -lt 500 ]; then
  curl -fsS "https://vigilmon.online/api/push/YOUR_SESSION_TOKEN"
fi

Step 9: Monitor Workflow Task Completion Rate

Workflow tasks that pile up or go overdue indicate SLA breaches in your business processes — HR tickets not resolved, procurement approvals not granted on time, or compliance forms not submitted by their deadline.

-- Overdue workflow tasks in Joget
SELECT COUNT(*) AS overdue_tasks
FROM wf_assignment
WHERE due_date < NOW()
  AND finish_date IS NULL;

#!/bin/bash
OVERDUE=$(mysql -u joget -p"$JOGET_DB_PASSWORD" jwdb \
  --skip-column-names -s \
  -e "SELECT COUNT(*) FROM wf_assignment WHERE due_date < NOW() AND finish_date IS NULL;" 2>/dev/null)

if [ -n "$OVERDUE" ] && [ "$OVERDUE" -lt 20 ]; then
  curl -fsS "https://vigilmon.online/api/push/YOUR_TASK_TOKEN"
else
  echo "Overdue tasks: ${OVERDUE:-unknown}"
fi

Tune the 20 threshold to match your organization's SLAs — some workflows have inherently longer timelines than others.

Step 10: Configure Alerting

With monitors in place, configure alert escalation in Vigilmon:

1. Go to Alert Channels → Add Channel.
2. Add your primary DevOps channel (email, Slack #devops, PagerDuty).
3. Add a BPM/app owners channel (Slack #bpm-ops or email to app administrators).
4. Add a business process owners channel for task SLA alerts.

Recommended alert thresholds:

| Monitor | Threshold | Channel | |---|---|---| | Joget HTTP portal | Any failure | Primary on-call | | MySQL TCP | Any failure | Primary on-call | | JVM heap >85% | Heartbeat miss | DevOps | | Plugin load errors | Heartbeat miss | App Owners | | App Builder HTTP | Any failure | App Owners | | Stalled workflows >5 | Heartbeat miss | BPM Ops | | Overdue tasks >20 | Heartbeat miss | Process Owners | | Form submission | Heartbeat miss | App Owners | | Active sessions anomaly | Heartbeat miss | DevOps |

Use immediate alerts for the HTTP portal monitor and MySQL TCP monitor. Use 2-failure confirmation for JVM heap and session count monitors to avoid transient spikes triggering false alarms.

Conclusion

Joget's Java/Tomcat/MySQL/plugin stack has failure modes at every layer. JVM OOM can crash Tomcat while the reverse proxy still returns cached responses. A single broken plugin can silently break published apps without crashing the platform. Stalled workflow processes can sit unnoticed for days. And overdue tasks accumulate to SLA-breaching counts that only surface when someone complains.

The monitoring setup above covers every critical dimension: user-facing availability (portal, app builder), infrastructure health (MySQL, JVM heap), business process integrity (workflow stalls, overdue tasks, form submissions), and plugin ecosystem health. With Vigilmon running across all ten monitors, you'll catch Joget failures before they impact your government services, HR processes, or enterprise workflows.