Monitoring Solidtime with Vigilmon

Solidtime is a sleek, modern self-hosted time tracking application built on Laravel and Vue.js. Teams rely on it to log billable hours, track project budgets, and generate accurate invoices. When Solidtime goes down mid-workday, entries get lost, timers stop, and reporting becomes unreliable. Vigilmon gives you continuous visibility across every layer of the Solidtime stack — from the web application to the export job service — so you catch problems before your team notices them.

What You'll Set Up

• HTTP uptime monitor for the Solidtime web application (port 80)
• Time entry API health check
• Project and task management API monitor
• Timer webhook delivery endpoint monitoring
• Export and reporting job heartbeat
• Database connectivity health probe
• User session and authentication endpoint monitoring

Prerequisites

• Solidtime installed and running (typically on port 80 or behind a reverse proxy)
• A free Vigilmon account

Step 1: Monitor the Solidtime Web Application

The Solidtime web UI is where your team logs time, manages projects, and views reports. Downtime here means no time tracking for everyone using the app.

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

Step 2: Add a Health Endpoint

Solidtime's Laravel backend supports custom health routes. Add one to expose the application's internal state:

// routes/api.php
Route::get('/health', function () {
    $checks = [];

    // Database
    try {
        DB::connection()->getPdo();
        $checks['database'] = 'ok';
    } catch (\Exception $e) {
        $checks['database'] = 'error';
    }

    // Cache / Redis
    try {
        Cache::put('solidtime_health', 1, 5);
        $checks['cache'] = Cache::get('solidtime_health') === 1 ? 'ok' : 'error';
    } catch (\Exception $e) {
        $checks['cache'] = 'error';
    }

    // Queue connection
    try {
        Queue::size();
        $checks['queue'] = 'ok';
    } catch (\Exception $e) {
        $checks['queue'] = 'error';
    }

    $allOk = !in_array('error', $checks);
    return response()->json([
        'status' => $allOk ? 'ok' : 'degraded',
        'checks' => $checks,
    ], $allOk ? 200 : 503);
})->middleware('throttle:60,1');

Add a Vigilmon monitor for https://solidtime.yourdomain.com/api/health with a 1 minute check interval.

Step 3: Monitor the Time Entry API

Solidtime's time entry API is the core of the application — it handles every clock-in, clock-out, and manual entry. API failures silently prevent time from being recorded even if the web UI appears functional.

The time entry endpoint follows a RESTful pattern:

GET /api/v1/me/time-entries
POST /api/v1/me/time-entries

Add a monitor for a safe read-only API probe:

1. URL: https://solidtime.yourdomain.com/api/v1/me/time-entries
2. Type: HTTP / HTTPS
3. Expected HTTP status: 401 (Unauthorized — proves the route exists and the API is responding; actual auth is handled by the app)
4. Check interval: 1 minute

A 404 means the API router is broken. A 500 means an exception in the time entry handler. Either triggers an alert.

Step 4: Monitor the Project and Task Management API

Projects and tasks are the backbone of Solidtime's organizational structure. If these API routes break, users can't create projects, assign team members, or categorize time entries.

Add a monitor for the projects endpoint:

1. URL: https://solidtime.yourdomain.com/api/v1/organizations
2. Type: HTTP / HTTPS
3. Expected HTTP status: 401
4. Check interval: 2 minutes

Step 5: Monitor Timer Webhook Delivery

If you've configured Solidtime to deliver timer events to external services (project management tools, billing systems), those webhook endpoints need to stay reachable. Add a monitor for each configured webhook URL:

1. URL: https://solidtime.yourdomain.com/api/webhooks/timers
2. Type: HTTP / HTTPS
3. Expected HTTP status: 405 (for GET against a POST-only endpoint)
4. Check interval: 1 minute

If Solidtime delivers to an external webhook receiver, monitor that URL too — broken external receivers silently drop timer events.

Step 6: Set Up a Heartbeat for Export and Reporting Jobs

Solidtime's scheduled export jobs generate reports and push data to connected integrations. These run via Laravel's scheduler and queue workers. A dead scheduler means reports don't generate and integrations drift out of sync.

Set up a Vigilmon heartbeat:

1. Click Add Monitor → set Type to Cron Job / Heartbeat.
2. Name it Solidtime Scheduler.
3. Set Expected ping interval to 10 minutes.
4. Copy the heartbeat URL.

Configure the ping in app/Console/Kernel.php:

protected function schedule(Schedule $schedule)
{
    // Existing Solidtime scheduled tasks
    $schedule->command('solidtime:generate-reports')->hourly();

    // Heartbeat
    $schedule->call(function () {
        Http::get(env('VIGILMON_HEARTBEAT_URL'));
    })->everyFiveMinutes();
}

Also monitor your queue worker process — if it dies, time entry webhooks and export jobs queue up indefinitely:

# In your supervisord config
[program:solidtime-worker]
command=php /var/www/solidtime/artisan queue:work --tries=3 --timeout=60

Step 7: Monitor Authentication Endpoints

Solidtime uses session-based authentication (or API tokens for integrations). If the login endpoint fails, no one can access the application even if the web server is running.

Add a monitor:

1. URL: https://solidtime.yourdomain.com/login
2. Type: HTTP / HTTPS
3. Expected HTTP status: 200
4. Check interval: 2 minutes

For API token authentication, monitor the token validation route:

https://solidtime.yourdomain.com/api/v1/auth/user

Expect a 401 response — this proves the auth layer is responding without requiring valid credentials.

Step 8: Configure Alerting

Set up alert channels in Vigilmon to notify your team when something fails:

1. Go to Alert Channels → add email, Slack, or a webhook to your team chat.
2. For the web application monitor: alert on 1 failure — all time tracking stops immediately.
3. For the time entry API: alert on 1 failure — every logged hour is at risk.
4. For project API and auth monitors: use 2 consecutive failures to filter transient hiccups.
5. For the scheduler heartbeat: alert on first missed ping — silent failures are the worst kind.

Monitoring Checklist

| Service | Monitor Type | Check Interval | Alert Threshold | |---|---|---|---| | Solidtime web application | HTTP | 1 min | 1 failure | | Application health (DB + cache + queue) | HTTP | 1 min | 1 failure | | Time entry API | HTTP | 1 min | 1 failure | | Project & task management API | HTTP | 2 min | 2 failures | | Timer webhook endpoint | HTTP | 1 min | 1 failure | | Authentication / login endpoint | HTTP | 2 min | 2 failures | | Laravel scheduler heartbeat | Heartbeat | 5 min | 1 missed ping |

Conclusion

Solidtime tracks the hours your business bills for — it deserves the same reliability attention you give client-facing services. With Vigilmon covering the web UI, every API layer, the scheduler heartbeat, and authentication, you'll catch failures before they turn into missing time entries or broken integrations. Spend 20 minutes wiring up these monitors, and you'll never be caught off guard by a silent Solidtime outage again.

Start monitoring Solidtime with Vigilmon →