Uptime monitoring for Dendrite Matrix homeserver

Dendrite is a next-generation Matrix homeserver written in Go. It is designed to be lightweight, scalable, and correct — making it popular as a self-hosted alternative to Synapse for communities and personal deployments. Because Dendrite acts as the backbone for real-time messaging and federation, downtime means lost messages, broken federation, and users left unable to communicate.

This tutorial covers production-grade uptime monitoring for Dendrite using Vigilmon. We will walk through:

• Monitoring the Matrix client API health endpoint
• Monitoring the federation API endpoint
• Monitoring the media repository service
• SSL certificate alerts for your Matrix domain
• Response time monitoring to catch performance degradation

Prerequisites

• Dendrite running as a monolith or polylith deployment (Docker, systemd, or bare metal)
• Your Matrix domain publicly reachable (e.g., matrix.example.com)
• A free account at vigilmon.online

Part 1: Monitor the Matrix client API health endpoint

Dendrite exposes the standard Matrix client API at /_matrix/client/versions. This endpoint returns the list of Matrix spec versions the server supports. It requires no authentication and is the canonical way to verify that the client-facing API is responding.

Test the endpoint manually

curl https://matrix.example.com/_matrix/client/versions

Expected response:

{
  "versions": ["r0.0.1", "r0.1.0", "r0.2.0", "r0.3.0", "r0.4.0", "r0.5.0", "r0.6.0", "v1.1", "v1.2"]
}

A healthy Dendrite always returns HTTP 200 with a versions array. If Dendrite is down or restarting, this endpoint returns 502/503 or times out.

Add a Vigilmon HTTP monitor

1. Log in to vigilmon.online and click Add Monitor.
2. Choose HTTP(S) monitor.
3. Enter: https://matrix.example.com/_matrix/client/versions
4. Set interval to 1 minute.
5. Add a keyword check: must contain versions.
6. Add your alert channel (email, Slack, webhook).
7. Click Save.

The keyword check confirms the actual Dendrite handler responded — not a cached error page from a reverse proxy.

Part 2: Monitor the federation API endpoint

Matrix federation is how your homeserver communicates with other servers in the Matrix network. If federation breaks, your users cannot send or receive messages from users on other homeservers. The /_matrix/federation/v1/version endpoint returns the server name and version and confirms the federation API is reachable.

Test the federation endpoint

curl https://matrix.example.com/_matrix/federation/v1/version

Expected response:

{
  "server": {
    "name": "Dendrite",
    "version": "0.13.7"
  }
}

Federation typically runs on port 8448 or behind a reverse proxy on port 443 with the .well-known/matrix/server delegation file. Verify which port your deployment uses:

# Check .well-known delegation
curl https://example.com/.well-known/matrix/server
# {"m.server": "matrix.example.com:443"}

# Or test port 8448 directly
curl https://matrix.example.com:8448/_matrix/federation/v1/version

Add a federation monitor in Vigilmon

1. Click Add Monitor → HTTP(S) monitor.
2. Enter the federation endpoint URL (using whichever port your deployment exposes).
3. Set interval to 2 minutes (federation is lower-priority than client API).
4. Add a keyword check: must contain Dendrite.
5. Name the monitor Dendrite Federation API.
6. Click Save.

Monitoring federation separately from the client API lets you distinguish between "Dendrite is completely down" and "only federation is broken," which have different remediation paths.

Part 3: Monitor the media repository

Dendrite serves user-uploaded media (images, files, avatars) through the media repository at /_matrix/media/. If this service fails, users see broken images and cannot share files even when the core messaging API is healthy.

Add a media repository monitor

The simplest check is the media repository version endpoint:

curl https://matrix.example.com/_matrix/media/v3/config

This returns the server's media upload size limit configuration. Use it as a lightweight availability check:

1. Click Add Monitor → HTTP(S) monitor.
2. Enter: https://matrix.example.com/_matrix/media/v3/config
3. Set interval to 5 minutes (media outages are less urgent than messaging outages).
4. Add a keyword check: must contain upload.
5. Name the monitor Dendrite Media Repository.
6. Click Save.

For Dendrite polylith deployments where the media API runs as a separate component, this monitor tells you specifically when the media component is down versus the rest of Dendrite.

Part 4: SSL certificate monitoring

Your Matrix domain certificate is critical. Matrix clients and other homeservers verify TLS strictly — an expired certificate causes federation failures across the entire network and breaks all client connections immediately.

1. In Vigilmon, click Add Monitor.
2. Choose SSL monitor.
3. Enter matrix.example.com (and example.com if you use a separate base domain for delegation).
4. Set alert threshold to 21 days before expiry — federation issues from expired certs cascade quickly.
5. Add your alert channel.
6. Click Save.

If you use port 8448 for federation, add a second SSL monitor for matrix.example.com:8448.

Part 5: Response time monitoring

Dendrite is written in Go and should be fast. Sustained high response times (above 2–3 seconds) on the client API indicate database contention, resource exhaustion, or a misconfigured reverse proxy. Catching latency spikes early prevents cascading failures.

Vigilmon records response time for every HTTP check. To set response time alerting:

1. Open the Dendrite Client API monitor you created in Part 1.
2. Under Advanced settings, enable Response time alert.
3. Set threshold to 3000 ms.
4. Save.

You can also view historical response time charts in the Vigilmon dashboard to spot trends — a gradual increase in response time often signals a slow database query or a memory leak before the service actually goes down.

Part 6: Webhook alerts for incident response

Add a webhook so Vigilmon delivers DOWN/UP events to your infrastructure:

// Example: Node.js webhook receiver for Dendrite alerts
import express from 'express';

const app = express();
app.use(express.json());

app.post('/webhook/vigilmon', (req, res) => {
  const { monitor_name, status, url, response_code, checked_at } = req.body;

  if (status === 'down') {
    console.error('[VIGILMON] Dendrite monitor DOWN', {
      monitor: monitor_name,
      url,
      code: response_code,
      at: checked_at,
    });
    // Notify on-call, post to ops Matrix room, create incident
  } else if (status === 'up') {
    console.info('[VIGILMON] Dendrite monitor recovered', { monitor: monitor_name });
  }

  res.sendStatus(204);
});

Vigilmon delivers this payload on DOWN and UP transitions:

{
  "monitor_id": "mon_xyz789",
  "monitor_name": "Dendrite Client API",
  "status": "down",
  "url": "https://matrix.example.com/_matrix/client/versions",
  "checked_at": "2026-06-30T09:15:00Z",
  "response_code": 502,
  "response_time_ms": 10001
}

For Matrix-native alerting, route Vigilmon webhooks into a dedicated ops Matrix room using a simple bot so the team sees alerts in the same tool they use for communication.

Summary

Your Dendrite deployment now has four monitoring layers:

1. Client API (/_matrix/client/versions) — confirms Dendrite is alive and serving Matrix clients, polled every 60 seconds.
2. Federation API (/_matrix/federation/v1/version) — confirms cross-server messaging is working, polled every 2 minutes.
3. Media repository — confirms file and image uploads/downloads are functional, polled every 5 minutes.
4. SSL certificate — alerts 21 days before expiry to prevent federation blacklisting across the Matrix network.

Vigilmon handles check scheduling, multi-region polling, alert routing, and uptime history. You get notified within one check interval of any failure — before your users file support tickets.

Monitor your Dendrite homeserver free at vigilmon.online

#dendrite #matrix #selfhosted #monitoring #devops