Monitoring Rspack with Vigilmon: Dev Server Health, Build Output Endpoints, SSL Certificate & Alerting

Rspack is the Rust-based, webpack-compatible JavaScript bundler that delivers 5–10× faster cold builds and incremental rebuilds compared to webpack, while supporting the full webpack plugin and loader ecosystem. Teams migrating from webpack to Rspack dramatically cut their CI build times — but a faster bundler doesn't mean build failures disappear. When the Rspack dev server goes down mid-sprint, when a production build job silently exits non-zero, or when the CDN endpoint serving your bundled assets returns a 404 after a bad deploy, your users feel it immediately. Vigilmon gives you external visibility into every layer of an Rspack-powered frontend: dev server uptime, production asset endpoints, CI/CD build webhooks, and SSL certificate health.

What You'll Build

• An HTTP monitor on your Rspack dev server to catch crashes during development workflows
• An HTTP monitor on your production bundle-serving endpoint to catch bad deploys
• A webhook endpoint monitor to verify your CI/CD build pipeline receiver is reachable
• SSL certificate monitoring for your production frontend domain
• Alerting rules that distinguish build failures from infrastructure outages

Prerequisites

• Rspack 0.3+ (or an Nx/Rsbuild project using Rspack under the hood)
• An Rspack dev server running (typically on port 8080 or 3000) or a production build deployed behind a CDN or reverse proxy
• Your build pipeline exposes a webhook or status endpoint (Jenkins, GitHub Actions, or a custom CI/CD receiver)
• A free account at vigilmon.online

Step 1: Understand Where Rspack Failures Surface

Rspack failures appear in three distinct places depending on the environment:

Dev server crashes: When @rspack/core or @rsbuild/dev-server encounters a fatal error — a malformed config, a loader that throws synchronously, or an out-of-memory condition — the Node.js process exits and the dev server port closes. Developers receive no response on hot-reload requests and assume the network is to blame.

Production build failures: Rspack exits with a non-zero code when a module cannot be resolved, a loader throws, or the output directory cannot be written. CI systems may silently continue if the exit code is not checked, deploying a stale or empty bundle.

Asset serving failures: Even after a successful Rspack build, the CDN or reverse proxy serving main.js, chunk.*.js, or the index HTML can return 404 or 502 if the deployment step failed, the bucket was misconfigured, or a CDN cache invalidation did not propagate.

Vigilmon monitors all three externally — independent of your build tooling.

Step 2: Monitor the Rspack Dev Server

The Rspack dev server (Rsbuild or the webpack-dev-server-compatible mode) exposes an HTTP endpoint on startup:

# Default Rsbuild dev server
curl http://localhost:8080/

# Or with custom port
curl http://localhost:3000/

# Health check on the HMR WebSocket upgrade path
curl -I http://localhost:8080/__rspack_hmr

For a team dev server running on an internal host (not localhost), monitor it with Vigilmon:

1. Log in to Vigilmon → Add Monitor → HTTP.
2. URL: http://dev.internal.example.com:8080/ (your team's dev server URL).
3. Check interval: 60 seconds.
4. Response timeout: 15 seconds.
5. Expected status: 200.
6. Label: Rspack dev server.
7. Click Save.

Localhost dev servers: If your dev server only binds to 127.0.0.1, it is not externally reachable and cannot be monitored directly. Run your dev server with --host 0.0.0.0 (Rsbuild: set dev.host: '0.0.0.0' in rsbuild.config.ts) and monitor it by the machine's LAN or VPN IP.

Step 3: Monitor the Production Asset Endpoint

After an Rspack build completes and assets are deployed to a CDN or object storage, the most important check is that the entrypoint asset is actually reachable:

# Check that the main bundle is served
curl -I https://app.example.com/static/js/main.js

# Check the application HTML shell
curl -I https://app.example.com/

# Verify a specific chunk exists (useful post-deploy)
curl -I https://cdn.example.com/assets/chunk.abc123.js

1. Add Monitor → HTTP.
2. URL: https://app.example.com/ (your production frontend URL).
3. Check interval: 2 minutes.
4. Expected status: 200.
5. Keyword: a unique string in your HTML shell (e.g., your app name or <div id="root").
6. Label: Rspack production frontend.
7. Click Save.

Add a second monitor for the main JS bundle directly, pointing to the hashed filename in your CDN. After each deploy, update this monitor URL to the new hash if it changes — or better, serve the bundle from a stable, non-hashed URL (e.g., /static/js/main.js) via cache-busting headers so the monitor URL stays constant.

Step 4: Monitor Your CI/CD Build Webhook

Many CI/CD pipelines that run Rspack builds expose a status or notification webhook. If the webhook receiver goes down, your pipeline loses the ability to notify your team of build results:

# Example: a build notification receiver
curl -X GET https://build.example.com/api/rspack/build-status/latest
# Returns: {"status":"success","duration":4200,"assets":15}

For GitHub Actions, Jenkins, or Nx Cloud, you can also monitor the CI provider's API:

# GitHub Actions status endpoint (unauthenticated, public repos)
curl https://api.github.com/repos/your-org/your-repo/actions/workflows/build.yml/runs?per_page=1

1. Add Monitor → HTTP.
2. URL: https://build.example.com/api/rspack/build-status/latest.
3. Check interval: 5 minutes.
4. Expected status: 200.
5. Keyword: success or status.
6. Label: Rspack CI build webhook.
7. Click Save.

Step 5: Monitor SSL Certificates

Rspack production apps are always served over HTTPS. An expired certificate causes browsers to block the page entirely — your monitoring should warn you weeks in advance:

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

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

If you serve assets from a separate CDN domain (e.g., cdn.example.com), add a second SSL monitor for that domain — CDN certificates sometimes have separate renewal pipelines.

Step 6: Configure Alerting for Build Pipeline Correlation

In Vigilmon under Settings → Notifications, wire up alert channels and add deployment context:

| Monitor | Trigger | Action | |---|---|---| | Dev server | Non-200 or timeout | Check Node.js process; restart rsbuild dev; check for OOM kill | | Production frontend | Non-200 or keyword missing | Check CDN deployment logs; verify Rspack build exit code in CI | | Build webhook | Non-200 or timeout | CI/CD webhook receiver is down; builds may run but team is unnotified | | SSL certificate | < 30 days to expiry | Renew via Let's Encrypt or ACM; check CDN TLS settings |

Deploy alerting pattern: Enable a Vigilmon maintenance window for 3 minutes immediately after each Rspack build deployment. This prevents alerts from firing on the brief window between asset removal and CDN propagation. Any failure after the window is a genuine problem.

Common Rspack Failure Modes and What Vigilmon Catches

| Scenario | Vigilmon monitor | |---|---| | Dev server process crashes (OOM, fatal loader error) | Dev server HTTP monitor fires | | Rspack build exits non-zero; stale bundle deployed | Production asset monitor returns outdated keyword | | Empty bundle deployed (output dir write failure) | Production frontend keyword check fails | | CDN cache invalidation not propagated | Production asset 404 or stale content | | SSL certificate expired | SSL monitor fires 30 days before; HTTPS blocked | | CI/CD webhook receiver unreachable | Build webhook monitor fires; team misses build alerts | | Port conflict on dev server restart | Dev server monitor returns connection refused | | Wrong output path deployed to CDN | Production frontend 404 | | Network partition between dev machine and team dev server | Dev server monitor timeout | | CDN origin mismatch after bucket rename | Production asset 403 or 404 |

Rspack's Rust core makes JavaScript bundling dramatically faster — but the reliability of the broader build-and-serve pipeline depends on external monitoring that your bundler cannot provide for itself. Vigilmon watches your dev server, production endpoints, CI/CD webhooks, and SSL certificates from outside your infrastructure, so you know within 60 seconds when a build has shipped broken assets or when your dev server has silently crashed mid-sprint.

Start monitoring your Rspack builds in under 5 minutes — register free at vigilmon.online.