Monitoring Activiti with Vigilmon: Runtime Bundle Health, REST API, Query Service, and Kubernetes Pod Status

Activiti is the open source BPMN 2.0 workflow engine originally created at Alfresco and now evolved into Activiti Cloud — a set of Spring Boot microservices designed to run BPMN process automation at scale in Kubernetes. Created by Tom Baeyens (inventor of jBPM) and released in 2010, Activiti became one of the most widely adopted open source workflow engines in enterprise Java. Activiti 7/Cloud decomposed the monolithic engine into microservices: a Runtime Bundle that runs the BPMN engine, a Query Service backed by Elasticsearch for process state queries, an Audit Service for compliance event storage, and Cloud Connectors for external service task execution. When the Runtime Bundle crashes, all process execution stops. When the Query Service fails, process state becomes invisible. When Cloud Connectors go offline, workflow instances stall at service tasks. Vigilmon gives you external visibility into Activiti Cloud's health across all its microservice surfaces.

What You'll Set Up

Runtime Bundle Spring Boot actuator health monitoring
REST API availability check for process management operations
Activiti Cloud Query Service health check
Audit Service uptime monitoring
SSL certificate monitoring for HTTPS deployments
Kubernetes-aware alerting for pod-level failures

Prerequisites

Activiti Cloud deployed (Runtime Bundle, Query Service, Audit Service, and optional Connectors)
Spring Boot Actuator enabled on each service (included by default)
Services accessible over HTTP/HTTPS with reachable domains or Kubernetes ingress URLs
A free account at vigilmon.online

Step 1: Understand Activiti Cloud's Microservice Architecture

Activiti Cloud consists of several independently deployed Spring Boot microservices:

| Service | Default port | Role | |---|---|---| | Runtime Bundle | 8080 | BPMN engine — process start, task completion, signals | | Query Service | 8182 | Elasticsearch-backed process state queries | | Audit Service | 8181 | Process event storage for compliance and audit | | Cloud Connectors | 8080 (per connector) | External service task implementations | | Gateway (optional) | 80/443 | API gateway routing to microservices |

Each service exposes a Spring Boot Actuator /actuator/health endpoint. Monitor each service independently — a failure in one service doesn't necessarily mean all services are down.

Step 2: Monitor the Runtime Bundle Health

The Runtime Bundle is the core of Activiti Cloud — it embeds the Activiti Core BPMN engine and exposes a REST API for process management. When it's down, no process instances can be created, no tasks completed, and no signals sent:

curl http://runtime-bundle.example.com/actuator/health
# Returns: {"status":"UP","components":{"db":{"status":"UP"},"rabbit":{"status":"UP"}}}

Log in to Vigilmon → Add Monitor → HTTP.
URL: https://runtime-bundle.example.com/actuator/health.
Check interval: 60 seconds.
Response timeout: 15 seconds.
Expected status: 200.
Keyword: "status":"UP".
Label: Activiti Runtime Bundle health.
Click Save.

This monitor catches:

Runtime Bundle pod crashes (OOM kill, CrashLoopBackOff)
Database connectivity loss causing the engine to refuse operations
RabbitMQ/Kafka connectivity loss causing the event stream health check to fail
JVM startup failures from Liquibase migration errors

Alert sensitivity: Set to trigger after 1 consecutive failure — a Runtime Bundle outage means all process execution has stopped.

Step 3: Monitor the Runtime Bundle REST API

The Runtime Bundle exposes a REST API for process management. Test a lightweight read-only endpoint to confirm the API is responding:

# Check process definitions are accessible
curl -H "Authorization: Bearer <token>" \
  https://runtime-bundle.example.com/v1/process-definitions
# Returns JSON with process definition list

For monitoring without authentication complexity, use the actuator info endpoint:

curl https://runtime-bundle.example.com/actuator/info
# Returns: {} or build info JSON

Add Monitor → HTTP.
URL: https://runtime-bundle.example.com/actuator/info.
Check interval: 60 seconds.
Response timeout: 10 seconds.
Expected status: 200.
Label: Activiti Runtime Bundle REST.
Click Save.

Step 4: Monitor the Query Service

The Activiti Cloud Query Service provides fast process state queries backed by Elasticsearch. It receives events from the Runtime Bundle via the message broker (Kafka or RabbitMQ) and indexes them for querying. When the Query Service is unavailable, process state becomes invisible to end users and external systems:

curl http://query-service.example.com/actuator/health
# Returns: {"status":"UP","components":{"elasticsearch":{"status":"UP"},"rabbit":{"status":"UP"}}}

Add Monitor → HTTP.
URL: https://query-service.example.com/actuator/health.
Check interval: 60 seconds.
Response timeout: 15 seconds.
Expected status: 200.
Keyword: "status":"UP".
Label: Activiti Query Service health.
Click Save.

Elasticsearch dependency: The Query Service health includes Elasticsearch connectivity status. If Elasticsearch is down, the Query Service health will show "elasticsearch":{"status":"DOWN"} and the overall status will degrade to DOWN or UNKNOWN. This makes the actuator health check a useful proxy for Elasticsearch availability.

Step 5: Monitor the Audit Service

The Activiti Cloud Audit Service stores all process events for compliance and regulatory audit purposes. Event persistence lag or Audit Service failures create compliance audit gaps — processes were executed but no audit trail exists:

curl http://audit-service.example.com/actuator/health
# Returns: {"status":"UP","components":{"elasticsearch":{"status":"UP"}}}

Add Monitor → HTTP.
URL: https://audit-service.example.com/actuator/health.
Check interval: 2 minutes.
Response timeout: 15 seconds.
Expected status: 200.
Keyword: "status":"UP".
Label: Activiti Audit Service health.
Click Save.

Step 6: Monitor Cloud Connectors

Activiti Cloud Connectors implement external service tasks — they receive task activation events from the Runtime Bundle via the message broker and call external services (HTTP APIs, databases, legacy systems). If a connector goes offline, every workflow instance that reaches the corresponding service task stalls indefinitely:

Repeat the following for each deployed connector:

Add Monitor → HTTP.
URL: https://connector-email.example.com/actuator/health (adjust per connector).
Check interval: 60 seconds.
Expected status: 200.
Keyword: "status":"UP".
Label: Activiti Connector: email-service (use a descriptive name per connector type).
Click Save.

Connector naming convention: Name each connector monitor after the service task type it implements (e.g., email-connector, payment-connector, pdf-generator). When an alert fires for a specific connector, you immediately know which workflow instances are stalled and which external service to investigate.

Step 7: Monitor SSL Certificates

All Activiti Cloud microservices in production use HTTPS. Certificate expiry on any service causes that service's REST clients and browser users to fail:

openssl s_client -connect runtime-bundle.example.com:443 2>/dev/null | openssl x509 -noout -dates

Add Monitor → SSL Certificate.
Domain: runtime-bundle.example.com.
Alert when expiry is within: 30 days.
Alert again: 14 days, 7 days, 3 days, 1 day.
Click Save.

Repeat for each microservice domain: query-service.example.com, audit-service.example.com, and each connector domain.

Wildcard certificates: If all Activiti Cloud services share a wildcard certificate (*.example.com), you only need one SSL monitor on the apex domain. Wildcard certificates expire together, so one monitor covers the entire deployment.

Step 8: Configure Alerting

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

| Monitor | Trigger | Incident meaning | Action | |---|---|---|---| | Runtime Bundle health | Non-200 or "UP" missing | BPMN engine down; no process execution | Check K8s pod logs; verify DB and message broker connectivity | | Runtime Bundle REST | Non-200 | REST API unavailable; process management broken | Usually same root cause as health failure; check pod and ingress | | Query Service health | Non-200 or "UP" missing | Process state queries failing; Elasticsearch degraded | Check Query Service pod; verify Elasticsearch cluster health | | Audit Service health | Non-200 or "UP" missing | Compliance audit trail broken | Check Audit Service pod; verify Elasticsearch write access | | Cloud Connector (each) | Non-200 or "UP" missing | Service tasks of that type stalled in workflows | Check connector pod; verify external service dependency | | SSL Certificate | < 30 days to expiry | Certificate expiring | Renew certificate; test all service clients after renewal |

Alert after: 1 consecutive failure for the Runtime Bundle monitors. 2 consecutive failures for Query Service, Audit Service, and connector monitors.

Common Activiti Cloud Failure Modes and What Vigilmon Catches

| Scenario | Vigilmon monitor | |---|---| | Runtime Bundle pod OOM killed (K8s) | Runtime Bundle health and REST monitors fire immediately | | Database connection pool exhausted | Runtime Bundle health shows DB DOWN; all process operations fail | | RabbitMQ/Kafka broker unavailable | Runtime Bundle health shows message broker DOWN; Query/Audit fall behind | | Elasticsearch cluster down | Query Service and Audit Service health monitors fire | | Cloud Connector CrashLoopBackOff | Connector health monitor fires; stalled instances accumulate at that task | | Activiti upgrade Liquibase migration failure | Runtime Bundle fails to start; health monitor fires | | Kubernetes node failure (pod evicted) | Affected service health monitors fire; K8s reschedules pods | | Ingress controller misconfiguration | All externally-reachable monitors fire; internal pod health may be fine | | SSL certificate expires | SSL monitor alerts at 30-day threshold; HTTPS connections fail | | Message broker partition / lag | Not directly catchable externally — monitor message broker separately |

Kubernetes-Native Monitoring

Activiti Cloud is designed to run in Kubernetes. Vigilmon's external monitors complement Kubernetes-native observability:

Pod readiness probes: Configure Kubernetes readiness probes pointing to /actuator/health on each service. Kubernetes removes unready pods from service endpoints — external traffic never reaches a failing pod. Vigilmon monitors detect when all pods fail simultaneously (no healthy pod is reachable externally).
Liveness probes: Configure Kubernetes liveness probes to restart pods that become deadlocked. Pair with Vigilmon to detect probe-triggered restart loops.
Horizontal pod autoscaling: Activiti Cloud scales horizontally. If HPA scales the Runtime Bundle to 0 pods during a misconfiguration, Vigilmon's external monitor detects the resulting 503 before your users do.
PodDisruptionBudgets: Set PDBs to ensure rolling upgrades don't take all Runtime Bundle pods offline simultaneously. Vigilmon catches transient outages during PDB violations.

# Kubernetes readiness probe example for Runtime Bundle
readinessProbe:
  httpGet:
    path: /actuator/health
    port: 8080
  initialDelaySeconds: 30
  periodSeconds: 10
  failureThreshold: 3

Event Stream and Suspended Process Monitoring

Vigilmon monitors external availability. Event stream lag, suspended process instances, and connector task backlog require internal monitoring:

Message broker metrics: Monitor RabbitMQ queue depth or Kafka consumer group lag for the Activiti Cloud event topics. Alert when consumer lag exceeds a threshold — indicates the Query or Audit Service is falling behind.
Suspended process instances: Query the Runtime Bundle REST API for suspended process instances: GET /v1/process-instances?status=SUSPENDED. Alert when count grows — indicates systematic processing failures.
Connector task backlog: Monitor the Kafka/RabbitMQ queue depth for each connector's input topic. A growing queue means the connector is not consuming tasks fast enough.
Elasticsearch index health: Query GET /_cluster/health on Elasticsearch and alert when status is red — indicates data loss or index corruption affecting Query and Audit services.

Vigilmon catches infrastructure-level failures (services down, pods unreachable, certificates expired). Business process health and event stream lag require message broker and Elasticsearch internal monitoring.

Activiti Cloud is the distributed process automation backbone for Kubernetes-native Java applications — when the Runtime Bundle goes down, process instances freeze; when connectors go offline, service tasks stall; when the Query Service fails, process state becomes invisible. Vigilmon gives you the external health signal across every microservice surface before your users notice: Runtime Bundle availability, REST API health, Query and Audit Service uptime, connector availability, and SSL certificate expiry, so you can restore process execution and maintain audit compliance before business SLAs are breached.

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