How to Monitor Codeium Enterprise (Self-Hosted) with Vigilmon

Codeium Enterprise gives your engineering team AI-powered autocomplete, chat, and code search across 70+ programming languages — all running on your own infrastructure with full data privacy. But when the inference server goes down, every developer on your team loses completions simultaneously. When GPU memory runs out, latency spikes to seconds per token. When the auth service fails, nobody can log in.

In this tutorial you'll set up comprehensive monitoring for your self-hosted Codeium Enterprise deployment using Vigilmon — covering the API server, GPU health, IDE plugin endpoints, authentication, and TLS certificate expiry.

Why monitoring Codeium Enterprise matters

A self-hosted Codeium Enterprise deployment is a shared dependency for your entire engineering team. When something fails:

• API server down — every IDE plugin (VS Code, JetBrains, Vim, Emacs) loses completions at the same time; developers notice immediately but may not know it's a Codeium issue
• GPU OOM crash — the inference server silently restarts after CUDA out-of-memory errors; completions return after a delay but logs fill with crash traces
• Auth service failure — new sessions can't be created; existing tokens keep working until they expire, masking the problem until developers are locked out
• Code search indexer staleness — after a large commit or repository migration the index goes stale; completions lose context-awareness without any visible error
• TLS certificate expiry — the dashboard and API become unreachable over HTTPS; IDE plugins fail with cryptic TLS handshake errors

External monitoring from Vigilmon catches all of these before your team reports them via Slack.

What you'll need

• A running Codeium Enterprise self-hosted deployment (port 8080 for API, port 3000 for dashboard)
• A free Vigilmon account (sign up takes 30 seconds)

Step 1: Verify your Codeium health endpoints

Codeium Enterprise exposes health check endpoints on both its API server and dashboard. Confirm they're accessible before configuring monitors:

# API server health check (port 8080)
curl -s http://your-codeium-host:8080/health
# Expected: {"status":"ok"} or HTTP 200

# Dashboard health (port 3000)
curl -s http://your-codeium-host:3000/health
# Expected: HTTP 200

# Language model inference readiness
curl -s http://your-codeium-host:8080/api/v1/inference/health
# Expected: {"ready":true,"gpu_available":true}

If your Codeium deployment doesn't expose a /health route on port 8080, you can probe the completions endpoint with a lightweight request:

curl -s -o /dev/null -w "%{http_code}" \
  -X POST http://your-codeium-host:8080/api/v1/complete \
  -H "Content-Type: application/json" \
  -d '{"text":"","language":"python","cursor_offset":0}'

A 400 (bad request) or 200 both confirm the API server is alive — you're testing reachability, not correctness.

Step 2: Monitor the API server (port 8080)

The API server on port 8080 is the core inference endpoint. Every completion request from every IDE plugin passes through it.

1. Log in to vigilmon.online and go to Monitors → New Monitor
2. Choose HTTP / HTTPS as the type
3. Set the URL to https://your-codeium-host:8080/health
4. Set the check interval to 1 minute
5. Under Expected response, set status code to 200
6. Set the timeout to 10 seconds (inference startup can be slow after a GPU crash)
7. Save the monitor

This is your primary alert. If port 8080 goes down, your entire team loses completions.

Step 3: Monitor the dashboard (port 3000)

The dashboard on port 3000 is where team admins manage licenses, view usage, and configure the deployment.

1. Go to Monitors → New Monitor
2. Choose HTTP / HTTPS
3. Set the URL to https://your-codeium-host:3000/
4. Set the check interval to 5 minutes (lower priority than the API)
5. Expected status code: 200
6. Save the monitor

Step 4: Monitor TLS certificate expiry

Codeium Enterprise is deployed with HTTPS. An expired certificate causes IDE plugins to fail with TLS errors that are hard to diagnose.

1. Go to Monitors → New Monitor
2. Choose SSL Certificate as the type
3. Enter your Codeium hostname (e.g. codeium.internal.example.com)
4. Set an alert threshold of 30 days before expiry — gives you time to renew before any disruption
5. Save the monitor

Vigilmon will notify you when your certificate is within 30 days of expiring, then again at 14 days and 7 days.

Step 5: Monitor the authentication service

Codeium Enterprise uses a team-level auth service for license validation and session management. If it goes down, new IDE plugin sessions fail to authenticate.

Add a dedicated monitor for the auth endpoint:

1. Go to Monitors → New Monitor
2. Choose HTTP / HTTPS
3. Set the URL to https://your-codeium-host:8080/api/v1/auth/health (or /api/auth/status depending on your version)
4. Check interval: 2 minutes
5. Expected status: 200
6. Save the monitor

If the exact auth health route isn't available, monitor the login endpoint with a TCP check on port 8080 as a fallback.

Step 6: Monitor IDE plugin connectivity endpoints

Codeium exposes per-IDE plugin check endpoints. You can monitor these to detect plugin-specific failures independent of the core API:

# VS Code plugin health
curl https://your-codeium-host:8080/api/v1/ide/vscode/health

# JetBrains plugin health
curl https://your-codeium-host:8080/api/v1/ide/jetbrains/health

Set up HTTP monitors for each IDE endpoint your team uses. Use a 5-minute check interval — these are lower priority than the core API.

Step 7: Monitor PostgreSQL database connectivity

Codeium Enterprise stores user sessions, telemetry, and usage analytics in PostgreSQL (or SQLite for smaller deployments). Add a TCP monitor for the database port:

1. Go to Monitors → New Monitor
2. Choose TCP Port
3. Enter your database host and port (your-db-host / 5432)
4. Save the monitor

For SQLite deployments, skip this step — the database file is local to the Codeium process and its health is reflected by the API health check.

Step 8: Configure alerting

When your Codeium API goes down, you want an alert in under two minutes — before developers start filing support tickets.

1. Go to Alert Channels → Add Channel
2. Choose Slack, Email, or Webhook
3. For Slack: paste your Slack webhook URL
4. Assign the alert channel to all your Codeium monitors

Recommended alert routing:

| Monitor | Alert channel | Priority | |---------|---------------|----------| | API server (port 8080) | Slack #oncall + Email | High | | TLS certificate expiry | Email | Medium | | Auth service | Slack #oncall | High | | Dashboard (port 3000) | Email | Low | | Database TCP | Slack #oncall | High |

Summary: Codeium Enterprise monitor checklist

| Monitor | Type | Endpoint | Interval | |---------|------|----------|----------| | API server | HTTP | :8080/health | 1 min | | Dashboard | HTTP | :3000/ | 5 min | | TLS certificate | SSL | hostname | Daily | | Auth service | HTTP | :8080/api/v1/auth/health | 2 min | | Database | TCP | :5432 | 2 min | | VS Code plugin | HTTP | :8080/api/v1/ide/vscode/health | 5 min |

With these monitors in place, you'll know about API outages, GPU-crash-induced restarts, TLS expiry, and database failures before your engineering team notices the missing completions.

What's next

• Heartbeat monitoring — wrap your Codeium index rebuild cron job with a Vigilmon heartbeat so you're alerted if the indexer stops running after large commits
• Status page — publish a status page for your Codeium deployment so developers can check current health without pinging oncall

Get started free at vigilmon.online — no credit card, monitors start running in under a minute.