Monitoring LinkAce with Vigilmon

LinkAce is a self-hosted bookmark manager and link archive built on Laravel — providing organized bookmarking with automatic metadata fetching, tagging, list management, built-in dead link detection, and optional Wayback Machine archival. It's a powerful replacement for Pinboard, Raindrop.io, or browser bookmarks for researchers, writers, and knowledge workers who want full control over their link collections. But "full control" means you own the uptime too. Vigilmon monitors your LinkAce web application, REST API, built-in link checker health, and scheduler so your archive stays accessible and your link checking stays active.

What You'll Set Up

• HTTP monitor for the LinkAce web application
• REST API health check via the links endpoint
• Application-level health metric via the failed link checker count
• Scheduler health heartbeat (Laravel scheduled tasks)
• SSL certificate expiry alerts for your LinkAce domain

Prerequisites

• LinkAce installed and accessible over HTTP/HTTPS (port 80 or 443)
• A LinkAce API token (generated in your account settings under API Token)
• A free Vigilmon account

Step 1: Monitor the LinkAce Web Application

The LinkAce login page or dashboard is your first health signal. A 200 response confirms nginx (or Apache) is serving traffic and the Laravel application has booted successfully.

1. Log in to vigilmon.online and click Add Monitor.
2. Set Type to HTTP / HTTPS.
3. Enter your LinkAce URL: https://links.yourdomain.com/
4. Set Check interval to 1 minute.
5. Set Expected HTTP status to 200.
6. Under Keyword check, enter LinkAce to confirm the response body is your application, not a default nginx page or a maintenance screen.
7. Click Save.

If LinkAce returns a 500 error (common when the .env APP_KEY is missing, the database is unreachable, or storage permissions are wrong), Vigilmon alerts immediately.

Step 2: Monitor the LinkAce REST API

LinkAce provides a REST API at /api/v1/. The links endpoint returns paginated bookmark data — validating the API layer, the authentication system, and the database read path in a single call:

GET https://links.yourdomain.com/api/v1/links
Authorization: Bearer YOUR_API_TOKEN

Expected response:

{
  "data": [...],
  "links": {...},
  "meta": {
    "current_page": 1,
    "total": 1234
  }
}

Add this as a monitor in Vigilmon:

1. Click Add Monitor → HTTP / HTTPS.
2. URL: https://links.yourdomain.com/api/v1/links
3. Expected status: 200.
4. Request headers: add Authorization: Bearer YOUR_API_TOKEN.
5. Keyword check: current_page — confirms the JSON pagination structure is present.
6. Check interval: 2 minutes.
7. Click Save.

An invalid or expired API token returns a 401 response; a database failure returns a 500 — both are caught by the status code check.

Step 3: Monitor Built-In Link Checker Health

LinkAce's built-in link checker periodically probes every saved bookmark for dead links (404, connection timeout, domain expired). The count of failed links is an application-level health metric:

• A gradually increasing count over weeks is expected — some bookmarks will naturally go dead.
• A sudden spike means either the link checker ran and the internet is down (false positive), or the link checker cron stopped and accumulated failures are appearing after finally running.
• A count that never changes means the scheduler has stopped and the link checker is no longer running.

Monitor this via the API:

GET https://links.yourdomain.com/api/v1/links?check_failed=1
Authorization: Bearer YOUR_API_TOKEN

In Vigilmon:

1. Click Add Monitor → HTTP / HTTPS.
2. URL: https://links.yourdomain.com/api/v1/links?check_failed=1
3. Expected status: 200.
4. Request headers: Authorization: Bearer YOUR_API_TOKEN.
5. Keyword check: meta — confirms the response is valid JSON with pagination data.
6. Check interval: 30 minutes (link checker runs infrequently; no need to poll every minute).
7. Click Save.

This confirms the link checker API endpoint is functional. Track the meta.total value over time in the Vigilmon response history to notice unexpected spikes.

Step 4: Heartbeat Monitoring for the Laravel Scheduler

LinkAce relies on the Laravel scheduler (php artisan schedule:run called every minute via cron) for:

• Automatic dead link checking
• Metadata refresh for saved links
• Wayback Machine submission queue

If the cron job stops, these background tasks silently halt. Use a Vigilmon heartbeat to detect a stopped scheduler.

The scheduler's most visible effect is the updated_at timestamp on links. A recently updated link means the scheduler ran recently. Monitor this:

1. In Vigilmon, click Add Monitor → Cron Heartbeat.
2. Set Expected ping interval to 60 minutes.
3. Copy the heartbeat URL (e.g. https://vigilmon.online/heartbeat/scheduler-abc123).
4. On your server, create a health check script:

#!/bin/bash
# Get the most recently updated link
RESPONSE=$(curl -sf \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  "https://links.yourdomain.com/api/v1/links?orderby=updated_at&orderdir=desc&per_page=1")

if echo "$RESPONSE" | grep -q '"updated_at"'; then
  curl -s https://vigilmon.online/heartbeat/scheduler-abc123
fi

Add this to cron on the LinkAce server:

*/60 * * * * /opt/linkace-healthcheck.sh

This confirms the API is responding and bookmark data is being updated. For tighter scheduler verification, check whether the Laravel scheduler cron entry is present:

# Check if the Laravel scheduler cron job exists
crontab -l | grep "schedule:run"
# Should output: * * * * * cd /var/www/linkace && php artisan schedule:run >> /dev/null 2>&1

If missing, add it:

crontab -e
# Add: * * * * * cd /var/www/linkace && php artisan schedule:run >> /dev/null 2>&1

For Docker-based deployments, verify the scheduler is running inside the container:

docker exec linkace php artisan schedule:run

Step 5: SSL Certificate Alerts for Your LinkAce Domain

Your personal knowledge archive should be accessible over HTTPS. If the certificate expires, your bookmark collection becomes inaccessible (modern browsers hard-block expired certificates).

Enable SSL monitoring:

1. Open the HTTP / HTTPS monitor created in Step 1.
2. Enable Monitor SSL certificate.
3. Set Alert when certificate expires in less than 21 days.
4. Click Save.

Verify Certbot renewal:

# Check current certificate expiry
certbot certificates

# Test renewal without applying changes
certbot renew --dry-run

# Check the renewal timer
systemctl status certbot.timer

Step 6: Configure Alert Channels and Thresholds

1. Go to Alert Channels in Vigilmon and add email, Slack, or a webhook.
2. Set thresholds:
   • Web application (/): 2 consecutive failures — Laravel occasionally takes an extra second to respond under load.
   • API links (/api/v1/links): 1 failure — API unavailability means your entire bookmark archive is inaccessible.
   • Link checker (?check_failed=1): 2 failures — the link checker endpoint may be slow when results are large.
   • Scheduler heartbeat: treated as missing after 65 minutes — the 5-minute buffer accounts for cron timing jitter.

Summary

| Monitor | Target | What It Catches | |---|---|---| | Web application | / keyword LinkAce | nginx down, Laravel boot failure | | API links | /api/v1/links | API broken, database read failure | | Link checker | /api/v1/links?check_failed=1 | Link checker endpoint failure | | Scheduler heartbeat | Most recently updated link | Laravel scheduler stopped | | SSL certificate | Your LinkAce domain | Certificate expiry, broken HTTPS |

LinkAce turns your saved links into a permanent, searchable personal archive — but only if the service stays running and the scheduler keeps checking for dead links. With Vigilmon monitoring the web UI, API, link checker health, Laravel scheduler, and SSL certificate, you get complete observability across your knowledge management infrastructure.