Monitoring Flipt with Vigilmon

Flipt is an open-source, self-hosted feature flag platform that gives you full control over your feature rollouts without sending flag data to a third party. That control comes with a monitoring responsibility: when Flipt goes down, client SDKs fall back to default values — usually false — and your feature rollouts silently freeze. Vigilmon provides external uptime monitoring for Flipt's REST API, health endpoint, and UI, giving you immediate alerts when your flag server is unavailable.

What You'll Set Up

• HTTP health monitor on Flipt's /health endpoint
• HTTP monitor on the Flipt REST API for flag evaluation
• TCP port monitors for HTTP and gRPC listeners
• SSL certificate alert for the Flipt UI domain

Prerequisites

• Flipt 1.x running with HTTP and/or gRPC enabled
• A free Vigilmon account

Step 1: Monitor the Flipt Health Endpoint

Flipt exposes a /health endpoint on its HTTP port (default 8080). This endpoint returns 200 when Flipt is ready to serve requests.

1. Log in to vigilmon.online and click Add Monitor.
2. Set Type to HTTP / HTTPS.
3. Enter the URL: http://your-flipt-host:8080/health.
4. Set Check interval to 1 minute.
5. Set Expected HTTP status to 200.
6. Click Save.

Verify it responds locally:

curl -s http://localhost:8080/health
# Returns: {"status":"OK"}

The health endpoint checks that Flipt has successfully connected to its backing store (SQLite, Postgres, MySQL, or Redis). A 503 response means Flipt is up but its database is unreachable — a more subtle failure mode than a complete crash.

Step 2: Monitor the Flag Evaluation REST API

Flipt's core function is evaluating flags. Add a monitor that probes the evaluation API directly to confirm flag evaluation is working end-to-end:

1. Click Add Monitor → HTTP / HTTPS.
2. Enter: http://your-flipt-host:8080/api/v1/namespaces/default/flags.
3. Set Expected HTTP status to 200.
4. Set Check interval to 1 minute.
5. Click Save.

This endpoint lists flags in the default namespace and returns 200 even if no flags are defined yet. A non-200 response indicates an API-layer issue separate from the process health check.

If you use authentication tokens on your Flipt API, add the token as a request header in the monitor configuration:

Authorization: Bearer YOUR_FLIPT_TOKEN

Step 3: Monitor the Flipt Web UI

Flipt serves a management UI at the root path http://your-flipt-host:8080/. Add a monitor for it:

1. Click Add Monitor → HTTP / HTTPS.
2. Enter: http://your-flipt-host:8080/.
3. Set Expected HTTP status to 200.
4. Set Check interval to 5 minutes.
5. Click Save.

The UI availability check confirms that Flipt's embedded frontend is serving correctly, which can fail independently of the API if the build assets are corrupted or the static file serving is misconfigured.

Step 4: Add TCP Port Monitors for HTTP and gRPC

Flipt serves gRPC on port 9000 by default alongside the HTTP API on 8080. Client SDKs that use the gRPC transport will fail silently if the gRPC port goes down even when HTTP remains up.

Add TCP monitors for both ports:

1. Click Add Monitor → TCP Port.
2. Enter host and port 8080. Click Save.
3. Repeat for port 9000.

TCP monitors catch network-layer failures — firewall rule changes, port binding conflicts, or the gRPC server crashing while the HTTP server stays up — that HTTP monitors miss.

Step 5: SSL Certificate Alert for the Flipt Domain

If Flipt is exposed via a reverse proxy (nginx, Caddy) with TLS, add an SSL certificate monitor:

1. Open the HTTP monitor for https://flipt.yourdomain.com/health.
2. Enable Monitor SSL certificate.
3. Set Alert when certificate expires in less than 21 days.
4. Click Save.

Feature flag clients using TLS verification will immediately fail when the certificate expires — this alert gives you 3 weeks to renew before clients start returning SDK errors.

Step 6: Heartbeat Monitoring for Client SDK Connectivity

For a full end-to-end check, instrument your application's Flipt SDK client to ping a Vigilmon heartbeat after each successful flag evaluation:

// Go example
import (
    flipt "go.flipt.io/flipt/sdk/go"
    "net/http"
)

func evaluateFlag(client *flipt.Client, flagKey string) bool {
    result, err := client.Flipt().Evaluate(ctx, &flipt.EvaluationRequest{
        NamespaceKey: "default",
        FlagKey:      flagKey,
        EntityId:     "user-123",
    })
    if err == nil {
        // Ping Vigilmon heartbeat on successful evaluation
        go http.Get("https://vigilmon.online/heartbeat/YOUR_HEARTBEAT_ID")
    }
    return result.GetEnabled()
}

In Vigilmon:

1. Click Add Monitor → Cron Heartbeat.
2. Set the expected interval to match your flag evaluation frequency.
3. Copy the heartbeat URL into your SDK client code.
4. Click Save.

This confirms that your application can actually reach and evaluate flags — not just that the Flipt process is alive.

Step 7: Configure Alert Channels

1. Go to Alert Channels in Vigilmon and add Slack, email, or a webhook.
2. Set Consecutive failures before alert to 2 on HTTP monitors — Flipt may briefly return non-200 during database migrations or restarts.
3. Consider routing Flipt alerts to your on-call channel with higher urgency than other monitors, since a flag server outage affects every feature rollout in progress.

Summary

| Monitor | Target | What It Catches | |---|---|---| | HTTP health | :8080/health | Process crash, DB connectivity loss | | HTTP flags API | :8080/api/v1/namespaces/default/flags | API-layer failure | | HTTP web UI | :8080/ | UI serving failure | | TCP port | :8080 (HTTP) | Network-layer failure | | TCP port | :9000 (gRPC) | gRPC listener crash | | SSL certificate | Flipt domain | Certificate expiry before clients fail | | Cron heartbeat | Heartbeat URL | SDK connectivity failure |

Self-hosting Flipt gives you data sovereignty and eliminates vendor lock-in for feature flags — but it means your team owns availability. With Vigilmon monitoring the health endpoint, evaluation API, gRPC port, and SSL certificate, you'll know about Flipt problems before your application's fallback-to-default behavior starts affecting users.