Stract Monitoring with Vigilmon: Crawl Pipeline, Search API & Index Health Checks

Your Stract search index stopped updating six hours ago. Users are getting stale results from last night's crawl. The crawl pipeline silently hit a memory limit and the worker crashed without restarting. Nobody got an alert.

Stract is an open-source web search engine written in Rust, listening on port 3000. It runs a multi-component architecture: a web frontend serving search results, a crawler ingesting new pages, an indexing service building the inverted index, a ranking algorithm layer scoring results, and distributed worker nodes sharing crawl workload. Self-hosting Stract gives you a private, customizable search engine — and full responsibility for knowing when any layer of that pipeline fails.

Vigilmon probes your Stract infrastructure from the outside, the way a real search user would. If the search endpoint starts timing out, if the crawl pipeline stalls, or if distributed nodes lose connectivity, Vigilmon alerts you before stale indexes start returning degraded results.

What You'll Build

• An HTTP monitor on the Stract web server
• A search API response time and correctness probe
• A crawl pipeline health check
• An indexing service availability monitor
• A ranking algorithm service probe
• A distributed node connectivity check
• Alert channels for your search infrastructure team

Prerequisites

• A self-hosted Stract installation (latest release recommended)
• Web server default port: 3000
• A free account at vigilmon.online

Step 1: Monitor the Stract Web Server

The Stract web server on port 3000 is the entry point for all search traffic. If it goes down, your entire self-hosted search capability disappears for end users.

Test the server is responding:

curl -o /dev/null -s -w "%{http_code}" http://your-stract-host:3000/

Expected: a 200 response serving the Stract search interface HTML.

Set up the Vigilmon monitor:

1. Log in to Vigilmon and click New Monitor → HTTP.
2. Set URL to http://your-stract-host:3000/.
3. Set Check interval to 60 seconds.
4. Set Expected status code to 200.
5. Under Advanced → Keyword check, add:
   • Keyword present: Search
6. Save the monitor.

This baseline check catches Rust process crashes, port binding failures, and reverse proxy misconfigurations that take the search interface offline.

Step 2: Monitor the Search API

The search API is the core of Stract. A slow or failing search endpoint directly impacts every user querying your instance. Monitoring response time and result quality catches both availability failures and performance degradation before users notice.

Test a known-good query:

curl -o /dev/null -s -w "%{http_code}" \
  "http://your-stract-host:3000/search?q=test"

Expected: 200 with HTML containing search results. A timeout or 500 indicates the search ranking or index layer has failed. Slow response times (above 2–3 seconds for a simple query) indicate index bloat, memory pressure, or ranking algorithm performance regression.

Set up the Vigilmon monitor:

1. Click New Monitor → HTTP in Vigilmon.
2. Set URL to http://your-stract-host:3000/search?q=test.
3. Set Expected status code to 200.
4. Set Check interval to 60 seconds.
5. Set Timeout to 5000 ms — a query taking longer than 5 seconds is a functional failure.
6. Under Advanced → Keyword check, add:
   • Keyword present: results
7. Save the monitor.

Stract's ranking pipeline executes on every query. A timeout here means the ranking algorithm or the index reader is blocked, and every user is experiencing the same delay.

Step 3: Monitor the Crawl Pipeline Health

Stract's crawler continuously fetches new pages to keep the index fresh. If the crawl pipeline stalls — due to rate limiting, network failures, or queue exhaustion — your index stops receiving new content and search results grow stale over time.

Test the crawl status endpoint:

curl -s http://your-stract-host:3000/api/crawl/status

A healthy Stract crawl pipeline exposes status information about active crawl jobs, pages queued, and crawl rate. If Stract exposes an admin or metrics endpoint, check that the crawl job count is non-zero and the queue is not stuck at maximum depth.

Set up the Vigilmon monitor:

1. Click New Monitor → HTTP in Vigilmon.
2. Set URL to http://your-stract-host:3000/api/crawl/status.
3. Set Expected status code to 200.
4. Set Check interval to 300 seconds.
5. Under Advanced → Keyword check, add:
   • Keyword absent: error
6. Save the monitor.

If Stract does not expose a dedicated crawl status endpoint in your version, monitor the admin metrics path (/metrics or /admin/status) and alert on the crawl queue depth metric instead.

Step 4: Monitor the Indexing Service

Stract's indexing service processes crawled pages into the inverted index. A stalled indexer means the index stops growing — new pages are crawled but never become searchable. This is a silent failure: the web server returns results, but they get progressively staler.

Test index freshness via the API:

curl -s "http://your-stract-host:3000/api/index/stats"

A healthy indexer returns statistics including the total document count and the last index update timestamp. If the document count is not growing over a 24-hour window or the last-updated timestamp is stale, the indexer has stalled.

Set up the Vigilmon monitor:

1. Click New Monitor → HTTP in Vigilmon.
2. Set URL to http://your-stract-host:3000/api/index/stats.
3. Set Expected status code to 200.
4. Set Check interval to 600 seconds.
5. Under Advanced → Keyword check, add:
   • Keyword present: documents
   • Keyword absent: error
6. Save the monitor.

For more precise staleness detection, use a Vigilmon webhook trigger to compare the last_updated timestamp against the current time — flag if the index has not been updated in more than 2 hours.

Step 5: Monitor the Ranking Algorithm Service

Stract's ranking algorithm evaluates query relevance across the index. If the ranking layer becomes degraded — due to model loading failures, memory exhaustion, or configuration errors — search results become nonsensical even when the web server returns 200 responses.

Test ranking correctness with a deterministic query:

curl -s "http://your-stract-host:3000/api/search?q=test&format=json" \
  | python3 -c "import sys,json; d=json.load(sys.stdin); print('ok' if d.get('results') else 'empty')"

A healthy ranking service returns a JSON response with a non-empty results array for a common query term. An empty results array for a query that should match many documents indicates the ranking service has a scoring problem.

Set up the Vigilmon monitor:

1. Click New Monitor → HTTP in Vigilmon.
2. Set URL to http://your-stract-host:3000/api/search?q=technology&format=json.
3. Set Expected status code to 200.
4. Set Check interval to 120 seconds.
5. Under Advanced → Keyword check, add:
   • Keyword present: results
6. Save the monitor.

Step 6: Monitor Distributed Node Connectivity

If you run Stract in a distributed configuration with multiple crawl or index worker nodes, inter-node connectivity is critical. A node that loses contact with the coordinator stops contributing to the crawl workload and its partial index shard becomes unavailable.

Test the node connectivity status:

curl -s http://your-stract-host:3000/api/nodes/health

A healthy response lists all registered nodes with their status as online. Any node showing offline or unreachable means crawl capacity has been reduced and certain index shards may be unavailable for query execution.

Set up the Vigilmon monitor:

1. Click New Monitor → HTTP in Vigilmon.
2. Set URL to http://your-stract-host:3000/api/nodes/health.
3. Set Expected status code to 200.
4. Set Check interval to 120 seconds.
5. Under Advanced → Keyword check, add:
   • Keyword absent: offline
   • Keyword absent: unreachable
6. Save the monitor.

For single-node Stract deployments, skip this step and focus resources on the crawl pipeline and indexing service monitors instead.

Step 7: Alert Channels

Go to Notifications → New Channel in Vigilmon and configure:

• Email — immediate alerts to your search infrastructure team
• Webhook — Slack or Discord for team-wide visibility into search outages

A failing search API alert looks like:

🔴 DOWN: stract-search-api (HTTP monitor)
Expected status 200, got 504 Gateway Timeout
Region: EU-Central
Triggered: 2026-07-13 04:47 UTC

When the service recovers:

✅ RECOVERED: stract-search-api
Downtime: 18 minutes

Set critical severity for the web server and search API monitors — these are user-facing. Use warning severity for crawl pipeline, indexing, and node connectivity monitors, which represent gradual index degradation rather than immediate user impact. Enable Alerting → Escalation to page your infrastructure contact if the search API is unresponsive for more than 3 minutes.

What You've Built

| Scenario | How Vigilmon catches it | |---|---| | Rust process crash | HTTP monitor on :3000 fails with connection refused | | Search query timing out | Search API monitor exceeds 5-second timeout | | Crawl pipeline stalled | Crawl status endpoint returns error or non-200 | | Indexer stopped processing | Index stats endpoint returns stale or error response | | Ranking algorithm failure | Search JSON returns empty results for common queries | | Worker node offline | Node health endpoint shows offline status | | Memory exhaustion OOM kill | All monitors fail simultaneously |

Stale search results are invisible until a user realizes the top result is from three weeks ago. External monitoring with Vigilmon gives you a real-time signal when your Stract crawl pipeline, indexing service, or search API breaks — before index staleness becomes something your users have to notice themselves.

Start monitoring your Stract search engine today — register free at vigilmon.online.