How to Monitor Oxlint with Vigilmon

Oxlint is a JavaScript and TypeScript linter written in Rust, delivering 50–100× the speed of ESLint across 400+ rules covering correctness, security, performance, and style. Teams run it as a first-pass "fast feedback" linter before ESLint, cutting minutes from CI times. But the CI runners, pre-commit hook servers, and webhook consumers that orchestrate Oxlint still need monitoring — and that's where Vigilmon comes in.

What You'll Set Up

• HTTP monitors for self-hosted CI runners that execute Oxlint checks
• Cron heartbeat monitors for scheduled nightly lint jobs
• Webhook endpoint monitors so lint results actually reach downstream consumers
• SSL certificate alerts for internal tooling services

Prerequisites

• Oxlint installed via npm install -D oxlint or cargo install oxlint
• A CI/CD pipeline (GitHub Actions, GitLab CI, Jenkins, or similar) that runs Oxlint
• A free Vigilmon account

Step 1: Monitor Your CI Runner or Lint Server

Self-hosted runners that execute Oxlint checks need uptime monitoring. If the runner is down, Oxlint never runs, and broken code merges without a lint gate.

1. Log in to vigilmon.online and click Add Monitor.
2. Set Type to HTTP / HTTPS.
3. Enter the runner's health URL: https://ci.yourdomain.com/health (or your runner's status page).
4. Set Check interval to 1 minute.
5. Set Expected HTTP status to 200.
6. Click Save.

If your runner does not expose a health endpoint, monitor the web interface root URL and treat any non-200 as a signal to investigate.

Step 2: Add a Health Endpoint to Your Oxlint Wrapper

If you wrap Oxlint in a custom lint gateway or API (for example, a service that runs Oxlint on uploaded code and returns structured results), expose a health route:

Node.js / Fastify lint API

import { execa } from 'execa';

fastify.get('/health', async (req, reply) => {
  try {
    const { stdout } = await execa('oxlint', ['--version']);
    return { status: 'ok', version: stdout.trim() };
  } catch (err) {
    reply.status(503);
    return { status: 'error', detail: err.message };
  }
});

GitHub Actions with Oxlint

# .github/workflows/oxlint.yml
name: Oxlint
on: [push, pull_request]

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install Oxlint
        run: npm install -g oxlint
      - name: Run Oxlint
        run: oxlint src/

Monitor the GitHub Actions API or your CI web interface to confirm the workflow is running successfully.

Step 3: Heartbeat Monitoring for Scheduled Lint Scans

Many teams run Oxlint on a schedule to catch drift: a nightly full-codebase scan, a weekly security-focused lint pass using the -A oxc_security category. Use Vigilmon's cron heartbeat to confirm each scheduled run completes:

1. In Vigilmon, click Add Monitor → Cron Heartbeat.
2. Set the expected ping interval (e.g. 1440 minutes for a daily scan, 10080 for weekly).
3. Copy the heartbeat URL: https://vigilmon.online/heartbeat/abc123.
4. Add the ping to your scheduled lint script:

#!/bin/bash
# Nightly Oxlint security scan
cd /srv/my-project

oxlint --deny-warnings \
  -A oxc_security \
  --format json \
  ./src > /var/log/oxlint-nightly.json 2>&1

if [ $? -eq 0 ]; then
  curl -s https://vigilmon.online/heartbeat/abc123
fi

If Oxlint finds security violations (exit code 1) or the script crashes, the heartbeat is never sent. You'll be alerted after the interval passes — before the next business day starts.

Step 4: Monitor the Oxlint Results Webhook Consumer

If Oxlint results feed into a downstream system — a Slack bot, a GitHub PR check API, a custom dashboard — monitor that consumer endpoint so you know when the feedback loop breaks:

1. In Vigilmon, click Add Monitor → HTTP / HTTPS.
2. Enter the consumer webhook URL.
3. Set Expected HTTP status to 200 or 204.
4. Set Check interval to 5 minutes.
5. Click Save.

A down webhook consumer means lint results are silently swallowed. Developers stop trusting the lint gate when annotations never appear on their PRs.

Step 5: TCP Port Monitor for Self-Hosted Oxlint Services

If you expose Oxlint as an internal service (e.g., a daemon listening on a TCP port for IDE integrations), add a TCP monitor:

1. In Vigilmon, click Add Monitor → TCP.
2. Enter the host and port: oxlint.internal:7070.
3. Set Check interval to 1 minute.
4. Click Save.

This catches the service process dying without the HTTP layer going down — useful for long-running IDE language-server-style integrations.

Step 6: SSL Certificate Alerts

Oxlint tooling dashboards, webhook relays, and API surfaces all need valid TLS. For each HTTPS endpoint:

1. Open the HTTP monitor created in Steps 1 or 4.
2. Enable Monitor SSL certificate.
3. Set Alert when certificate expires in less than 21 days.
4. Click Save.

A lapsed certificate on your lint API causes IDE plugins and CI runners to reject connections — making Oxlint appear broken when the problem is infrastructure.

Step 7: Configure Alert Channels and Thresholds

1. Go to Alert Channels in Vigilmon and add Slack, email, or a webhook.
2. For HTTP monitors, set Consecutive failures before alert to 2 to filter transient blips.
3. For cron heartbeats, set Consecutive failures before alert to 1 — a missed lint job is always worth investigating.

Suppress false alerts during Oxlint version upgrades:

# Before upgrading Oxlint
curl -X POST https://vigilmon.online/api/maintenance \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{"monitor_id": "abc123", "duration_minutes": 10}'

npm install -D oxlint@latest

Summary

| Monitor | Target | What It Catches | |---|---|---| | CI runner health | https://ci.yourdomain.com/health | Runner down, lint gate silently skipped | | Cron heartbeat | Heartbeat URL | Scheduled scan crash or exit error | | Webhook consumer | Downstream endpoint | Lint results not reaching PR/Slack | | TCP port | oxlint.internal:7070 | Daemon crash without HTTP signal | | SSL certificate | Each tooling domain | TLS expiry blocking connections |

Oxlint's speed advantage only helps if the pipeline running it stays healthy. With Vigilmon covering your CI runners, scheduled scans, webhook consumers, and TLS certificates, you get the same reliability guarantee for your lint infrastructure that Oxlint brings to your code quality checks.