Monitoring Bloop with Vigilmon

Bloop is an open-source AI-powered code search and understanding engine. It indexes your entire codebase and provides a natural-language chat interface for questions like "how does authentication work?" or "where is the payment processing logic?" — combining semantic search, exact text search, and local LLM inference into a single web application. Bloop self-hosts as a Rust backend with a React frontend on port 7080, with an optional Ollama integration (port 11434) for AI chat answers. When any component fails — the web app, the code indexer, the git sync loop, or the LLM backend — developers lose access to their AI-assisted code navigation. Vigilmon keeps watch on every layer.

What You'll Set Up

• Bloop web application availability monitor (port 7080)
• Code indexer health and index freshness heartbeat
• Ollama / local LLM connectivity monitor (port 11434)
• Git repository sync health check
• Code search latency probe (P95 SLA monitoring)
• Database integrity check
• Disk space monitoring for the code index
• SSL certificate expiry alerts

Prerequisites

• Bloop installed and running (bloop binary or Docker: ghcr.io/bloopai/bloop)
• Bloop web UI accessible at http://localhost:7080
• Optional: Ollama running on port 11434 for AI chat answers
• A free Vigilmon account

Step 1: Monitor the Bloop Web Application

Bloop's web UI and REST API are served from the same port 7080. When this goes down, developers have no access to code search or AI chat — the primary value of the tool.

1. Log in to vigilmon.online and click Add Monitor.
2. Set Type to HTTP / HTTPS.
3. Enter the Bloop URL:
   • Local: http://localhost:7080/
   • Reverse-proxy / remote: https://bloop.yourdomain.com/
4. Set Check interval to 1 minute.
5. Set Expected HTTP status to 200.
6. Click Save.

Bloop serves its React frontend and REST API from the same address. A 404 or connection refused means the Bloop process has crashed, the Docker container has stopped, or a system restart did not bring the service back up.

Tip: If Bloop is running behind nginx or Caddy, monitor the proxy URL and enable SSL certificate monitoring in the same step. This also lets you validate the TLS configuration without a separate monitor.

Step 2: Monitor Code Indexer Health and Index Freshness

Bloop continuously indexes your git repository for both semantic (embedding-based) and exact text search. If the indexer process stalls, crashes, or falls behind on commits, search results become stale. Old results pointing to deleted code or missing newly added functions directly reduce developer trust in the tool.

1. Click Add Monitor → Cron Heartbeat.
2. Set Expected ping interval to 30 minutes.
3. Copy the heartbeat URL (e.g. https://vigilmon.online/heartbeat/abc123).

Create check_index.sh that queries the Bloop API for index state and freshness:

#!/bin/bash
BLOOP_URL="${BLOOP_URL:-http://localhost:7080}"
MAX_LAG_SECONDS=1800  # 30 minutes

# Get repository sync state from Bloop API
REPO_STATE=$(curl -s "$BLOOP_URL/api/repos" | python3 -c "
import sys, json
repos = json.load(sys.stdin)
for r in repos:
    status = r.get('sync_status', {}).get('status', 'unknown')
    if status not in ('done', 'queued'):
        print(f'WARN: repo {r.get(\"name\")} status={status}', file=sys.stderr)
print('ok')
" 2>/dev/null)

if [ "$REPO_STATE" = "ok" ]; then
  curl -s "https://vigilmon.online/heartbeat/YOUR_INDEX_HEARTBEAT_ID"
else
  echo "Indexer health check failed"
fi

Schedule every 15 minutes:

*/15 * * * * /path/to/check_index.sh

If the indexer stalls on a large commit or crashes during reindexing, the heartbeat stops and Vigilmon alerts.

Step 3: Monitor Ollama / Local LLM Connectivity

Bloop's AI chat answers — the "talk to your codebase" interface — are powered by a local LLM via Ollama. If Ollama crashes or runs out of VRAM, all chat queries return errors while the code search functionality remains intact. Monitor the two independently so you can distinguish "Bloop is down" from "AI chat is unavailable."

1. Click Add Monitor → HTTP / HTTPS.
2. Enter: http://localhost:11434/ (or the LAN IP if Ollama is on a separate host).
3. Set Expected HTTP status to 200.
4. Set Check interval to 1 minute.
5. Click Save.

Then add a model load verification heartbeat:

#!/bin/bash
# Verify the Bloop-configured model is loaded in Ollama
MODEL="${BLOOP_LLM_MODEL:-deepseek-coder:6.7b}"
RESPONSE=$(curl -s http://localhost:11434/api/tags)

if echo "$RESPONSE" | python3 -c "
import sys, json
data = json.load(sys.stdin)
models = [m['name'] for m in data.get('models', [])]
exit(0 if any('$MODEL' in m for m in models) else 1)
"; then
  curl -s "https://vigilmon.online/heartbeat/YOUR_LLM_MODEL_HEARTBEAT_ID"
else
  echo "Model $MODEL not available in Ollama"
fi

Schedule every 10 minutes.

Step 4: Monitor Git Repository Sync Health

Bloop watches for new git commits and re-indexes the repository on changes. If the git sync loop falls behind — due to a large force-push, a corrupted ref, or a file system issue — search results diverge from the actual codebase. Developers notice this as search returning results that no longer exist or missing recently added code.

1. Click Add Monitor → Cron Heartbeat.
2. Set Expected ping interval to 60 minutes.
3. Copy the heartbeat URL.

Create check_git_sync.sh:

#!/bin/bash
BLOOP_URL="${BLOOP_URL:-http://localhost:7080}"
REPO_PATH="${BLOOP_REPO_PATH:-$HOME/projects/myrepo}"

# Get the HEAD commit from git
GIT_HEAD=$(git -C "$REPO_PATH" rev-parse HEAD 2>/dev/null)

# Get the last indexed commit from Bloop API (adjust endpoint to your Bloop version)
INDEXED=$(curl -s "$BLOOP_URL/api/repos/local%2F$( basename "$REPO_PATH")" \
  | python3 -c "import sys,json; r=json.load(sys.stdin); print(r.get('last_index_unix_secs',0))" 2>/dev/null)

if [ -n "$GIT_HEAD" ] && [ -n "$INDEXED" ]; then
  curl -s "https://vigilmon.online/heartbeat/YOUR_GIT_SYNC_HEARTBEAT_ID"
fi

Schedule hourly. A missed heartbeat indicates that the git sync loop has stalled or the repository is inaccessible.

Step 5: Monitor Search Latency

Bloop's value to developers depends on fast search response times. A P95 latency spike — caused by an overloaded CPU, insufficient RAM for the embedding index, or a fragmented on-disk index — directly hurts productivity. Monitor search latency as a proxy for index health and resource pressure.

1. Click Add Monitor → Cron Heartbeat.
2. Set Expected ping interval to 10 minutes.
3. Copy the heartbeat URL.

Create check_search_latency.sh:

#!/bin/bash
BLOOP_URL="${BLOOP_URL:-http://localhost:7080}"
MAX_LATENCY_MS=2000  # 2 second P95 threshold

START=$(date +%s%3N)
RESULT=$(curl -s -X POST "$BLOOP_URL/api/answer" \
  -H "Content-Type: application/json" \
  -d '{"q":"function main","page_size":5}' \
  -o /dev/null -w "%{http_code}")
END=$(date +%s%3N)

LATENCY=$(( END - START ))

if [ "$RESULT" = "200" ] && [ "$LATENCY" -lt "$MAX_LATENCY_MS" ]; then
  curl -s "https://vigilmon.online/heartbeat/YOUR_SEARCH_LATENCY_HEARTBEAT_ID"
else
  echo "Search latency ${LATENCY}ms or HTTP $RESULT — threshold: ${MAX_LATENCY_MS}ms"
fi

Schedule every 10 minutes. If search exceeds 2 seconds, investigate index fragmentation or memory pressure.

Step 6: Monitor Database Integrity

Bloop stores its code index in a local database (RocksDB or SQLite depending on the version). Corruption after an unexpected shutdown, a failed write, or disk errors can cause search results to return errors or incomplete data.

1. Click Add Monitor → Cron Heartbeat.
2. Set Expected ping interval to 60 minutes.
3. Copy the heartbeat URL.

Create check_db.sh:

#!/bin/bash
BLOOP_DATA="${BLOOP_DATA_DIR:-$HOME/.bloop}"

# For SQLite-based Bloop installations
if [ -f "$BLOOP_DATA/bloop.db" ]; then
  sqlite3 "$BLOOP_DATA/bloop.db" "PRAGMA integrity_check;" | grep -q "^ok$" \
    && curl -s "https://vigilmon.online/heartbeat/YOUR_DB_HEARTBEAT_ID" \
    || echo "SQLite integrity check failed"
else
  # For RocksDB, check that the data directory is readable and non-empty
  [ -d "$BLOOP_DATA" ] && [ "$(ls -A "$BLOOP_DATA")" ] \
    && curl -s "https://vigilmon.online/heartbeat/YOUR_DB_HEARTBEAT_ID" \
    || echo "Bloop data directory missing or empty"
fi

Schedule hourly.

Step 7: Monitor Disk Space for the Code Index

Large monorepos can produce indexes in the tens of gigabytes. A full disk causes the indexer to fail silently and can corrupt in-progress writes to RocksDB. Alert before disk fills.

1. Click Add Monitor → Cron Heartbeat.
2. Set Expected ping interval to 30 minutes.
3. Copy the heartbeat URL.

Create check_disk.sh:

#!/bin/bash
BLOOP_DATA="${BLOOP_DATA_DIR:-$HOME/.bloop}"

# Alert at 80% full
USED_PCT=$(df "$BLOOP_DATA" | awk 'NR==2{gsub(/%/,"",$5); print $5}')

if [ "$USED_PCT" -lt 80 ]; then
  curl -s "https://vigilmon.online/heartbeat/YOUR_DISK_HEARTBEAT_ID"
else
  echo "Disk usage at ${USED_PCT}% — threshold: 80%"
fi

Schedule every 30 minutes. At 80% usage, investigate large repositories or plan index pruning before the disk fills completely.

Step 8: SSL Certificate Monitoring

If Bloop is exposed through a reverse proxy with TLS, monitor the certificate expiry.

1. Open the HTTP monitor for Bloop (created in Step 1).
2. Enable Monitor SSL certificate.
3. Set Alert when certificate expires in less than 21 days.
4. Click Save.

Step 9: Configure Alert Channels

1. Go to Alert Channels in Vigilmon and add Slack, email, Discord, or a webhook.
2. On the Bloop web app monitor: set Consecutive failures before alert to 2.
3. On the Ollama backend monitor: set Consecutive failures to 1.
4. On heartbeat monitors: the default single-missed-interval threshold is appropriate.
5. For the disk space monitor: consider a separate alert channel for infra-ops so disk warnings reach the right team.

Summary

| Monitor | Type | Target | Interval | |---------|------|--------|----------| | Bloop web app | HTTP | http://localhost:7080/ | 1 min | | Ollama LLM backend | HTTP | http://localhost:11434/ | 1 min | | LLM model load status | Heartbeat | probe script → Vigilmon | 10 min | | Code indexer health | Heartbeat | probe script → Vigilmon | 15 min | | Git repository sync | Heartbeat | probe script → Vigilmon | 60 min | | Search latency (P95) | Heartbeat | probe script → Vigilmon | 10 min | | Database integrity | Heartbeat | probe script → Vigilmon | 60 min | | Disk space for index | Heartbeat | probe script → Vigilmon | 30 min | | SSL certificate | SSL (on HTTP monitor) | reverse proxy domain | — |

Bloop's effectiveness as a developer tool hinges on fast, accurate, and fresh search results. When the indexer stalls, the LLM crashes, or the disk fills, developers notice through degraded search quality long before an obvious error appears. With Vigilmon watching each component, you know about problems within minutes and can restore full code intelligence before it disrupts developer workflows.

Get started for free at vigilmon.online.