tutorial

Monitoring NeoLoad with Vigilmon: Controller Health, Test API, TCP Port Checks & SSL Alerts

How to monitor NeoLoad with Vigilmon — controller uptime, REST API availability, TCP port checks, and SSL certificate alerts for enterprise load testing pipelines.

NeoLoad is Tricentis's enterprise load testing platform — orchestrating thousands of virtual users, integrating with CI/CD pipelines, and generating performance reports that shape release decisions. When the NeoLoad Controller or Web UI goes down, performance test runs fail silently, scheduled regression tests never start, and CI pipelines stall waiting for results that never arrive. Vigilmon gives you external visibility into NeoLoad before your QA team notices: the web UI health endpoint, REST API availability, TCP port reachability, and SSL certificate expiry.

What You'll Build

  • A monitor on NeoLoad's web UI health endpoint to catch controller failures
  • A monitor on the NeoLoad REST API to detect API-layer degradation
  • A TCP port check for the NeoLoad Controller communication port
  • SSL certificate monitoring for your NeoLoad domain
  • An alerting setup that distinguishes controller failures from test infrastructure problems

Prerequisites

  • A running NeoLoad Web or NeoLoad Controller instance accessible via HTTPS
  • A domain pointing to NeoLoad (e.g., https://neoload.example.com)
  • A free account at vigilmon.online

Step 1: Verify NeoLoad's Health Endpoints

NeoLoad Web exposes a health check endpoint that returns system status. Verify it is responding:

# Check NeoLoad Web health endpoint
curl -I https://neoload.example.com/api/v1/health

# Check the main web UI
curl -I https://neoload.example.com

A healthy NeoLoad Web instance returns HTTP 200 from the health endpoint. The main UI returns 200 when the frontend is serving correctly. If you are running the on-premises NeoLoad Controller (not NeoLoad Web), check that the controller's REST API port is reachable:

# NeoLoad Controller REST API (default port 7400)
curl -I https://neoload.example.com:7400/api/v1/workspaces

NeoLoad version note: NeoLoad Web uses port 443 (standard HTTPS). The legacy on-premises NeoLoad Controller uses port 7400 for its REST API and port 7500 for design communication. Check your NeoLoad installation guide for the exact ports in use.

Step 2: Create a Vigilmon HTTP Monitor for the Web UI

  1. Log in to Vigilmon → Add Monitor → HTTP.
  2. URL: https://neoload.example.com.
  3. Check interval: 60 seconds.
  4. Response timeout: 15 seconds (NeoLoad Web can be slow during active test runs).
  5. Expected status: 200.
  6. Keyword: NeoLoad (appears in the page title of the web UI).
  7. Click Save.

This monitor catches:

  • NeoLoad Web process crashes or JVM out-of-memory errors
  • Container restarts that leave the port temporarily unavailable
  • Misconfigured reverse proxy rules after deployment
  • License server communication failures that prevent the UI from loading

Alert sensitivity: Set alerts to trigger after 2 consecutive failures to filter transient timeouts during heavy test execution.

Step 3: Create a Vigilmon HTTP Monitor for the REST API

The NeoLoad REST API powers all CI/CD integrations — Jenkins plugins, GitHub Actions workflows, and custom scripts all interact with the API to trigger tests and fetch results. API degradation breaks automation before it breaks the UI:

  1. Add Monitor → HTTP.
  2. URL: https://neoload.example.com/api/v1/tests (or https://neoload.example.com:7400/api/v1/workspaces for on-premises Controller).
  3. Check interval: 2 minutes.
  4. Response timeout: 15 seconds.
  5. Expected status: 200 or 401 (unauthenticated requests confirm the API is running).
  6. Label: NeoLoad REST API.
  7. Click Save.

Configure expected status as 401 if your NeoLoad API requires authentication — a 401 means the API is healthy and correctly requiring credentials. A 502 or connection timeout means the API is down.

When the API monitor fires but the web UI monitor stays green, the API layer has degraded while the frontend continues to serve static content — this can happen after partial upgrades or misconfigured API routing.

Step 4: Create a TCP Monitor for the Controller Port

NeoLoad Load Generators connect to the Controller over TCP (default port 7100). If this port is blocked or closed, Load Generators cannot receive test instructions and all active test runs fail:

# Verify Load Generator communication port
nc -zv neoload.example.com 7100
  1. Add Monitor → TCP.
  2. Host: neoload.example.com.
  3. Port: 7100 (default Load Generator communication port; check your NeoLoad runtime settings).
  4. Check interval: 2 minutes.
  5. Response timeout: 10 seconds.
  6. Label: NeoLoad Controller port.
  7. Click Save.

This monitor fires when:

  • A firewall rule change blocks the controller port
  • The NeoLoad Controller process restarts on a different port
  • Network segmentation isolates the Controller from Load Generators

When the TCP monitor fires but HTTP monitors are green, the Controller web interface is up but Load Generators cannot connect — tests will launch but immediately fail with agent connection errors.

Step 5: Monitor SSL Certificates

NeoLoad CI/CD integrations authenticate over HTTPS. An expired certificate breaks:

  • All Jenkins plugin connections to NeoLoad Web
  • GitHub Actions NeoLoad steps
  • Custom scripts using the NeoLoad REST API
  • User access to the NeoLoad Web UI
  1. Add Monitor → SSL Certificate.
  2. Domain: neoload.example.com.
  3. Alert when expiry is within: 30 days.
  4. Alert again: 14 days, 7 days, 3 days, 1 day.
  5. Click Save.

Check the certificate NeoLoad presents with: openssl s_client -connect neoload.example.com:443 2>/dev/null | openssl x509 -noout -dates

Step 6: Monitor the NeoLoad Licensing Endpoint

NeoLoad requires a valid license to execute test runs. The license server is often a separate process or remote service. When it becomes unreachable, NeoLoad can appear healthy but refuses to start new test runs:

# If using a local license server, check its HTTP health endpoint
curl -I https://neoload-license.example.com/health
  1. Add Monitor → HTTP.
  2. URL: your NeoLoad license server health URL.
  3. Check interval: 5 minutes.
  4. Expected status: 200.
  5. Label: NeoLoad license server.
  6. Click Save.

This step applies if you run an on-premises or floating license server. NeoLoad SaaS licenses are validated remotely by Tricentis — monitor outbound connectivity to *.tricentis.com from your NeoLoad host instead.

Step 7: Configure Alerting

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

| Monitor | Trigger | Action | |---|---|---| | Web UI | Non-200 or keyword missing | Check NeoLoad Web container/service logs; restart if needed | | REST API | Non-200/401 | API layer issue; check NeoLoad API service and routing | | Controller TCP port | Connection refused or timeout | Check firewall rules; verify NeoLoad Controller is running | | SSL certificate | < 30 days to expiry | Renew certificate; update CI/CD integrations if needed | | License server | Non-200 | Check license server process; contact Tricentis support |

Alert after: 2 consecutive failures for HTTP monitors. 1 failure for TCP monitors — TCP timeouts during active load tests are rare and almost always indicate a real network issue.

Common NeoLoad Failure Modes and What Vigilmon Catches

| Scenario | Vigilmon monitor | |---|---| | NeoLoad Web process crash | Web UI unreachable; API monitor fires within 60 s | | API service degradation | REST API monitor fires; web UI stays green | | Controller port blocked by firewall | TCP monitor fires; HTTP monitors stay green | | Load Generator connection failures | TCP monitor fires; tests fail with agent errors | | SSL certificate expires | SSL monitor alerts at 30-day threshold; all CI integrations break | | License server unreachable | License monitor fires; NeoLoad refuses test runs | | OOM during large test run | Web UI goes down; API becomes unresponsive | | Reverse proxy misconfiguration after upgrade | Web UI returns 502; TCP port may still respond | | DNS misconfiguration | All monitors fire simultaneously |

Load testing failures are particularly dangerous because they often happen at the worst time — right before or during a release cycle when performance validation is critical. Vigilmon gives you early warning through web UI availability, API health, controller port reachability, and SSL certificate expiry — so you catch NeoLoad failures before your CI pipelines time out waiting for test results.

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

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