tutorial

Monitoring Bigeye with Vigilmon: Data Observability Platform Health, API Availability & Webhook Delivery

How to monitor Bigeye data observability infrastructure with Vigilmon — API availability, dashboard uptime, webhook delivery health, and SSL certificate validity.

Bigeye is the data observability platform that automatically monitors data quality across your warehouse tables, detects anomalies in row counts, freshness, and field distributions, and alerts data engineers before downstream consumers notice a problem. When Bigeye's API goes down, scheduled data quality checks stop running silently. When the dashboard becomes unavailable, teams lose the alert history and lineage context needed to diagnose a data incident. When webhook delivery fails, Slack and PagerDuty integrations stop receiving data quality alerts, leaving incidents invisible to on-call engineers. Vigilmon gives you external visibility into Bigeye's availability: the API, dashboard, and outbound webhook endpoints, so you know the moment the observability platform itself becomes unobservable.

What You'll Build

  • An HTTP monitor on the Bigeye dashboard to detect frontend failures
  • A health-check monitor on the Bigeye REST API to catch backend degradation
  • A monitor on your webhook receiver to verify Bigeye alert delivery is flowing
  • An SSL certificate monitor for your Bigeye domain
  • Alerting that distinguishes API outages from webhook delivery failures

Prerequisites

  • A Bigeye account with API access (cloud-hosted or self-hosted deployment)
  • The Bigeye dashboard exposed via HTTPS (e.g., https://app.bigeye.com or your self-hosted domain)
  • A webhook receiver endpoint configured to accept Bigeye data quality alerts
  • A free account at vigilmon.online

Step 1: Understand Bigeye's Service Architecture

Bigeye's deployment (cloud or self-hosted) centers on a set of cooperating services:

| Component | Default port | Role | |---|---|---| | Bigeye Dashboard | 443 (HTTPS) | Web UI for data quality rules, alert history, and lineage | | Bigeye REST API | 443 (HTTPS) | Rule evaluation triggers, alert queries, and catalog sync | | Metric collection workers | Internal | Pull metrics from warehouse (Snowflake, BigQuery, Redshift, etc.) | | Webhook dispatcher | Outbound | Delivers data quality alerts to Slack, PagerDuty, and custom endpoints |

External monitoring focuses on the API and dashboard HTTPS endpoints — these surface the availability of the entire Bigeye deployment and are the interfaces your engineers interact with directly.

Step 2: Monitor the Bigeye Dashboard with HTTP Check

The Bigeye dashboard is the primary interface for reviewing data quality alerts, configuring monitors, and inspecting anomaly history:

curl -I https://app.bigeye.com
# Returns HTTP 200 with HTML when the frontend is healthy
  1. Log in to Vigilmon → Add Monitor → HTTP.
  2. URL: https://app.bigeye.com (or your self-hosted Bigeye domain).
  3. Check interval: 60 seconds.
  4. Response timeout: 15 seconds.
  5. Expected status: 200.
  6. Keyword: Bigeye (appears in the page title and HTML content).
  7. Click Save.

This monitor catches:

  • Bigeye frontend process crashes or deployment failures
  • CDN or reverse proxy misconfigurations blocking dashboard access
  • Failed Bigeye upgrades that leave the frontend in a broken state
  • DNS resolution failures for the Bigeye domain

Alert sensitivity: Set to trigger after 1 consecutive failure. When the Bigeye dashboard is unavailable, data engineers cannot investigate open alerts or modify data quality rules during an active incident.

Step 3: Monitor the Bigeye REST API

Bigeye's REST API is used both by the dashboard frontend and by automated integrations that trigger rule evaluations and query alert state. When the API is degraded, scheduled data quality checks may stop running even if the dashboard HTML appears to load from cache:

curl https://app.bigeye.com/api/v1/health
# Returns: {"status": "ok"} when the API is healthy
  1. Add Monitor → HTTP.
  2. URL: https://app.bigeye.com/api/v1/health.
  3. Check interval: 60 seconds.
  4. Response timeout: 10 seconds.
  5. Expected status: 200.
  6. Keyword: ok (present in healthy API responses).
  7. Label: Bigeye API health.
  8. Click Save.

Why monitor the API separately from the dashboard? The dashboard may serve cached HTML from a CDN even when the API backend is down. A failing API means Bigeye cannot evaluate data quality rules, cannot deliver alerts to webhook destinations, and cannot respond to queries from automated pipelines that poll for data quality status before proceeding with downstream transformations.

Step 4: Monitor Your Webhook Receiver

Bigeye delivers data quality alerts to your on-call tools (Slack, PagerDuty, custom webhooks) via outbound HTTP calls. If your webhook receiver endpoint becomes unavailable or returns errors, Bigeye alert delivery fails silently — your on-call team stops receiving data quality notifications even though Bigeye is still detecting anomalies internally.

Set up a lightweight HTTP endpoint on your webhook receiver and monitor it:

curl https://your-webhook-receiver.example.com/health
# Returns: {"status": "ok"} when the receiver is up
  1. Add Monitor → HTTP.
  2. URL: https://your-webhook-receiver.example.com/health.
  3. Check interval: 2 minutes.
  4. Response timeout: 10 seconds.
  5. Expected status: 200.
  6. Keyword: ok.
  7. Label: Bigeye webhook receiver.
  8. Click Save.

If your receiver is a hosted service (Slack, PagerDuty), monitor your own middleware or integration relay instead. For Slack incoming webhooks, you can verify the Slack API is reachable at https://slack.com/api/api.test.

Step 5: Monitor the Bigeye Catalog Sync Endpoint

For teams using Bigeye's automated catalog sync (where Bigeye pulls schema metadata from your warehouse on a schedule), a dedicated sync status endpoint confirms the catalog is updating:

curl https://app.bigeye.com/api/v1/catalog/status
# Returns catalog sync status and last successful sync timestamp
  1. Add Monitor → HTTP.
  2. URL: https://app.bigeye.com/api/v1/catalog/status.
  3. Check interval: 5 minutes.
  4. Response timeout: 15 seconds.
  5. Expected status: 200.
  6. Keyword: status (present in the response JSON).
  7. Label: Bigeye catalog sync.
  8. Click Save.

Catalog sync failures mean new warehouse tables and schema changes are not reflected in Bigeye's rule engine, causing newly added columns to go unmonitored until the sync recovers.

Step 6: Monitor SSL Certificates

Bigeye's dashboard and REST API are accessed over HTTPS by both engineers and automated systems that poll Bigeye's API for data quality status before triggering downstream pipeline steps. An expired certificate breaks both browser access and programmatic API calls:

openssl s_client -connect app.bigeye.com:443 2>/dev/null | openssl x509 -noout -dates
  1. Add Monitor → SSL Certificate.
  2. Domain: app.bigeye.com (or your self-hosted domain).
  3. Alert when expiry is within: 30 days.
  4. Alert again: 14 days, 7 days, 3 days, 1 day.
  5. Click Save.

API client impact: Data pipelines that call Bigeye's API to check data quality status before running downstream transformations will fail with TLS errors when the certificate expires. These failures are often silent — the pipeline either skips the quality check entirely or crashes without a clear error, letting bad data propagate downstream.

Step 7: Configure Alerting

In Vigilmon under Settings → Notifications, configure your alert channels:

| Monitor | Trigger | Action | |---|---|---| | Dashboard | Non-200 or Bigeye missing | Check Bigeye frontend deployment; inspect CDN configuration | | API health | Non-200 or ok missing | Backend down; check Bigeye service logs; verify database connectivity | | Webhook receiver | Non-200 or ok missing | On-call alerts not delivering; verify receiver deployment and connectivity | | Catalog sync | Non-200 or status missing | Schema sync stalled; check warehouse connectivity from Bigeye workers | | SSL certificate | < 30 days to expiry | Renew certificate; verify API clients reconnect after renewal |

Alert after: 1 consecutive failure for the dashboard and API health monitors. 2 consecutive failures for catalog sync and webhook receiver to avoid noise from transient timeouts.

Common Bigeye Failure Modes and What Vigilmon Catches

| Scenario | Vigilmon monitor | |---|---| | Bigeye API process crash | API health monitor fires; data quality rule evaluation stops | | Dashboard frontend deployment failure | Dashboard monitor fires; engineers cannot review open alerts | | Webhook receiver crash | Webhook receiver monitor fires; on-call team stops getting data quality alerts | | Catalog sync failure | Catalog sync monitor fires; new tables go unmonitored | | TLS certificate expired | SSL monitor alerts at 30-day threshold; API clients start failing | | DNS misconfiguration | All monitors fire simultaneously | | Network partition between Bigeye and warehouse | API health may degrade; catalog sync monitor fires | | Bigeye upgrade leaves API in broken state | API health monitor fires; dashboard monitor may also fire |

Monitoring Data Quality Checks Themselves (Beyond Infrastructure)

Vigilmon monitors Bigeye's infrastructure endpoints — the API, dashboard, and webhook receiver. The health of individual data quality checks is a separate concern that requires application-level observability within Bigeye:

  • Bigeye's built-in alerting: Configure alert policies within Bigeye to route data quality failures to Slack, PagerDuty, or email — this is separate from monitoring Bigeye's own availability.
  • Data freshness monitoring: Bigeye's freshness monitors track how recently tables were updated. These are Bigeye-level monitors for data pipeline health, not infrastructure availability.
  • Rule coverage auditing: Periodically audit which tables have Bigeye monitors configured to ensure new tables added to the warehouse are covered.

Vigilmon catches infrastructure-level failures — when Bigeye itself is down. Data quality failures within a healthy Bigeye deployment require Bigeye's own notification rules.

Bigeye is the layer that keeps your data warehouse honest — when it goes down, anomalies in row counts, freshness, and field distributions go undetected until downstream consumers notice broken dashboards and incorrect reports. Vigilmon gives you external visibility into Bigeye's availability that doesn't depend on Bigeye self-reporting: API uptime, dashboard health, webhook delivery readiness, and SSL certificate validity, so you know the moment the observability platform itself needs attention and can restore data quality monitoring before the next anomaly goes undetected.

Start monitoring Bigeye in under 5 minutes — register free at vigilmon.online.

Monitor your app with Vigilmon

Free plan — 5 monitors, no credit card required. Up and running in 60 seconds.

Start free →
← Back to all articles