Monitoring Taiko Browser Automation Tests with Vigilmon: Detect Silent Test Suite Failures

Your Taiko smoke suite ran successfully after every deployment for two months. Then a Node.js version bump on the CI agent introduced a Chromium binary path mismatch. The Gauge runner launched, found zero specifications, and exited cleanly with code 0. Your team shipped three releases without a single browser test running.

This is the silent browser automation failure problem. Uptime monitors check HTTP responses — not "did Taiko actually open a browser and run tests today?" The answer is heartbeat monitoring: Taiko pings a unique URL at the end of a successful run, and Vigilmon alerts you the moment that ping goes missing.

This tutorial walks you through wiring Taiko into Vigilmon so a broken test runner can never silently let regressions through.

What You'll Cover

• Heartbeat monitoring for Taiko test suites run via Gauge or standalone scripts
• Detecting Taiko runners that start but open no browsers
• Alerting on suites that fail, hang, or are never invoked
• Multi-environment monitoring (staging and production smoke tests)
• CI integration for GitHub Actions and GitLab CI

Prerequisites

• Taiko installed (npm install -g taiko) with Gauge or a custom test runner
• A free account at vigilmon.online

The Problem: What Taiko's Built-In Reporting Misses

Taiko generates clean pass/fail output and Gauge produces HTML reports — but neither tells you when:

• The CI pipeline that schedules the Gauge run is removed or paused
• A Chromium binary is missing and the process exits before any page is opened
• Zero spec files match the discovery pattern (clean exit, no tests run)
• A before_suite hook throws and the rest of the suite is silently skipped
• The test machine runs out of disk space and the browser process is killed

Vigilmon's heartbeat pattern turns the absence of a ping into an alert.

Step 1: Create a Heartbeat Monitor in Vigilmon

1. Log in to Vigilmon and click New Monitor → Heartbeat.
2. Name it something like Taiko E2E — Staging Smoke.
3. Set Expected interval to match your run schedule — 4 hours for post-deploy smoke, 24 hours for nightly regression.
4. Set Grace period to 15 minutes to allow for browser launch delays and retries.
5. Save and copy the Ping URL — it looks like https://vigilmon.online/api/heartbeat/<unique-id>.

Step 2: Ping Vigilmon from a Taiko Script

Option A — Standalone Taiko script

Add a heartbeat call at the end of a successful run in your entry-point script:

// run-smoke.js
const { openBrowser, goto, closeBrowser, text } = require("taiko");
const https = require("https");

function pingVigilmon(url) {
  return new Promise((resolve, reject) => {
    const req = https.request(url, { method: "POST" }, (res) => resolve(res.statusCode));
    req.on("error", reject);
    req.setTimeout(10000, () => req.destroy(new Error("Vigilmon ping timed out")));
    req.end();
  });
}

(async () => {
  try {
    await openBrowser({ headless: true });
    await goto("https://staging.example.com");

    if (!(await text("Welcome").exists())) {
      throw new Error("Home page check failed");
    }

    // All checks passed — send heartbeat
    const heartbeatUrl = process.env.VIGILMON_HEARTBEAT_URL;
    if (heartbeatUrl) {
      await pingVigilmon(heartbeatUrl);
      console.log("Vigilmon heartbeat sent");
    }
  } catch (err) {
    console.error("Test failed:", err.message);
    process.exit(1);   // Non-zero exit suppresses heartbeat
  } finally {
    await closeBrowser();
  }
})();

Run it:

VIGILMON_HEARTBEAT_URL="https://vigilmon.online/api/heartbeat/<id>" node run-smoke.js

Option B — Gauge after_suite hook

If you run Taiko via Gauge, add the heartbeat to an after_suite hook that only fires on clean runs:

// tests/hooks.js
const { BeforeSuite, AfterSuite } = require("gauge");
const https = require("https");

let suiteFailed = false;

BeforeSuite(async () => {
  suiteFailed = false;
});

AfterSuite(async (context) => {
  if (suiteFailed) return;

  const heartbeatUrl = process.env.VIGILMON_HEARTBEAT_URL;
  if (!heartbeatUrl) return;

  await new Promise((resolve, reject) => {
    const req = https.request(heartbeatUrl, { method: "POST" }, (res) => resolve());
    req.on("error", reject);
    req.setTimeout(10000, () => req.destroy(new Error("timeout")));
    req.end();
  });
  console.log("Vigilmon heartbeat sent");
});

Gauge sets the suite context to failed when any specification fails — read it to conditionally suppress the ping:

AfterSuite(async (context) => {
  // context.currentScenario is undefined at suite level;
  // track failures via BeforeScenario/AfterScenario hooks instead.
  if (process.exitCode !== 0) return;
  // ... send ping
});

Step 3: CI Integration

GitHub Actions

# .github/workflows/smoke.yml
name: Taiko Smoke Tests

on:
  schedule:
    - cron: "0 */4 * * *"   # Every 4 hours
  push:
    branches: [main]

jobs:
  taiko-smoke:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Set up Node.js
        uses: actions/setup-node@v4
        with:
          node-version: "20"

      - name: Install dependencies
        run: npm ci

      - name: Install Chromium for Taiko
        run: npx taiko install chromium

      - name: Run Taiko smoke tests
        env:
          VIGILMON_HEARTBEAT_URL: ${{ secrets.VIGILMON_TAIKO_HEARTBEAT_URL }}
        run: node run-smoke.js

GitHub Actions with Gauge

      - name: Run Gauge specs
        env:
          VIGILMON_HEARTBEAT_URL: ${{ secrets.VIGILMON_TAIKO_HEARTBEAT_URL }}
        run: gauge run --env staging specs/

GitLab CI

# .gitlab-ci.yml
taiko:smoke:
  stage: test
  image: node:20
  variables:
    VIGILMON_HEARTBEAT_URL: $VIGILMON_TAIKO_HEARTBEAT_URL
  only:
    - schedules
    - main
  before_script:
    - npm ci
    - npx taiko install chromium
  script:
    - node run-smoke.js

Step 4: Multi-Environment Monitoring

Create a separate Vigilmon monitor for each environment and test tier:

| Suite | Environment | Monitor name | Interval | |---|---|---|---| | Post-deploy smoke | Staging | Taiko Smoke — Staging | 4 h | | Post-deploy smoke | Production | Taiko Smoke — Production | 4 h | | Nightly regression | Staging | Taiko E2E — Nightly | 25 h | | Critical-path check | Production | Taiko Critical Path — Production | 1 h |

Parameterize by environment in your script:

const env = process.env.TARGET_ENV || "staging";
const heartbeatVar = `VIGILMON_${env.toUpperCase()}_HEARTBEAT_URL`;
const heartbeatUrl = process.env[heartbeatVar];

TARGET_ENV=production \
  VIGILMON_PRODUCTION_HEARTBEAT_URL="https://vigilmon.online/api/heartbeat/<prod-id>" \
  node run-smoke.js

Step 5: Configure Alert Channels

In Vigilmon, go to Notifications → New Channel and configure:

• Email — immediate notification when a heartbeat is missed
• Slack webhook — ping your #qa-alerts or #deployments channel

Sample missed-heartbeat notification:

🔴 MISSED HEARTBEAT: Taiko Smoke — Staging
Last ping: 5 hours ago
Expected interval: 4 hours

Recovery notification:

✅ HEARTBEAT RECOVERED: Taiko Smoke — Staging
Gap: 5 hours

What You're Now Catching

| Silent failure mode | How Vigilmon detects it | |---|---| | CI pipeline disabled or deleted | No ping arrives → alert after grace period | | Chromium binary missing | Process exits before tests run, no ping → alert | | Zero spec files discovered | Suite ends empty (exit 0), no ping → alert | | before_suite hook throws | Tests never run, no ping → alert | | Browser crashes mid-suite | Non-zero exit, heartbeat suppressed → alert | | Scheduled trigger dropped | No ping at expected interval → alert |

Taiko gives you fast, readable browser automation — until the test machine goes quiet. Vigilmon's heartbeat monitors give you the external signal Taiko can't: a definitive alert when your browser tests haven't run in longer than expected.

Wire Vigilmon into your Taiko suite today — register free at vigilmon.online.