tutorial

Uptime Monitoring for Thunder Client VS Code Extension Backend Services 2026

Thunder Client lives inside VS Code and tests your backend services. Add health endpoints, heartbeat monitoring, and uptime alerts for those services — free, in under 30 minutes.

Uptime Monitoring for Thunder Client VS Code Extension Backend Services 2026

Thunder Client is the lightweight REST client built directly into VS Code. Developers love it because there's no context switch — you test your API without leaving the editor. But Thunder Client sends requests on demand; it doesn't watch your backend services continuously.

This guide shows how to add external uptime monitoring to every service you test with Thunder Client — so you know about outages before you open VS Code.

The problem with editor-embedded testing

Thunder Client is tightly coupled to your development workflow. You use it when you're actively building. Your backend services run continuously.

The mismatch:

| | Thunder Client | Vigilmon | |---|---|---| | When it runs | When a developer triggers it | Continuously, every 5 minutes | | Where it runs | Your local machine | Multiple global regions | | Failure detection | Only when you're in VS Code | Immediately, from anywhere | | Background jobs | No | Yes (heartbeat monitors) |

Use Thunder Client for interactive development and debugging. Use Vigilmon for continuous production monitoring.

Step 1: Add a health endpoint to your backend services

For every backend service you test with Thunder Client, add a /health endpoint. This becomes the URL Vigilmon probes every 5 minutes.

Node.js / Express:

// routes/health.js
const express = require('express');
const router = express.Router();

router.get('/health', async (req, res) => {
  const checks = {};

  // Check database
  try {
    await db.query('SELECT 1');
    checks.database = { status: 'ok' };
  } catch (err) {
    checks.database = { status: 'error', detail: err.message };
  }

  // Check Redis cache
  try {
    await redis.ping();
    checks.cache = { status: 'ok' };
  } catch (err) {
    checks.cache = { status: 'error', detail: err.message };
  }

  const allOk = Object.values(checks).every(c => c.status === 'ok');

  res.status(allOk ? 200 : 503).json({
    status: allOk ? 'ok' : 'degraded',
    checks,
    timestamp: new Date().toISOString(),
  });
});

module.exports = router;

Python / Django:

# views/health.py
from django.http import JsonResponse
from django.db import connection
from django.core.cache import cache

def health_check(request):
    checks = {}

    # Database check
    try:
        with connection.cursor() as cursor:
            cursor.execute('SELECT 1')
        checks['database'] = {'status': 'ok'}
    except Exception as e:
        checks['database'] = {'status': 'error', 'detail': str(e)}

    # Cache check
    try:
        cache.set('health_ping', 'pong', timeout=5)
        val = cache.get('health_ping')
        if val != 'pong':
            raise ValueError('Cache read/write mismatch')
        checks['cache'] = {'status': 'ok'}
    except Exception as e:
        checks['cache'] = {'status': 'error', 'detail': str(e)}

    all_ok = all(c['status'] == 'ok' for c in checks.values())

    return JsonResponse(
        {'status': 'ok' if all_ok else 'degraded', 'checks': checks},
        status=200 if all_ok else 503,
    )

Add it to Thunder Client — create a GET /health request in a _Health folder in your Thunder Client collection. Your teammates who clone the repo get the health check request immediately.

Step 2: Store Thunder Client collections in git

Thunder Client supports a "Save to workspace" mode that stores collections as JSON files alongside your code:

my-project/
├── src/
├── .thunder-tests/
│   ├── thunderclient.json        # collection metadata
│   └── thunder-collection-*.json # your requests
└── package.json

Enable this in VS Code settings:

// .vscode/settings.json
{
  "thunder-client.saveToWorkspace": true
}

With collections in git, your health check requests are version-controlled alongside the services they test.

Step 3: Set up external HTTP monitoring with Vigilmon

With your /health endpoints live, point Vigilmon at them:

  1. Sign up at vigilmon.online — free tier, no credit card
  2. Click New Monitor → HTTP
  3. Enter https://yourservice.com/health
  4. Set the check interval (5 minutes on free tier)
  5. Save

Map your Thunder Client environments to Vigilmon monitors:

| Thunder Client Environment | Vigilmon Monitor URL | |---|---| | production | https://api.yourdomain.com/health | | staging | https://staging.api.yourdomain.com/health | | development | https://dev.api.yourdomain.com/health (if deployed) |

Step 4: Heartbeat monitoring for backend cron jobs and workers

Your backend likely runs scheduled jobs alongside the API — data sync, cleanup, report generation, queue processing. These don't have HTTP endpoints for Vigilmon to probe. Use heartbeat monitors instead.

The pattern: the job pings a unique URL on successful completion. If Vigilmon doesn't receive the ping within the expected window, it fires an alert.

In Vigilmon:

  1. New Monitor → Heartbeat
  2. Set the expected interval (add a buffer — a 24h job should use a 25h window)
  3. Copy the ping URL
  4. Add it to your environment

Node.js cron job with heartbeat:

// jobs/nightly-sync.js
const cron = require('node-cron');
const axios = require('axios');

cron.schedule('0 2 * * *', async () => {
  try {
    console.log('Starting nightly sync...');
    await runSync();
    console.log('Nightly sync complete.');

    // Only ping on success — the missed ping IS the alert
    if (process.env.SYNC_HEARTBEAT_URL) {
      await axios.get(process.env.SYNC_HEARTBEAT_URL);
    }
  } catch (err) {
    // Log the error; the absence of a heartbeat ping triggers the Vigilmon alert
    console.error('Nightly sync failed:', err);
  }
});

async function runSync() {
  // Your actual sync logic
}

Python Celery task with heartbeat:

# tasks.py
from celery import shared_task
import requests
import os
import logging

logger = logging.getLogger(__name__)

@shared_task
def nightly_cleanup():
    try:
        run_cleanup()

        heartbeat_url = os.environ.get('CLEANUP_HEARTBEAT_URL')
        if heartbeat_url:
            requests.get(heartbeat_url, timeout=10)
            logger.info('nightly_cleanup: heartbeat sent')

    except Exception:
        # Don't ping — missed ping triggers the alert
        logger.exception('nightly_cleanup: failed')
        raise


def run_cleanup():
    # Your cleanup logic
    pass

Add environment variables for each heartbeat:

# .env (never commit this)
SYNC_HEARTBEAT_URL=https://vigilmon.online/api/heartbeat/token-abc
CLEANUP_HEARTBEAT_URL=https://vigilmon.online/api/heartbeat/token-def
REPORT_HEARTBEAT_URL=https://vigilmon.online/api/heartbeat/token-ghi

Step 5: Monitor your Thunder Client requests in CI

Thunder Client collections can be run in CI using the @thunderclient/cli package:

npm install -D @thunderclient/cli

package.json:

{
  "scripts": {
    "test:api": "tc-cli run --env production"
  }
}

GitHub Actions:

# .github/workflows/api-tests.yml
name: API Tests

on:
  schedule:
    - cron: '0 8 * * *'
  push:
    branches: [main]

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

      - name: Install dependencies
        run: npm ci

      - name: Start service
        run: npm run start:test &
        # Give the service time to start
      
      - name: Wait for service
        run: npx wait-on http://localhost:3000/health

      - name: Run Thunder Client tests
        run: npm run test:api

      - name: Ping heartbeat on success
        if: success()
        run: curl -fsS "${{ secrets.TC_HEARTBEAT_URL }}"

Step 6: Alert routing

In Vigilmon Notifications → New Channel, configure where alerts go:

Slack — recommended for team notification:

1. Create Slack incoming webhook at api.slack.com/messaging/webhooks
2. In Vigilmon: Notifications → New Channel → Slack
3. Paste webhook URL
4. Enable on your monitors

Alert format:

🔴 DOWN: api.yourdomain.com/health
Status: 503 | Started: 4 min ago
Regions failing: US-East, EU-West, AP-Southeast

VS Code extension (for solo developers):

Vigilmon sends email alerts by default. Pair with a VS Code notification extension or a push notification service (Pushover, ntfy.sh) so you get alerted even when VS Code is closed.

# ntfy.sh example — send to your phone
# Configure in Vigilmon via webhook:
curl -d "API is DOWN: api.yourdomain.com" ntfy.sh/your-topic

Step 7: Public status page

When your service is down, a status page gives users a place to check:

  1. Status Pages → New Status Page
  2. Add your production monitors
  3. Copy the public URL

Add the status page URL to your VS Code workspace README and your API documentation so your team and users always know where to check.

What you've built

| What | How | |---|---| | Health endpoints | /health per service, saved in Thunder Client collection | | External uptime monitoring | Vigilmon HTTP monitors per environment | | Background job heartbeats | Ping on success; missed ping triggers alert | | CI pipeline heartbeats | @thunderclient/cli + Vigilmon heartbeat | | Instant alerts | Slack, email, or push notifications | | Public status page | Linked from workspace README |

Thunder Client makes API testing feel native to VS Code. Your uptime monitoring should feel equally native to your infrastructure — always on, always external, always multi-region.

Get started free at vigilmon.online — your first monitor is running in under a minute.

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