Monitoring Canvas LMS with Vigilmon

Canvas LMS is the open-source learning management system trusted by universities and K-12 districts worldwide. Self-hosting Canvas gives you full control over student data and customization — but it also means you're responsible for keeping the platform available during high-traffic periods like finals week or live class sessions. A failed background job can stop grade notifications; a Redis outage can break the entire session layer; a Delayed::Job worker crash can silently queue thousands of unprocessed emails. Vigilmon gives you continuous visibility across every Canvas service layer so you catch failures before students and instructors do.

What You'll Set Up

• Canvas web server availability (port 3000)
• Background job worker (Delayed::Job) health
• PostgreSQL database connectivity
• Redis cache service monitoring
• File storage backend health
• Email delivery service monitoring
• OAuth/SSO authentication endpoint
• Canvas API response time monitoring
• Canvas Live Events Kinesis stream health

Prerequisites

• Canvas LMS deployed (self-hosted on Linux, Docker, or Kubernetes)
• Admin access to your Canvas instance
• A free Vigilmon account

Step 1: Monitor the Canvas Web Server

Canvas runs on port 3000 by default (proxied through nginx or Apache in production). The web server availability check is your primary health signal.

1. Log in to vigilmon.online and click Add Monitor.
2. Set Type to HTTP / HTTPS.
3. Enter your Canvas URL: https://canvas.yourinstitution.edu
4. Set Check interval to 1 minute.
5. Set Expected HTTP status to 200.
6. Click Save.

Canvas doesn't ship with a dedicated /health endpoint out of the box, but you can probe a lightweight page that exercises the full stack. The login page at /login/canvas is a good candidate — it requires the database and session layer to render successfully:

https://canvas.yourinstitution.edu/login/canvas

Add a keyword check for the string Log In to confirm the page is rendering actual content rather than an error page.

Step 2: Monitor Delayed::Job Background Workers

Canvas relies heavily on Delayed::Job workers for sending notifications, processing grades, generating course exports, and delivering emails. When workers stop, jobs pile up in the queue and students stop receiving notifications — often silently.

Add a cron heartbeat to verify workers are actively processing:

1. In Vigilmon, click Add Monitor → Cron Heartbeat.
2. Set the expected interval to 10 minutes.
3. Copy the heartbeat URL.
4. Create a Canvas plugin or cron job on your Canvas server that checks the job queue and pings the heartbeat:

#!/bin/bash
# Check that Delayed::Job workers are running
WORKER_COUNT=$(ps aux | grep -c '[d]elayed_job')
if [ "$WORKER_COUNT" -gt "0" ]; then
  curl -s https://vigilmon.online/heartbeat/YOUR_DJ_HEARTBEAT_ID
fi

Alternatively, probe the Delayed::Job queue via the Canvas database to confirm jobs are being processed (not just that the worker process exists):

#!/bin/bash
DB_URL="postgresql://canvas:password@localhost/canvas_production"

# Alert if more than 500 pending jobs older than 10 minutes
STUCK_JOBS=$(psql "$DB_URL" -t -c \
  "SELECT COUNT(*) FROM delayed_jobs WHERE run_at < NOW() - INTERVAL '10 minutes' AND locked_at IS NULL AND attempts < 25")

if [ "$STUCK_JOBS" -lt "500" ]; then
  curl -s https://vigilmon.online/heartbeat/YOUR_DJ_HEARTBEAT_ID
fi

Schedule this script every 10 minutes. A queue backlog signals worker health issues even when the process is running.

Step 3: Monitor PostgreSQL Database

Canvas stores all course content, enrollments, grades, and user data in PostgreSQL. Database failures are immediate and total.

1. Add a TCP monitor in Vigilmon.
2. Set Host to your PostgreSQL server hostname.
3. Set Port to 5432.
4. Set Check interval to 1 minute.
5. Click Save.

For a deeper connectivity check, expose a database health endpoint via a simple Rack middleware or a standalone health script:

# config/initializers/health_check.rb (Canvas initializer)
# Add to your canvas nginx config to proxy /health-db to this
Rails.application.routes.draw do
  get '/health-db', to: proc {
    begin
      ActiveRecord::Base.connection.execute('SELECT 1')
      [200, { 'Content-Type' => 'text/plain' }, ['ok']]
    rescue => e
      [503, { 'Content-Type' => 'text/plain' }, ["error: #{e.message}"]]
    end
  }
end

Add an HTTP monitor for https://canvas.yourinstitution.edu/health-db with expected status 200.

Step 4: Monitor Redis Cache

Canvas uses Redis for session storage, page caching, and cache invalidation. A Redis failure typically takes down the entire Canvas session layer — users get logged out and pages fail to load.

1. Add a TCP monitor in Vigilmon.
2. Set Host to your Redis server hostname.
3. Set Port to 6379.
4. Set Check interval to 1 minute.
5. Click Save.

If Redis requires authentication, add a cron heartbeat that runs an authenticated PING:

#!/bin/bash
RESULT=$(redis-cli -h your-redis-host -a your-redis-password ping 2>/dev/null)
if [ "$RESULT" = "PONG" ]; then
  curl -s https://vigilmon.online/heartbeat/YOUR_REDIS_HEARTBEAT_ID
fi

Schedule every 2 minutes. Redis failures in Canvas are among the highest-impact outages — prioritize alerting for this monitor with zero consecutive failure tolerance.

Step 5: Monitor File Storage Backend

Canvas stores course files, assignment submissions, and media uploads in either a local filesystem, Amazon S3, or a compatible object storage backend. A storage failure means students can't submit assignments or download course materials.

For S3-backed storage, add an HTTP monitor that probes a known object:

https://your-bucket.s3.amazonaws.com/health-check.txt

Upload a small health-check.txt file to your Canvas bucket and monitor it with expected status 200. This verifies bucket accessibility and IAM permissions.

For local filesystem storage, add a cron heartbeat:

#!/bin/bash
# Check that the Canvas file storage directory is writable
STORAGE_PATH="/var/canvas/storage"
TEST_FILE="$STORAGE_PATH/.health_$(date +%s)"

if touch "$TEST_FILE" 2>/dev/null && rm "$TEST_FILE" 2>/dev/null; then
  curl -s https://vigilmon.online/heartbeat/YOUR_STORAGE_HEARTBEAT_ID
fi

Step 6: Monitor Email Notification Delivery

Canvas sends a high volume of notification emails — course announcements, grade postings, assignment feedback, and due date reminders. Silent email delivery failures are one of the most common Canvas complaints.

If you're using an SMTP relay or email service with a status API, add an HTTP monitor for its health endpoint:

https://api.sendgrid.com/v3/mail/batch  # or your provider's health URL

For a more direct check, use a cron heartbeat that sends a test message and verifies delivery:

#!/bin/bash
# Send a test email via Canvas's own mailer configuration
echo "Canvas email health check" | mail -s "Vigilmon health check" \
  -S smtp=smtp://your-smtp-host:587 \
  health-check@yourinstitution.edu

if [ $? -eq 0 ]; then
  curl -s https://vigilmon.online/heartbeat/YOUR_EMAIL_HEARTBEAT_ID
fi

Pair this with a dedicated inbox that receives and acknowledges the test messages if you need end-to-end delivery verification.

Step 7: Monitor OAuth/SSO Authentication

Most institutions authenticate Canvas users via SAML, CAS, or OAuth (Google, Microsoft). An SSO endpoint failure locks out all users who don't have local Canvas accounts.

Add an HTTP monitor for your identity provider's SSO endpoint:

https://sso.yourinstitution.edu/saml/metadata

Or for Canvas's OAuth endpoint:

https://canvas.yourinstitution.edu/login/oauth2/auth

Set Expected HTTP status to 200 or 302 (SSO endpoints often redirect). Add a keyword check to confirm the response contains expected content (e.g., your institution's name in the SAML metadata).

Step 8: Monitor Canvas API Response Times

The Canvas REST API is used by LTI integrations, mobile apps, and third-party tools. Slow API responses degrade all downstream integrations simultaneously.

1. Add an HTTP monitor for a lightweight Canvas API endpoint:

https://canvas.yourinstitution.edu/api/v1/accounts/self

2. Add your API token as an Authorization header in the monitor configuration:

Authorization: Bearer YOUR_CANVAS_API_TOKEN

3. Enable Response time alerting in Vigilmon.
4. Set Alert threshold to 2000ms.
5. Click Save.

Use a read-only API token scoped to account-level access. This probe exercises the full Canvas API stack without writing any data.

Step 9: Monitor Canvas Live Events Kinesis Stream

If your Canvas deployment publishes Live Events to Amazon Kinesis (used for analytics, LRS integrations, and audit logs), stream health is critical for downstream data pipelines.

Add a cron heartbeat that checks the Kinesis stream status via the AWS CLI:

#!/bin/bash
STREAM_STATUS=$(aws kinesis describe-stream-summary \
  --stream-name canvas-live-events \
  --query 'StreamDescriptionSummary.StreamStatus' \
  --output text 2>/dev/null)

if [ "$STREAM_STATUS" = "ACTIVE" ]; then
  curl -s https://vigilmon.online/heartbeat/YOUR_KINESIS_HEARTBEAT_ID
fi

Schedule every 15 minutes. A non-ACTIVE stream status means Live Events are buffering or dropping on the Canvas side.

Step 10: Configure Alert Channels

1. Go to Alert Channels in Vigilmon and add Slack, email, or a webhook for your IT ticketing system.
2. Create a high-priority channel for database and Redis monitors — these require immediate response.
3. Set Consecutive failures before alert to 2 on the web server monitor (Canvas can have brief delays during garbage collection or job processing peaks).
4. Set consecutive failures to 1 on PostgreSQL and Redis TCP monitors.
5. Add a Maintenance window in Vigilmon for your scheduled Canvas upgrade windows.

Summary

| Monitor | Target | What It Catches | |---|---|---| | HTTP web server | /login/canvas | Canvas UI/API down | | Cron heartbeat | DJ worker script | Background jobs not processing | | TCP PostgreSQL | :5432 | Database unavailable | | TCP Redis | :6379 | Session layer broken | | HTTP / Heartbeat | S3 or storage path | File upload/download broken | | Cron heartbeat | Email delivery script | Notification emails not sending | | HTTP SSO | Identity provider metadata URL | Login broken for SSO users | | HTTP API | /api/v1/accounts/self | API slow or unresponsive | | Cron heartbeat | Kinesis stream check | Live Events pipeline broken | | SSL certificate | Canvas domain | Certificate expiry breaks access |

Canvas LMS is the academic backbone for your institution — an outage during exam submission or a final grade posting can have real consequences for students. With Vigilmon watching every layer from the web server to the background job queue, your team knows about failures before they impact the classroom.