tutorial

Monitoring Hawtio with Vigilmon

Hawtio is an open-source web console for managing JVM applications, Camel routes, and ActiveMQ brokers — but the console itself, its Jolokia bridge, and its JMX layer can each fail independently. Here's how to monitor Hawtio and the JVM infrastructure it manages with Vigilmon.

Hawtio is a lightweight, plugin-based web console for managing and monitoring Java and JVM-based applications. It provides a browser UI for JMX MBean inspection, Apache Camel route management, ActiveMQ broker monitoring, and OSGi container control — all through a Jolokia JMX-HTTP bridge. When the Hawtio console goes down, your operations team loses visibility into every JVM application it manages. Vigilmon monitors the Hawtio web console, its Jolokia bridge, JVM metrics endpoints, and the services it connects to so you know immediately when any layer of your Java observability stack fails.

What You'll Set Up

  • Hawtio web console availability monitoring on port 8080
  • JVM metrics endpoint health checks
  • JMX MBean browser service monitoring
  • Camel route monitoring integration health
  • ActiveMQ broker connectivity checks
  • OSGi container health monitoring
  • Jolokia JMX-HTTP bridge service monitoring
  • Log viewer endpoint availability

Prerequisites

  • Hawtio 4.x deployed as a standalone WAR, Spring Boot app, or in a Karaf/WildFly/Quarkus container
  • Hawtio accessible on port 8080 (or your configured port)
  • Jolokia agent active (bundled in most Hawtio deployments)
  • A free Vigilmon account

Step 1: Monitor the Hawtio Web Console

The Hawtio web console is the primary management interface for your JVM applications. Monitor its availability on port 8080:

  1. Log in to vigilmon.online and click Add Monitor.
  2. Set Type to HTTP / HTTPS.
  3. Enter your Hawtio URL: http://hawtio.yourdomain.com:8080/hawtio
  4. Set Check interval to 1 minute.
  5. Set Expected HTTP status to 200.
  6. Enable Response body keyword check and require hawtio in the response.
  7. Click Save.

If Hawtio is deployed as a Spring Boot application with a context path, adjust the URL accordingly:

http://hawtio.yourdomain.com:8080/actuator/health

Spring Boot's actuator health endpoint provides structured health information for Hawtio Spring Boot deployments.

For Hawtio deployed in WildFly or JBoss EAP:

http://hawtio.yourdomain.com:8080/hawtio/index.html

Verify the response contains the Hawtio application shell HTML rather than a WildFly error page.

Step 2: JVM Metrics Endpoint Health

Hawtio exposes JVM metrics through its Jolokia integration. Monitor the JVM metrics endpoint to verify the metrics collection layer is active:

  1. Click Add Monitor → HTTP / HTTPS.
  2. URL: http://hawtio.yourdomain.com:8080/hawtio/jolokia/read/java.lang:type=Memory
  3. Set Expected HTTP status to 200.
  4. Enable Response body keyword check and require "HeapMemoryUsage" in the response.
  5. Set Check interval to 2 minutes.

The Jolokia read endpoint for the JVM Memory MBean returns heap and non-heap memory usage:

{
  "request": {
    "mbean": "java.lang:type=Memory",
    "type": "read"
  },
  "value": {
    "HeapMemoryUsage": {
      "committed": 536870912,
      "init": 268435456,
      "max": 8589934592,
      "used": 234567890
    }
  },
  "status": 200
}

A successful response confirms both the JVM is running and Jolokia can read MBean attributes. If the JVM runs out of heap memory or a GC pause freezes the process, this endpoint stops responding.

Step 3: JMX MBean Browser Service

The JMX MBean browser is Hawtio's core feature — it lets operators inspect and modify MBean attributes and invoke operations. Monitor the MBean browser service health:

  1. Add an HTTP monitor for the Jolokia list endpoint: 
    http://hawtio.yourdomain.com:8080/hawtio/jolokia/list
  2. Set Expected HTTP status to 200.
  3. Enable Response body keyword check and require "java.lang" in the response (the JVM platform MBeans are always present).
  4. Set Check interval to 5 minutes.

The /list endpoint returns the full MBean registry. Because it can return several megabytes of JSON for complex JVM deployments, use body keyword matching rather than full response validation — checking for "java.lang" confirms the registry is populated without processing the full payload.

If your Hawtio deployment requires authentication to access Jolokia:

  1. In Vigilmon monitor settings, add a Basic auth header:
    • Username: your Hawtio operator username
    • Password: the corresponding password
    • Or use Authorization: Bearer with a service token if Hawtio is configured for token authentication.

Step 4: Camel Route Monitoring Integration

If your environment uses Apache Camel (standalone, Spring Boot, or Karaf), Hawtio provides Camel route inspection through JMX. Monitor Camel route health:

  1. Add an HTTP monitor for the Camel context MBean: 
    http://hawtio.yourdomain.com:8080/hawtio/jolokia/read/org.apache.camel:context=*,type=context,name=*
  2. Set Expected HTTP status to 200.
  3. Enable Response body keyword check and require "Started" in the response to verify at least one Camel context is in the Started state.
  4. Set Check interval to 2 minutes.

For a specific Camel context named camel-1:

http://hawtio.yourdomain.com:8080/hawtio/jolokia/read/org.apache.camel:context=camel-1,type=context,name="camel-1"/State

This returns "Started", "Stopped", or "Suspended". Set Vigilmon's body keyword check to require "Started" — any other state is an operational problem.

To monitor a specific route's exchange count (to detect a route that stopped processing):

http://hawtio.yourdomain.com:8080/hawtio/jolokia/read/org.apache.camel:context=camel-1,type=routes,name="my-route"/ExchangesTotal

Combine with a cron heartbeat in your Camel route to confirm it's processing messages at the expected rate.

Step 5: ActiveMQ Broker Connectivity

Hawtio integrates with ActiveMQ Classic and ActiveMQ Artemis to display queue depths, consumer counts, and message rates. Monitor the broker connectivity through Jolokia:

ActiveMQ Classic:

  1. Add an HTTP monitor: 
    http://hawtio.yourdomain.com:8080/hawtio/jolokia/read/org.apache.activemq:type=Broker,brokerName=localhost
  2. Set Expected HTTP status to 200.
  3. Require "BrokerName" in the response body.
  4. Set Check interval to 1 minute.

ActiveMQ TCP connectivity (direct broker check):

  1. Click Add Monitor → TCP Port.
  2. Enter your ActiveMQ broker host and port 61616 (default OpenWire port).
  3. Set Check interval to 1 minute.

This confirms the broker is accepting connections even if Hawtio's JMX layer has issues.

Monitor queue depth via Jolokia:

http://hawtio.yourdomain.com:8080/hawtio/jolokia/read/org.apache.activemq:type=Broker,brokerName=localhost,destinationType=Queue,destinationName=YourQueue/QueueSize

Use Vigilmon's body keyword check to verify the queue size is within expected bounds. For dead-letter queues, alert if QueueSize is non-zero.

Step 6: OSGi Container Health

For Hawtio deployments running inside an Apache Karaf OSGi container, monitor the OSGi framework through Jolokia:

  1. Add an HTTP monitor: 
    http://hawtio.yourdomain.com:8080/hawtio/jolokia/read/osgi.core:type=framework,version=1.7,Framework=*
  2. Set Expected HTTP status to 200.
  3. Require "FrameworkStartLevel" in the response.

Monitor bundle states to catch failed bundles:

http://hawtio.yourdomain.com:8080/hawtio/jolokia/exec/osgi.core:type=bundleState,version=1.7,Framework=*/listBundles

A healthy Karaf container has all bundles in ACTIVE state. Bundles in RESOLVED or INSTALLED state that should be ACTIVE indicate a dependency or configuration problem.

For Karaf-specific health, also monitor the Karaf shell port:

  1. Click Add Monitor → TCP Port.
  2. Enter your Karaf host and SSH port 8101.
  3. A successful TCP connection confirms the Karaf SSH shell is available for remote management.

Step 7: Jolokia JMX-HTTP Bridge

The Jolokia bridge is the core of Hawtio's JMX access — all MBean reads, writes, and exec operations flow through it. Monitor the Jolokia bridge health endpoint directly:

  1. Add an HTTP monitor: 
    http://hawtio.yourdomain.com:8080/hawtio/jolokia/version
  2. Set Expected HTTP status to 200.
  3. Enable Response body keyword check and require "jolokia" in the response.
  4. Set Check interval to 1 minute.

The /version endpoint returns Jolokia's version and configuration without reading any MBeans:

{
  "request": { "type": "version" },
  "value": {
    "agent": "1.7.2",
    "protocol": "7.2",
    "config": {
      "maxDepth": "15",
      "maxCollectionSize": "0"
    }
  },
  "status": 200
}

This is the lightest Jolokia probe — it confirms the HTTP bridge is operational without touching the JVM's MBean registry. If Jolokia fails while the underlying JVM is still running, this monitor alerts immediately while the web console monitor may still return 200 (serving cached static assets).

Step 8: Log Viewer Endpoint Availability

Hawtio's log viewer plugin displays application logs from the java.util.logging and log4j/logback systems through JMX. Monitor the log viewer endpoint:

  1. Add an HTTP monitor for: 
    http://hawtio.yourdomain.com:8080/hawtio/jolokia/read/io.hawt.log:type=Logs
  2. Set Expected HTTP status to 200.
  3. Enable Response body keyword check and require "Logs" in the response.
  4. Set Check interval to 5 minutes.

If the log viewer MBean is not registered (which happens when the Hawtio logging plugin fails to start), Jolokia returns a 404 with an error object — Vigilmon catches this as a non-200 response.

Step 9: Configure Alert Channels

  1. Go to Alert Channels in Vigilmon and add Slack, email, PagerDuty, or webhook.
  2. Create two alert groups:
    • hawtio-console: web console and Jolokia version — for operations team Slack channel.
    • hawtio-services: Camel, ActiveMQ, OSGi — for developer/middleware team channel.
  3. For the Jolokia bridge and ActiveMQ TCP monitors, set Consecutive failures before alert to 1 — these are immediately impactful failures.
  4. For the Camel and OSGi endpoint monitors, set Consecutive failures before alert to 2 to absorb brief GC pauses or context restarts.

Summary

| Monitor | Target | What It Catches | |---|---|---| | Web console | /hawtio or /hawtio/index.html | Hawtio UI unavailable | | JVM metrics | Jolokia /read/java.lang:type=Memory | JVM crash, heap exhaustion | | MBean browser | Jolokia /list | JMX registry failure | | Camel context | Jolokia Camel context MBean | Route stopped or suspended | | ActiveMQ (JMX) | Jolokia ActiveMQ broker MBean | Broker disconnected from JMX | | ActiveMQ (TCP) | TCP port 61616 | Broker down entirely | | OSGi framework | Jolokia OSGi framework MBean | Karaf bundle failures | | Jolokia bridge | Jolokia /version | JMX-HTTP bridge failure | | Log viewer | Jolokia log MBean | Logging plugin failure |

Hawtio is both a management console and an observability platform for your JVM stack — which means when Hawtio itself has problems, you lose your window into everything it monitors. With Vigilmon watching the Hawtio web console, Jolokia bridge, Camel routes, ActiveMQ broker, and OSGi container independently, you maintain external observability even when Hawtio's own instrumentation is the thing that's failing.

Monitor your app with Vigilmon

Free plan — 5 monitors, no credit card required. Up and running in 60 seconds.

Start free →
← Back to all articles