Laravel Pulse

Què és Laravel Pulse?#

Quan una aplicació Laravel arriba a producció, necessites visibilitat sobre què hi passa realment. No n'hi ha prou amb saber que "funciona": necessites saber quines consultes SQL triguen massa, quins endpoints són lents, si els servidors tenen prou memòria, si la cache està fent la seva feina o si les cues estan acumulant jobs. Sense aquesta informació, els problemes de rendiment passen desapercebuts fins que els usuaris es queixen, i llavors ja és tard.

Laravel Pulse és una eina de monitorització de rendiment dissenyada específicament per a entorns de producció. Proporciona un dashboard en temps real que mostra les mètriques més importants de la teva aplicació: ús dels servidors, consultes lentes, peticions lentes, excepcions, eficiència de la cache, estat de les cues i molt més. Tot això amb un impacte mínim sobre el rendiment de l'aplicació, gràcies a un sistema de recollida de dades optimitzat i configurable.

Pulse vs Telescope#

És important entendre la diferència entre Pulse i Telescope, perquè serveixen per a propòsits completament diferents. Telescope és una eina de depuració per a desenvolupament local: registra cada petició, cada consulta, cada event amb un nivell de detall enorme. Això és fantàstic per depurar, però seria un desastre en producció perquè el volum de dades colapsaria la base de dades i ralentiria l'aplicació.

Pulse, en canvi, està dissenyat per a producció des del principi. En lloc de registrar cada operació individual, recull mètriques agregades: no guarda cada consulta SQL, sinó les que superen un llindar de temps configurable. No registra cada petició HTTP, sinó les que són lentes. Això significa que l'impacte sobre el rendiment és mínim i el volum de dades emmagatzemades és manejable. A més, Pulse fa servir un sistema de mostreig configurable que permet controlar exactament quantes dades es recullen.

En resum: Telescope per a depurar en desenvolupament, Pulse per a monitoritzar en producció. Són complementaris, no alternatives.

Instal·lació i configuració inicial#

Per instal·lar Pulse, utilitza Composer i després publica els fitxers de configuració i executa les migracions:

composer require laravel/pulse

Un cop instal·lat el paquet, publica la configuració i executa les migracions per crear les taules necessàries:

php artisan vendor:publish --provider="Laravel\Pulse\PulseServiceProvider"
php artisan migrate

La migració crea dues taules principals: pulse_values per a valors puntuals (com l'estat actual dels servidors) i pulse_entries per a entrades temporals (com consultes lentes). Aquestes taules estan dissenyades per ser compactes i eficients, amb un sistema de poda automàtic que elimina les dades antigues.

Després de la instal·lació, el dashboard de Pulse està disponible a la ruta /pulse. Per defecte, aquesta ruta només és accessible en entorn local. Per a producció, hauràs de configurar l'autorització, com veurem més endavant.

El dashboard i les seves targetes#

El dashboard de Pulse està format per targetes (cards), cadascuna de les quals mostra un tipus de mètrica diferent. Per defecte, Pulse inclou un conjunt complet de targetes que cobreixen les àrees més importants de monitorització. Pots personalitzar quines targetes apareixen i en quin ordre editant la vista del dashboard.

Per publicar la vista del dashboard i poder-la personalitzar:

php artisan vendor:publish --tag=pulse-dashboard

Això crea el fitxer resources/views/vendor/pulse/dashboard.blade.php, on pots reordenar, eliminar o afegir targetes:

<x-pulse>
    <livewire:pulse.servers cols="full" />
 
    <livewire:pulse.usage cols="4" rows="2" />
    <livewire:pulse.queues cols="4" />
    <livewire:pulse.cache cols="4" />
 
    <livewire:pulse.slow-queries cols="8" />
    <livewire:pulse.exceptions cols="4" />
 
    <livewire:pulse.slow-requests cols="6" />
    <livewire:pulse.slow-jobs cols="6" />
 
    <livewire:pulse.slow-outgoing-requests cols="6" />
</x-pulse>

Cada targeta accepta propietats com cols (quantes columnes ocupa en el grid de 12 columnes) i rows (quantes files ocupa). Això et permet dissenyar un dashboard que s'adapti a les teves prioritats de monitorització.

Servidors (Servers)#

La targeta de servidors mostra l'estat en temps real de cada servidor on s'executa l'aplicació: ús de CPU, memòria RAM i espai de disc. Això és fonamental per detectar servidors sobrecarregats o que s'estan quedant sense espai.

Per recollir les mètriques dels servidors, necessites executar la comanda pulse:check com un procés continu a cada servidor. Normalment, es gestiona amb Supervisor:

php artisan pulse:check

# /etc/supervisor/conf.d/pulse.conf
[program:pulse-check]
process_name=%(program_name)s
command=php /var/www/app/artisan pulse:check
autostart=true
autorestart=true
user=www-data
redirect_stderr=true
stdout_logfile=/var/www/app/storage/logs/pulse-check.log

La targeta mostra un gràfic temporal per a cada servidor, cosa que permet detectar patrons: per exemple, si la CPU puja cada dia a les 3 de la matinada, probablement és una tasca programada que consumeix molts recursos.

Ús de l'aplicació (Application Usage)#

Aquesta targeta mostra tres mètriques d'ús: quins usuaris fan més peticions, quins despatxen més jobs i quins consultes lentes generen. Això és útil per identificar usuaris que fan un ús intensiu de l'aplicació o que tenen patrons d'ús problemàtics.

Per defecte, Pulse registra les 10 peticions més freqüents per minut i els usuaris que les fan. Pots configurar el nombre d'entrades i el període de temps al fitxer de configuració.

Consultes lentes (Slow Queries)#

Aquesta és probablement la targeta més útil per a l'optimització del rendiment. Mostra les consultes SQL que superen un llindar de temps configurable (per defecte, 1000 ms). Per a cada consulta, veuràs el text SQL, el temps d'execució i quantes vegades s'ha executat durant el període de mostreig.

Les consultes lentes són sovint la causa principal de problemes de rendiment en aplicacions Laravel. Un N+1 que passa desapercebut en desenvolupament (amb 10 registres) pot ser devastador en producció (amb 10.000 registres). Pulse t'ajuda a detectar aquests problemes abans que els usuaris els notin.

Jobs lents (Slow Jobs)#

Mostra els jobs de cua que triguen més del llindar configurat. Jobs que triguen massa poden bloquejar els workers i fer que la cua s'acumuli. Aquesta targeta t'ajuda a identificar quins jobs necessiten optimització o quins haurien de tenir el seu propi worker dedicat.

Peticions lentes (Slow Requests)#

Mostra les rutes HTTP que triguen més del llindar configurat a respondre. Per a cada ruta, veus el temps mitjà de resposta i el nombre de peticions. Això et permet prioritzar quines rutes necessiten optimització: una ruta que triga 3 segons i rep 1000 peticions al dia és molt més urgent que una que triga 5 segons però només rep 10 peticions al mes.

Excepcions recents (Recent Exceptions)#

Mostra les excepcions que s'han llançat recentment, agrupades per tipus i missatge. Per a cada excepció, veus quantes vegades s'ha produït i l'última vegada que ha passat. Això és essencial per detectar errors en producció ràpidament, especialment aquells que no causen una fallada visible per a l'usuari però que indiquen problemes subjacents.

Cache (Cache Hit/Miss Ratio)#

Mostra l'eficiència de la cache: quantes vegades s'ha trobat un valor a la cache (hit) vs quantes vegades no s'hi ha trobat (miss). Un ratio de hits baix indica que la cache no s'està aprofitant bé, ja sigui perquè els TTL són massa curts, perquè les claus no són les adequades o perquè la cache s'està invalidant massa sovint.

Un bon ratio de cache hauria de ser superior al 80%. Si el teu ratio està per sota del 50%, probablement estàs gastant recursos generant dades que podries estar servint des de la cache.

Peticions sortints lentes (Slow Outgoing Requests)#

Mostra les peticions HTTP que la teva aplicació fa a serveis externs (APIs de tercers, microserveis, webhooks) que triguen més del llindar configurat. Això és important perquè les peticions a serveis externs són sovint la causa de peticions HTTP lentes: si la teva aplicació crida una API que triga 2 segons a respondre, la teva petició HTTP trigarà com a mínim 2 segons.

Cues (Queues)#

Mostra l'estat de les cues: quants jobs estan esperant, quants s'estan processant i la velocitat de processament. Això et permet detectar quan una cua s'està acumulant (més jobs entren dels que surten) i actuar abans que el retard sigui massa gran.

Configuració en profunditat#

La configuració de Pulse es gestiona al fitxer config/pulse.php. Aquest fitxer controla tots els aspectes del sistema de monitorització: quins recorders estan actius, quins llindars s'apliquen, com s'emmagatzemen les dades i amb quina freqüència es poden.

Recorders#

Els recorders són els components que recullen les dades. Cada recorder s'encarrega d'un tipus de mètrica específic. Pots habilitar, deshabilitar i configurar cada recorder de manera independent:

// config/pulse.php
'recorders' => [
    // Consultes SQL que superen el llindar
    \Laravel\Pulse\Recorders\SlowQueries::class => [
        'enabled' => env('PULSE_SLOW_QUERIES_ENABLED', true),
        'sample_rate' => env('PULSE_SLOW_QUERIES_SAMPLE_RATE', 1),
        'threshold' => env('PULSE_SLOW_QUERIES_THRESHOLD', 1000), // ms
        'location' => true, // Registrar des d'on es fa la consulta
        'max_query_length' => 150, // Truncar consultes llargues
        'ignore' => [
            // Patrons de consultes a ignorar
            '/^select count/i',
        ],
    ],
 
    // Peticions HTTP lentes
    \Laravel\Pulse\Recorders\SlowRequests::class => [
        'enabled' => env('PULSE_SLOW_REQUESTS_ENABLED', true),
        'sample_rate' => env('PULSE_SLOW_REQUESTS_SAMPLE_RATE', 1),
        'threshold' => env('PULSE_SLOW_REQUESTS_THRESHOLD', 1000), // ms
        'ignore' => [
            // Rutes a ignorar
            '#^/pulse$#',
            '#^/telescope#',
        ],
    ],
 
    // Jobs de cua lents
    \Laravel\Pulse\Recorders\SlowJobs::class => [
        'enabled' => env('PULSE_SLOW_JOBS_ENABLED', true),
        'sample_rate' => env('PULSE_SLOW_JOBS_SAMPLE_RATE', 1),
        'threshold' => env('PULSE_SLOW_JOBS_THRESHOLD', 1000), // ms
    ],
 
    // Peticions HTTP sortints lentes
    \Laravel\Pulse\Recorders\SlowOutgoingRequests::class => [
        'enabled' => env('PULSE_SLOW_OUTGOING_REQUESTS_ENABLED', true),
        'sample_rate' => env('PULSE_SLOW_OUTGOING_REQUESTS_SAMPLE_RATE', 1),
        'threshold' => env('PULSE_SLOW_OUTGOING_REQUESTS_THRESHOLD', 1000), // ms
        'groups' => [
            // Agrupar URLs per patró
            '#^https://api\.stripe\.com/#' => 'Stripe API',
            '#^https://api\.github\.com/#' => 'GitHub API',
        ],
    ],
 
    // Excepcions
    \Laravel\Pulse\Recorders\Exceptions::class => [
        'enabled' => env('PULSE_EXCEPTIONS_ENABLED', true),
        'sample_rate' => env('PULSE_EXCEPTIONS_SAMPLE_RATE', 1),
        'location' => true,
        'ignore' => [
            // Classes d'excepcions a ignorar
        ],
    ],
 
    // Operacions de cache
    \Laravel\Pulse\Recorders\CacheInteractions::class => [
        'enabled' => env('PULSE_CACHE_INTERACTIONS_ENABLED', true),
        'sample_rate' => env('PULSE_CACHE_INTERACTIONS_SAMPLE_RATE', 1),
        'groups' => [
            // Agrupar claus de cache per patró
            '/^user_.*/' => 'user_*',
            '/^product_.*/' => 'product_*',
        ],
    ],
 
    // Ús de l'aplicació per usuari
    \Laravel\Pulse\Recorders\UserRequests::class => [
        'enabled' => env('PULSE_USER_REQUESTS_ENABLED', true),
        'sample_rate' => env('PULSE_USER_REQUESTS_SAMPLE_RATE', 1),
    ],
 
    // Estat dels servidors
    \Laravel\Pulse\Recorders\Servers::class => [
        'enabled' => env('PULSE_SERVERS_ENABLED', true),
        'directories' => [
            '/', // Disc a monitoritzar
        ],
    ],
 
    // Cues
    \Laravel\Pulse\Recorders\Queues::class => [
        'enabled' => env('PULSE_QUEUES_ENABLED', true),
        'sample_rate' => env('PULSE_QUEUES_SAMPLE_RATE', 1),
    ],
 
    // Peticions d'usuari
    \Laravel\Pulse\Recorders\UserJobs::class => [
        'enabled' => env('PULSE_USER_JOBS_ENABLED', true),
        'sample_rate' => env('PULSE_USER_JOBS_SAMPLE_RATE', 1),
    ],
],

Cada recorder té la seva pròpia configuració amb opcions específiques. L'opció enabled permet deshabilitar un recorder completament. L'opció threshold defineix el llindar de temps en mil·lisegons per considerar una operació com a "lenta". L'opció ignore permet excloure determinats patrons (consultes, rutes, excepcions) de la monitorització.

Taxa de mostreig (Sample Rate)#

La taxa de mostreig és una de les configuracions més importants de Pulse perquè afecta directament el rendiment i la precisió. Un sample_rate de 1 (100%) significa que es registra cada operació. Un sample_rate de 0.1 (10%) significa que només es registra una de cada deu operacions.

Per a aplicacions amb poc tràfic, un sample rate del 100% és perfectament acceptable. Per a aplicacions amb milers de peticions per segon, reduir el sample rate al 10% o fins i tot l'1% pot ser necessari per evitar que la recollida de mètriques afecti el rendiment:

// Per a aplicacions amb molt de tràfic
'recorders' => [
    \Laravel\Pulse\Recorders\SlowQueries::class => [
        'sample_rate' => 0.1, // 10% de les consultes
        'threshold' => 500,
    ],
    \Laravel\Pulse\Recorders\CacheInteractions::class => [
        'sample_rate' => 0.01, // 1% de les operacions de cache
    ],
    \Laravel\Pulse\Recorders\SlowRequests::class => [
        'sample_rate' => 1, // 100% de les peticions lentes (no en vols perdre cap)
    ],
],

Emmagatzematge i poda de dades#

Pulse emmagatzema les dades a la base de dades per defecte. Les taules creixen amb el temps, cosa que pot afectar el rendiment de les consultes del dashboard. Per evitar-ho, Pulse inclou un sistema de poda automàtic que elimina les dades antigues.

Configura la poda al fitxer de configuració:

// config/pulse.php
 
// Quants dies conservar les dades
'trim' => [
    'lottery' => [1, 1000], // Probabilitat de poda a cada petició
    'keep' => '7 days',     // Conservar les dades dels últims 7 dies
],

Per a una poda més fiable, programa la comanda de poda al scheduler:

// routes/console.php o app/Console/Kernel.php
Schedule::command('pulse:purge')->daily();

Si vols utilitzar una connexió de base de dades diferent per a les taules de Pulse (recomanat per a aplicacions amb molt de tràfic), pots configurar-ho al fitxer de configuració:

// config/pulse.php
'storage' => [
    'driver' => 'database',
    'connection' => 'pulse', // Connexió separada
    'chunk' => 1000,
],

I defineix la connexió al fitxer config/database.php:

// config/database.php
'connections' => [
    'pulse' => [
        'driver' => 'mysql',
        'host' => env('PULSE_DB_HOST', '127.0.0.1'),
        'database' => env('PULSE_DB_DATABASE', 'pulse'),
        'username' => env('PULSE_DB_USERNAME', 'pulse'),
        'password' => env('PULSE_DB_PASSWORD', ''),
    ],
],

Driver d'ingestió (Ingest Driver)#

Per defecte, Pulse escriu les mètriques directament a la base de dades dins de la mateixa petició HTTP. Per a aplicacions amb molt de tràfic, això pot afegir latència a les peticions. El driver d'ingestió Redis soluciona aquest problema emmagatzemant les mètriques temporalment a Redis i processant-les en segon pla:

// config/pulse.php
'ingest' => [
    'driver' => env('PULSE_INGEST_DRIVER', 'storage'),
    // Canviar a 'redis' per a aplicacions amb molt de tràfic
 
    'redis' => [
        'connection' => env('PULSE_REDIS_CONNECTION'),
        'chunk' => 1000,
    ],
],

Quan fas servir el driver Redis, les mètriques s'encuen a Redis durant la petició HTTP (operació molt ràpida) i després es processen en lot cap a la base de dades. Per processar les mètriques pendents, necessites executar la comanda pulse:work:

php artisan pulse:work

Igual que amb pulse:check, hauràs de gestionar aquest procés amb Supervisor per assegurar-te que funciona contínuament:

# /etc/supervisor/conf.d/pulse-work.conf
[program:pulse-work]
process_name=%(program_name)s
command=php /var/www/app/artisan pulse:work
autostart=true
autorestart=true
user=www-data
redirect_stderr=true
stdout_logfile=/var/www/app/storage/logs/pulse-work.log

Targetes personalitzades#

Una de les característiques més potents de Pulse és la possibilitat de crear targetes personalitzades amb Livewire. Això et permet monitoritzar mètriques específiques del teu negoci que les targetes predefinides no cobreixen.

Crear un recorder personalitzat#

Primer, crea un recorder que reculli les dades que t'interessen. Per exemple, un recorder que registra els pagaments processats:

namespace App\Pulse\Recorders;
 
use App\Events\PaymentProcessed;
use Illuminate\Config\Repository;
use Laravel\Pulse\Pulse;
 
class PaymentRecorder
{
    public string $listen = PaymentProcessed::class;
 
    public function __construct(
        protected Pulse $pulse,
        protected Repository $config,
    ) {}
 
    public function record(PaymentProcessed $event): void
    {
        $this->pulse->record(
            type: 'payment',
            key: $event->payment->gateway,
            value: $event->payment->amount,
        )->count()->sum();
    }
}

Registra el recorder a la configuració de Pulse:

// config/pulse.php
'recorders' => [
    // ... altres recorders
    \App\Pulse\Recorders\PaymentRecorder::class => [
        'enabled' => true,
    ],
],

Crear la targeta amb Livewire#

Ara crea el component Livewire que mostrarà les dades recollides pel recorder:

namespace App\Livewire\Pulse;
 
use Illuminate\Support\Facades\View;
use Laravel\Pulse\Livewire\Card;
use Laravel\Pulse\Facades\Pulse;
use Livewire\Attributes\Lazy;
 
#[Lazy]
class PaymentsCard extends Card
{
    public function render()
    {
        [$payments, $time, $runAt] = $this->remember(function () {
            return Pulse::aggregate(
                type: 'payment',
                aggregate: ['count', 'sum'],
                limit: 10,
            );
        });
 
        return View::make('livewire.pulse.payments-card', [
            'payments' => $payments,
            'time' => $time,
            'runAt' => $runAt,
        ]);
    }
}

I la vista Blade corresponent:

{{-- resources/views/livewire/pulse/payments-card.blade.php --}}
<x-pulse::card :cols="$cols" :rows="$rows" :class="$class" wire:poll.5s="">
    <x-pulse::card-header name="Pagaments" title="Pagaments per gateway">
        <x-slot:icon>
            <x-pulse::icons.credit-card />
        </x-slot:icon>
    </x-pulse::card-header>
 
    <x-pulse::scroll :expand="$expand">
        <x-pulse::table>
            <colgroup>
                <col width="100%" />
                <col width="0%" />
                <col width="0%" />
            </colgroup>
            <x-pulse::thead>
                <tr>
                    <x-pulse::th>Gateway</x-pulse::th>
                    <x-pulse::th class="text-right">Transaccions</x-pulse::th>
                    <x-pulse::th class="text-right">Total</x-pulse::th>
                </tr>
            </x-pulse::thead>
            <tbody>
                @foreach ($payments as $payment)
                    <tr wire:key="{{ $payment->key }}">
                        <x-pulse::td>{{ $payment->key }}</x-pulse::td>
                        <x-pulse::td class="text-right">
                            {{ number_format($payment->count) }}
                        </x-pulse::td>
                        <x-pulse::td class="text-right">
                            {{ number_format($payment->sum / 100, 2) }} €
                        </x-pulse::td>
                    </tr>
                @endforeach
            </tbody>
        </x-pulse::table>
    </x-pulse::scroll>
</x-pulse::card>

Finalment, afegeix la targeta al dashboard:

{{-- resources/views/vendor/pulse/dashboard.blade.php --}}
<x-pulse>
    <livewire:pulse.servers cols="full" />
    <livewire:pulse.payments-card cols="4" />
    {{-- ... altres targetes --}}
</x-pulse>

Les targetes personalitzades es carreguen de manera lazy per defecte (gràcies a l'atribut #[Lazy]), cosa que significa que no bloquegen la càrrega inicial del dashboard. La directiva wire:poll.5s fa que la targeta s'actualitzi cada 5 segons sense recarregar la pàgina.

Resolució d'usuaris#

Per defecte, Pulse identifica els usuaris pel seu ID i mostra el nom i l'email obtinguts del model User. Si necessites personalitzar com es resolen els usuaris (per exemple, si tens múltiples models d'usuari o si vols mostrar informació addicional), pots configurar el resolver:

// app/Providers/AppServiceProvider.php
use Laravel\Pulse\Facades\Pulse;
 
public function boot(): void
{
    Pulse::user(fn ($user) => [
        'name' => $user->full_name,
        'extra' => $user->role->name,
        'avatar' => $user->avatar_url,
    ]);
}

El resolver rep una instància del model d'usuari i retorna un array amb les claus name, extra i avatar. La clau extra apareix com a text secundari sota el nom de l'usuari al dashboard, i avatar mostra una imatge al costat del nom.

Si fas servir un resolver personalitzat i tens molts usuaris, considera fer servir cache per evitar consultes addicionals a la base de dades:

Pulse::user(fn ($user) => [
    'name' => $user->full_name,
    'extra' => $user->email,
    'avatar' => 'https://www.gravatar.com/avatar/' . md5($user->email),
]);

Seguretat: autorització del dashboard#

En producció, el dashboard de Pulse ha d'estar protegit perquè mostra informació sensible sobre la infraestructura i el rendiment de l'aplicació. Per defecte, Pulse només és accessible en entorn local (APP_ENV=local). Per a producció, has de definir una gate d'autorització:

// app/Providers/AppServiceProvider.php
use Illuminate\Support\Facades\Gate;
use Laravel\Pulse\Facades\Pulse;
 
public function boot(): void
{
    Gate::define('viewPulse', function ($user) {
        return in_array($user->email, [
            'admin@example.com',
            'devops@example.com',
        ]);
    });
}

Amb aquesta configuració, només els usuaris amb els correus especificats podran accedir al dashboard de Pulse. Pots fer servir qualsevol lògica que necessitis dins de la gate: comprovar rols, permisos, equips, etc.

Si vols canviar la ruta del dashboard (per defecte /pulse), pots fer-ho al fitxer de configuració:

// config/pulse.php
'path' => 'admin/pulse',
 
'middleware' => [
    'web',
    'auth',
    Authorize::class,
],

Impacte sobre el rendiment#

Un dels principis de disseny de Pulse és que l'impacte sobre el rendiment ha de ser mínim. Pulse aconsegueix això mitjançant diverses estratègies:

El mostreig configurable permet decidir quines dades es recullen i amb quina freqüència. No cal registrar el 100% de les operacions per obtenir mètriques útils. Amb un sample rate del 10%, les mètriques segueixen sent estadísticament representatives, però l'impacte sobre el rendiment es redueix dràsticament.

El driver d'ingestió Redis permet desacoblar la recollida de dades de l'escriptura a la base de dades. Les dades es recullen durant la petició HTTP (escriptura ràpida a Redis) i es processen en segon pla (escriptura a la base de dades).

La poda automàtica manté les taules de la base de dades compactes, cosa que garanteix que les consultes del dashboard siguin ràpides independentment de quant temps porti Pulse funcionant.

Les targetes del dashboard es carreguen de manera lazy i s'actualitzen amb polling, cosa que significa que la càrrega del dashboard no afecta el rendiment de l'aplicació principal.

Pulse vs eines APM de tercers#

Pulse no pretén substituir eines APM (Application Performance Monitoring) professionals com New Relic, Datadog, Sentry o AppSignal. Aquestes eines ofereixen funcionalitats que Pulse no té: tracing distribuït, alertes avançades, correlació d'events, dashboards complexos, integracions amb centenars de serveis i retenció de dades a llarg termini.

On Pulse destaca és en la seva integració nativa amb Laravel. Pulse entén els conceptes de Laravel (Eloquent, cues, cache, routes) d'una manera que cap eina genèrica pot igualar. A més, Pulse és gratuït i autohospedable, cosa que significa que les dades mai surten dels teus servidors.

La millor estratègia és combinar Pulse amb una eina APM professional. Pulse per a la monitorització diària del rendiment de l'aplicació (consultes lentes, cache, cues), i una eina APM per a la visió global de la infraestructura, alertes i anàlisi en profunditat d'incidències. Pulse pot ser el primer lloc on mires quan alguna cosa va malament, perquè mostra exactament les mètriques que més importen per a una aplicació Laravel. Si necessites investigar més a fons, les eines APM ofereixen les eines d'anàlisi avançada necessàries.

| Característica | Pulse | Eines APM (New Relic, Datadog) | |---|---|---| | Cost | Gratuït | De pagament (sovint car) | | Integració amb Laravel | Nativa i profunda | Genèrica | | Dades | Al teu servidor | Al núvol del proveïdor | | Instal·lació | Composer + migrate | Agent de sistema + SDK | | Tracing distribuït | No | Sí | | Alertes avançades | No | Sí | | Targetes personalitzades | Sí (Livewire) | Sí (dashboards) | | Impacte en rendiment | Mínim i configurable | Variable | | Retenció de dades | Configurable (dies) | Mesos o anys | | Entorn recomanat | Producció Laravel | Qualsevol stack |