PHP Monitoring Guide: Laravel, Metrics, Errors & APM Tools (2026)

Why PHP Monitoring Is Different

PHP applications have unique monitoring challenges compared to languages like Go or Java. The shared-nothing architecture means PHP has no persistent memory between requests — every request spins up a fresh process. There is no long-lived application state to watch. Instead, you need to monitor:

• PHP-FPM pool metrics — active processes, idle processes, max children reached
• OPcache hit rate — bytecode caching efficiency (should be >99%)
• Request-level metrics — latency per route, error rate, throughput
• External dependencies — MySQL slow queries, Redis latency, API call durations
• Queue health — Laravel Horizon or Beanstalkd queue depth and failure rate

The good news: because PHP is stateless, individual request failures don't cascade. The bad news: detecting slow memory leaks, OPcache thrashing, or FPM pool exhaustion requires explicit instrumentation.

Layer 1: Uptime & HTTP Monitoring

Start with basic external monitoring before building internal metrics. An external uptime monitor tells you when your PHP app is unreachable from users' perspectives — independent of what your internal metrics say.

Health Check Endpoint

Add a /health endpoint that checks critical dependencies:

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

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

    // Redis check
    try {
        Cache::store('redis')->get('health_check');
        $checks['redis'] = 'ok';
    } catch (\Exception $e) {
        $checks['redis'] = 'error';
    }

    // Queue check (optional)
    $checks['queue'] = Queue::size() < 1000 ? 'ok' : 'degraded';

    $status = in_array('error', $checks) ? 503 : 200;

    return response()->json([
        'status' => $status === 200 ? 'ok' : 'degraded',
        'checks' => $checks,
        'timestamp' => now()->toIso8601String(),
    ], $status);
});

Point your uptime monitor at this endpoint. Configure alerts for any non-200 response or response time >500ms.

Layer 2: PHP-FPM & Server Metrics

PHP-FPM has a built-in status page that exposes pool metrics. Enable it in your FPM pool config:

; /etc/php/8.3/fpm/pool.d/www.conf
pm.status_path = /fpm-status
ping.path = /fpm-ping

; Pool sizing — tune based on your server's RAM
pm = dynamic
pm.max_children = 50
pm.start_servers = 10
pm.min_spare_servers = 5
pm.max_spare_servers = 15
pm.max_requests = 500  ; Restart workers after N requests to prevent memory leaks

Key PHP-FPM metrics to watch at nginx_host/fpm-status:

OPcache Monitoring

// Expose OPcache stats as JSON endpoint (protect with auth middleware!)
Route::get('/metrics/opcache', function () {
    $status = opcache_get_status(false);
    return response()->json([
        'hit_rate'     => $status['opcache_statistics']['opcache_hit_rate'],
        'memory_usage' => $status['memory_usage']['used_memory'],
        'cached_files' => $status['opcache_statistics']['num_cached_files'],
        'restarts'     => $status['opcache_statistics']['oom_restarts']
                        + $status['opcache_statistics']['hash_restarts'],
    ]);
})->middleware('auth:sanctum');

OPcache hit rate below 95% indicates memory pressure or too many unique file paths. OPcache restarts (oom_restarts > 0) mean you need to increase opcache.memory_consumption.

Layer 3: Application Metrics with Prometheus

For per-route latency histograms and custom business metrics, use Prometheus instrumentation.

Install Prometheus Client for PHP

composer require promphp/prometheus_client_php

Laravel-Specific: spatie/laravel-prometheus

For Laravel apps, the spatie/laravel-prometheus package is the easiest path:

composer require spatie/laravel-prometheus

# Publish config
php artisan vendor:publish --provider="Spatie\Prometheus\PrometheusServiceProvider"

# This auto-registers /prometheus endpoint
# Add custom gauges in AppServiceProvider:
Prometheus::addGauge('queue_size')
    ->helpText('Current queue depth')
    ->value(fn () => Queue::size());

Prometheus::addGauge('active_users_24h')
    ->helpText('Users active in last 24 hours')
    ->value(fn () => User::where('last_seen_at', '>', now()->subDay())->count());

Middleware for Request Metrics

// app/Http/Middleware/PrometheusMiddleware.php
class PrometheusMiddleware
{
    public function handle(Request $request, Closure $next): Response
    {
        $start = microtime(true);
        $response = $next($request);
        $duration = microtime(true) - $start;

        $route = $request->route()?->getName() ?? 'unknown';
        $status = $response->getStatusCode();
        $method = $request->method();

        // Record request count
        Prometheus::getOrRegisterCounter(
            'http_requests_total',
            'Total HTTP requests',
            ['route', 'method', 'status']
        )->inc([$route, $method, (string) $status]);

        // Record duration histogram
        Prometheus::getOrRegisterHistogram(
            'http_request_duration_seconds',
            'HTTP request duration',
            ['route', 'method'],
            [0.01, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0]
        )->observe($duration, [$route, $method]);

        return $response;
    }
}

Layer 4: Error Tracking

Sentry for PHP/Laravel

Sentry is the standard choice for PHP error tracking. Install and configure in minutes:

composer require sentry/sentry-laravel

# .env
SENTRY_LARAVEL_DSN=https://your-key@sentry.io/your-project

# config/sentry.php — set error sample rates
return [
    'dsn' => env('SENTRY_LARAVEL_DSN'),
    'traces_sample_rate' => 0.1,  // 10% of requests for performance
    'profiles_sample_rate' => 0.1,
];

# bootstrap/app.php (Laravel 11+)
->withExceptions(function (Exceptions $exceptions) {
    $exceptions->report(function (Throwable $e) {
        if (app()->bound('sentry')) {
            \Sentry\captureException($e);
        }
    });
})

Laravel Flare (Laravel-Native Alternative)

Flare integrates deeply with Laravel's Ignition error page for beautiful production error reports:

composer require spatie/laravel-flare

# .env
FLARE_KEY=your-flare-key

# Flare auto-captures: Exceptions, SQL queries on error,
# logs, jobs, and full request context
# No additional configuration required in most Laravel apps

Layer 5: Laravel-Specific Tools

Laravel Telescope (Development & Staging)

Telescope provides an elegant dashboard for debugging in non-production environments:

composer require laravel/telescope --dev
php artisan telescope:install
php artisan migrate

# app/Providers/TelescopeServiceProvider.php
Telescope::night();  // Dark mode

# Record only slow queries in production (if you must enable it)
Telescope::filter(function (IncomingEntry $entry) {
    if ($entry->type === EntryType::QUERY) {
        return $entry->content['slow'];  // Only slow queries
    }
    return $this->app->isLocal();
});

Laravel Pulse (Production Monitoring)

Laravel Pulse is the production-ready alternative to Telescope with a much lower overhead:

composer require laravel/pulse
php artisan vendor:publish --provider="Laravel\Pulse\PulseServiceProvider"
php artisan migrate

# routes/web.php — protect the dashboard
Route::middleware(['auth', 'can:viewPulse'])->group(function () {
    Route::get('/pulse', \Laravel\Pulse\Http\Controllers\DashboardController::class);
});

# Pulse tracks: Requests, Slow Requests, Slow DB Queries,
# Queue stats, Cache usage, Exceptions, Server metrics

Laravel Horizon (Queue Monitoring)

composer require laravel/horizon
php artisan horizon:install
php artisan migrate

# Schedule snapshot for historical metrics
// app/Console/Kernel.php (Laravel 10) or routes/console.php (Laravel 11)
Schedule::command('horizon:snapshot')->everyFiveMinutes();

# Key Horizon metrics to alert on:
# - Failed jobs > 0 in last hour → page
# - Queue wait time > 30s → warning
# - Throughput dropping > 50% → warning

Layer 6: Database Query Monitoring

Slow database queries are the #1 source of PHP application performance issues. Laravel makes it easy to detect them:

// AppServiceProvider.php boot() method
use Illuminate\Database\Events\QueryExecuted;
use Illuminate\Support\Facades\DB;

// Log slow queries
DB::listen(function (QueryExecuted $query) {
    if ($query->time > 1000) {  // > 1 second
        Log::warning('Slow query detected', [
            'sql'      => $query->sql,
            'bindings' => $query->bindings,
            'time_ms'  => $query->time,
            'url'      => request()->fullUrl(),
        ]);

        // Optionally send to Sentry
        \Sentry\addBreadcrumb(
            category: 'db.query',
            message: 'Slow query: ' . $query->time . 'ms',
            level: 'warning',
        );
    }
});

// Enable query count in staging to catch N+1 problems
if (!app()->isProduction()) {
    DB::enableQueryLog();

    app()->terminating(function () {
        $queryCount = count(DB::getQueryLog());
        if ($queryCount > 50) {
            Log::warning("N+1 suspected: {$queryCount} queries on " . request()->path());
        }
    });
}

PHP APM Tools Comparison 2026

Recommendation: For most Laravel apps, start with Scout APM (free tier, Laravel package) for application-level traces and Sentry for error tracking. Add Blackfire.io if you need deep profiling for performance optimization. Graduate to Datadog when you need enterprise-grade observability across multiple services.

OpenTelemetry for PHP (2026)

OpenTelemetry's PHP SDK has matured significantly and is now a viable option for teams wanting vendor-neutral tracing:

composer require open-telemetry/sdk \
  open-telemetry/exporter-otlp \
  open-telemetry/opentelemetry-auto-laravel

# config/otel.php (or .env)
OTEL_PHP_AUTOLOAD_ENABLED=true
OTEL_SERVICE_NAME=my-laravel-app
OTEL_EXPORTER_OTLP_ENDPOINT=http://otel-collector:4317
OTEL_TRACES_SAMPLER=parentbased_traceidratio
OTEL_TRACES_SAMPLER_ARG=0.1  # 10% sampling

# The laravel instrumentation auto-instruments:
# - HTTP requests
# - Database queries (PDO)
# - Cache operations
# - Queue jobs

Essential PHP Monitoring Alerts

Frequently Asked Questions

Related Guides