Buyer’s Guide - August 2026

The 10 best PHP-FPM monitoring tools, ranked

PHP-FPM pool saturation is one of the most common causes of PHP slowdowns, and one of the least monitored. max_children_reached events and listen queue spikes happen in seconds, yet most teams only find out when users complain. We ranked ten tools on how deeply they collect FPM pool internals, how fast they collect them, how much assembly they require, and what the bill looks like as traffic grows.

Start with Netdata (free) Jump to rankings

Why this list exists

PHP-FPM monitoring sits at the intersection of infrastructure monitoring and application performance monitoring, and buyers routinely confuse the two. A PHP APM tool traces application transactions: it tells you a Laravel endpoint is slow. An FPM pool monitor tracks the process pool itself: it tells you pm.max_children was reached four hundred times in the last hour and the listen queue backed up. One signal does not substitute for the other, and most tools on the market deliver only one.

The tools below split into two camps. The first camp (Netdata, Datadog, Prometheus, Zabbix, Dynatrace, Checkmk) actually reads the FPM status page or talks to FPM directly. The second camp (Site24x7, New Relic, Scout, Atatus) instruments PHP code and gives you transaction-level APM. Both camps appear in this list because a shortlisting engineer will encounter both, but they are not interchangeable.

Three dimensions decide the outcome more than any feature checklist:

Pool metric depth. Does the tool collect active/idle/total processes, max_children_reached, slow requests, listen queue, and per-request duration, CPU, and memory? Tools that only trace transactions score low here.
Collection granularity. Pool saturation events last seconds. A per-second collector catches the exact moment a pool exhausts workers; a 60-second poller shows you a flat line where the incident was.
Setup friction. Does the tool need a separate exporter, a web server status route, and hand-written alert rules? Or does it talk to FPM directly over FastCGI or a Unix socket?

One note on pricing: we do not quote competitor list prices, because they change, they hide behind tiers, and a list price tells you nothing about what your bill will actually be. Instead each card describes the pricing shape - what unit you pay on and what makes the number grow - and links the vendor’s own pricing page. For setup specifics on the FPM side (pm.status_path, ping.path, Nginx location blocks), the PHP-FPM operator guides cover the configuration in detail.

We assembled the shortlist from tools with documented PHP-FPM or PHP APM integrations: official vendor docs, exporter repositories, and community plugin exchanges. Every claim on this page is drawn from vendor documentation and project repositories, not vendor marketing.

The heaviest-weighted criteria are PHP-FPM metric depth and collection granularity, because those two determine whether you can actually diagnose pool exhaustion during an incident. Ease of setup and stack correlation follow, since FPM problems are almost always caused by something upstream or downstream. Alerting, pricing predictability, and operational maturity round out the scoring.

Tester credit

Compiled by the Netdata team - Updated August 12, 2026

Sources verified

Scoring criteria

PHP-FPM metric depth 25%
Pool internals, not just app transactions
Collection granularity 20%
Per-second beats 60s polling for saturation events
Ease of setup 15%
Direct FastCGI/socket collection beats exporter assembly
Correlation with surrounding stack 15%
FPM alongside Nginx, host, and app metrics
Alerting and anomaly detection 10%
Built-in FPM alert templates vs writing rules from scratch
Pricing transparency and predictability 10%
Flat per-node beats per-GB ingest that scales with traffic
Operational maturity 5%
Official vs community-maintained integration

Vendor 01 / 10 · #netdata

Netdata

Real-time infrastructure monitoring with a built-in PHP-FPM collector that reads pool metrics at 1-second granularity over HTTP, TCP, or Unix socket.

Best for

Teams that want per-second PHP-FPM metrics without running a separate exporter or status-page polling setup
SREs who want FPM pool metrics correlated with host, Nginx, and application metrics in one dashboard
Budget-conscious teams that want open-source agents with a paid cloud tier only for fleet-wide features

Pricing

Per-node pricing: Netdata Cloud Business from $4.50/node/month on annual plans, decreasing as node count grows
Free Cloud tier for up to 5 nodes; agents are open source (AGPL) and remain free
Unlimited metrics, logs, users, and retention on paid plans - no per-GB or per-metric charges
Homelab plan for unlimited nodes at a flat yearly rate

Pros

Collects PHP-FPM metrics at 1-second granularity by default via the go.d phpfpm collector, with configurable update_every
Connects to FPM over HTTP, TCP, or Unix socket - no web server status-page route required
Monitors active/max_active/idle connections, requests, max_children_reached, slow requests, request duration, request CPU, and request memory per FPM instance
Supports multiple FPM instances, local and remote, in one configuration file
Correlates FPM metrics with 800+ other integrations (Nginx, Apache, Linux, Docker, Kubernetes) in the same UI
ML-based anomaly detection and AI-assisted troubleshooting on top of raw metrics

Where teams pair it

No default alert rules ship with the phpfpm collector; you create your own alert configuration for max_children_reached and queue depth
The collector requires manual configuration (no auto-detection), and pm.status_path must be enabled on the FPM pool first
Code-level PHP transaction tracing is not Netdata’s strength: it ingests OTLP traces today, but the trace visualization UI is still rolling out, so teams needing Laravel-style transaction traces pair it with an APM tool

Verdict

Netdata leads this list because it is the only tool here that collects FPM pool metrics at 1-second resolution by default, reads them directly over FastCGI or a Unix socket without a web server status route, and exposes per-request duration, CPU, and memory that most pollers never surface. When a pool exhausts its workers for eight seconds during a deploy, per-second collection is the difference between seeing it and missing it. The honest caveats: you write your own FPM alert rules, you enable the status path yourself, and if you need Laravel transaction traces you will pair it with an APM tool rather than replace one.

Start free -> Netdata pricing ->

Vendor 02 / 10 · #datadog

Datadog

Commercial observability platform with a built-in PHP-FPM agent check that monitors pool status and request performance.

Best for

Teams already standardized on Datadog for APM, logs, and infrastructure who want FPM metrics in the same platform
Organizations that need commercial support and a large integration ecosystem

Pricing

Per-host pricing for Infrastructure Monitoring and APM, plus per-GB charges for logs and per-million charges for custom metrics and indexed spans
Limited free tier capped by host count and short retention
Bill grows with host count, data ingest volume, indexed spans, and add-on products

Pros

Built-in PHP-FPM check ships with the Datadog Agent - no separate exporter to install
Collects listen queue size, active/idle/max processes, max children reached, accepted requests, and slow requests
Supports direct FastCGI communication (use_fastcgi) to bypass web server proxies
Monitors multiple FPM pools via proxy routes or direct FastCGI
1,000+ integrations and Watchdog ML-assisted alerting

Cons

Collection runs on the standard Agent check interval, not per-second - fast pool saturation events can be missed
Requires pm.status_path and ping.path configuration on every FPM pool
Pricing is complex and scales across hosts, logs, spans, and custom metrics - bills grow quickly

Verdict

Datadog has the strongest commercial PHP-FPM integration after Netdata, covering the same core pool metrics and offering a direct FastCGI path that skips the web server. The trade-offs are granularity and cost shape: the agent check does not run per-second, so short saturation spikes can slip between intervals, and the bill compounds across hosts, ingest, spans, and custom metrics in ways that are hard to predict as traffic grows. If you already pay for Datadog, enable the FPM check. If you are choosing fresh, compare the total cost carefully.

Read full Netdata vs Datadog -> Datadog pricing ->

Vendor 03 / 10 · #prometheus

Prometheus + Grafana

Open-source metrics stack that scrapes PHP-FPM status pages via php-fpm_exporter and visualizes them in Grafana dashboards.

Best for

Teams already running Kubernetes or a Prometheus-based observability stack
Organizations that want full control over data storage and dashboards without vendor lock-in

Pricing

Open source and self-hosted: you run and operate Prometheus, the exporter, and Grafana yourself
Grafana Cloud (optional SaaS) bills on active series, data points per minute, log ingest, and trace ingest
Self-hosted cost is infrastructure and operational time, not license fees

Pros

php-fpm_exporter connects directly to FPM via TCP or Unix socket - no web server status route needed
Exposes a rich metric set: accepted connections, active/idle/total processes, listen queue, max_children_reached, slow requests, process states
Actively maintained exporter (commits through August 2025) with Docker and Kubernetes deployment support
Multiple community Grafana dashboards for PHP-FPM: single pool, multi-pool, Kubernetes
PHP-FPM status page natively supports OpenMetrics format since PHP 8.1, enabling direct scraping without an exporter

Cons

Requires assembling and operating multiple components: exporter, Prometheus server, Grafana, and alerting rules
Default scrape interval is typically 15-30 seconds - not per-second
No built-in alert templates for FPM metrics; you write your own PromQL alert rules
php-fpm_exporter is community-maintained (hipages), not an official Prometheus project

Verdict

This is the standard open-source DIY path, and it covers the same core FPM metrics as the commercial tools once you assemble it. PHP 8.1’s native OpenMetrics status output removes the exporter from simple setups, which helps. The real cost is operational: you own the exporter lifecycle, the scrape configs, the dashboards, and every PromQL alert rule. At typical 15-30 second scrape intervals you also accept that short pool exhaustion events will be smoothed into averages.

Read full Netdata vs Prometheus -> Grafana pricing ->

Vendor 04 / 10 · #zabbix

Zabbix

Open-source enterprise monitoring platform with official PHP-FPM templates that poll the FPM status page via HTTP or the Zabbix agent.

Best for

Enterprises that want a self-hosted, open-source monitoring platform with official FPM templates
Teams already running Zabbix for network and server monitoring who want FPM in the same system

Pricing

Open source and self-hosted: you run and operate it
Optional paid technical support plans from Zabbix
Cost scales with infrastructure and operational effort, not per-node licenses

Pros

Official PHP-FPM by Zabbix agent and PHP-FPM by HTTP templates - no external scripts needed
Monitors active/idle/total processes, accepted connections, slow requests, listen queue, max children reached, queue utilization, and process CPU/memory
Supports multiple FPM pools via community templates with LLD auto-discovery
Built-in triggers for FPM down, slow requests, high queue utilization, and process not running
Tested on PHP 7 and PHP 8

Cons

Default polling is typically 1 minute - not per-second
The Zabbix agent template does not support HTTPS or redirects (a web.page.get limitation)
Official templates monitor one pool per status URL; multi-pool requires community templates
Setup requires enabling the status page and configuring Nginx or Apache location blocks

Verdict

Zabbix is the most complete self-hosted option after the Prometheus stack, and it is the only one with official templates and built-in FPM triggers, which saves real setup time. Process-level CPU and memory per pool is a genuine strength. The limits are granularity and pool scope: 1-minute default polling will miss short saturation events, and multi-pool monitoring leans on community templates rather than the official ones. A solid pick for existing Zabbix shops.

Read full Netdata vs Zabbix -> Zabbix pricing ->

Vendor 05 / 10 · #dynatrace

Dynatrace

Enterprise observability platform with built-in PHP-FPM monitoring that automatically collects pool metrics when FPM hosts are detected.

Best for

Large enterprises that want automatic discovery of PHP-FPM hosts and pool metrics without manual exporter setup
Teams already invested in Dynatrace for full-stack observability

Pricing

Per-host pricing for infrastructure and full-stack monitoring, billed per hour
Full-Stack billed per 8 GiB host (memory-based); logs billed per GiB ingested
Bill grows with host count, memory allocation, and data ingest

Pros

Automatic PHP-FPM monitoring: metrics are collected whenever a host running PHP-FPM is detected
Monitors accepted connections, slow requests, waiting connections, active/total processes, and queue depth
Supports multiple FPM pools via space-separated status page URIs
Includes process-level details (requests, input buffering, processes) on individual process pages
Requires only PHP 7.1+ and an enabled status page - no separate exporter

Cons

Per-8-GiB-host pricing is expensive for small fleets
Metric set is smaller than dedicated FPM collectors: no request duration, CPU, or memory per request
Requires the status page to be accessible from localhost over HTTP(S)

Verdict

Dynatrace’s differentiator is zero-effort discovery: OneAgent finds FPM hosts and starts collecting pool metrics on its own, which matters in a large fleet. The FPM metric set is shallower than dedicated collectors, missing per-request duration and resource usage, and collection cadence is the standard platform interval rather than per-second. The memory-based host pricing makes this an enterprise decision, not an FPM decision. Right for existing Dynatrace shops; hard to justify for FPM monitoring alone.

Read full Netdata vs Dynatrace -> Dynatrace pricing ->

Vendor 06 / 10 · #checkmk

Checkmk

IT infrastructure monitoring platform with a community PHP-FPM check plugin that tracks FPM pool performance indicators.

Best for

Teams that want a self-hosted or SaaS monitoring platform with agent-based collection and a large ruleset ecosystem
Organizations already using Checkmk for server and application monitoring

Pricing

Priced per service (not per host) for Infrastructure Monitoring, with custom metrics and synthetic tests as separate units
Free Community edition limited to a set number of services on one site
Bill grows with the number of monitored services and custom metrics

Pros

Community PHP-FPM check plugin on the Checkmk Exchange, actively updated (April 2026)
Monitors FPM pool performance indicators via the Checkmk agent
2,000+ built-in check plugins and a mature alerting and notification system
Raw edition is open source; commercial editions add enterprise features

Cons

PHP-FPM monitoring relies on a community plugin, not an official Checkmk integration
Plugin requires Checkmk 2.3.0+ as a minimum version
Default check interval is typically 1 minute
No per-second granularity for FPM metrics

Verdict

Checkmk is a mature monitoring platform, but its PHP-FPM coverage is a community plugin rather than a first-class integration, which puts the maintenance risk on you. The plugin is actively updated, which helps, and Checkmk’s notification engine is genuinely good. But coarse default polling and unofficial integration status mean this is a reasonable add-on for existing Checkmk users, not a reason to adopt Checkmk for FPM monitoring.

Read full Netdata vs Checkmk -> Checkmk pricing ->

Vendor 07 / 10 · #site24x7

Site24x7

All-in-one SaaS monitoring platform from Zoho with PHP APM agents and PHP-FPM slow log analysis.

Best for

SMBs and MSPs that want a single SaaS platform for website, server, and PHP application monitoring
Teams that want PHP-FPM slow logs analyzed without building a log pipeline

Pricing

Per-monitor pricing with three license types: basic, host, and advanced monitors
APM instances (including PHP) count as advanced monitors; server monitoring counts as host monitors
Bill grows with the number of monitors, add-ons (logs, RUM, synthetic runs), and polling frequency

Pros

APM Insight PHP agent monitors PHP applications with code-level tracing
PHP-FPM slow log management: collects and analyzes FPM slow logs via the server agent
Monitors PHP apps on Linux and Windows (IIS)
30-day free trial with no credit card

Cons

No dedicated PHP-FPM pool status integration - FPM pool metrics like max children and listen queue are not collected by the APM agent
APM instances are billed as advanced monitors, the most expensive license type
PHP-FPM slow logs require the separate server monitoring agent

Verdict

Site24x7 covers two adjacent needs well - PHP application tracing and FPM slow log analysis - but it never reads the FPM status page, so pool saturation metrics are absent. Slow logs tell you a request was slow after the fact; pool metrics tell you the pool is about to run out of workers. For Site24x7 shops this is a reasonable PHP story. For FPM pool monitoring specifically, pair it with something that reads the status page.

Read full Netdata vs Site24x7 -> Site24x7 pricing ->

Vendor 08 / 10 · #newrelic

New Relic

Usage-based observability platform with a PHP agent that auto-instruments applications running on PHP-FPM and tracks transaction performance.

Best for

Teams that want APM-style visibility into PHP application transactions, not just FPM pool metrics
Organizations that prefer a single platform for metrics, logs, and traces

Pricing

Usage-based: per-GB data ingest plus per-user fees for core and full-platform users
Free tier with limited monthly ingest and basic user access
Bill grows with data volume, user count, and optional add-ons

Pros

PHP agent auto-instruments Laravel, Symfony, and other frameworks with code-level transaction traces
Agent plus daemon architecture forwards data to the platform; supports multiple apps per daemon
Combines APM, infrastructure, logs, and traces in one platform
Free tier with limited monthly ingest

Cons

No dedicated PHP-FPM pool integration - FPM process counts require the Infrastructure agent, not the PHP agent
Per-GB ingest pricing makes bills unpredictable as data volume grows
Requires restarting the web server (PHP-FPM) after agent installation

Verdict

New Relic is strong PHP APM and weak FPM monitoring. The PHP agent gives you transaction traces, errors, and framework instrumentation that pool monitors cannot. What it does not give you is max_children_reached, listen queue depth, or slow request counts from the status page, and the Infrastructure agent’s process counts are not a substitute for pool internals. Use it for code-level visibility, and expect the ingest bill to track your traffic.

Read full Netdata vs New Relic -> New Relic pricing ->

Vendor 09 / 10 · #scout

Scout APM

Developer-focused APM for PHP (Laravel, Lumen, Symfony) with automatic N+1 detection, error monitoring, and transaction tracing.

Best for

PHP development teams using Laravel or Symfony who want code-level performance insights and N+1 detection
Small teams that want a simple, predictable APM without platform complexity

Pricing

Transaction-based tiers with no per-seat or per-host charges
Free tier with a set number of transactions; paid plans scale with transaction volume
Bill grows with the number of monitored transactions

Pros

Auto-instruments Laravel, Lumen, and Symfony with minimal overhead
Automatic N+1 query detection in Eloquent and Doctrine
Combines errors, logs, and traces in a single view
Supports PHP 7.2 through 8.3
Memory bloat detection for long-running PHP processes

Cons

No PHP-FPM pool metrics - it monitors application transactions, not FPM status
Limited to Laravel, Lumen, and Symfony frameworks
No infrastructure or host-level monitoring

Verdict

Scout is excellent at the question developers actually ask - why is this Laravel endpoint slow - with N+1 detection that surfaces Eloquent and Doctrine problems automatically. It is not an FPM monitor at all: no pool metrics, no status page collection, no host metrics. If your question is whether pm.max_children was reached, Scout cannot answer it. Treat it as the APM half of a two-tool PHP setup.

Scout PHP monitoring -> Scout pricing ->

Vendor 10 / 10 · #atatus

Atatus

Full-stack observability platform from NamLabs with a PHP APM agent supporting PHP 5.6+ and framework instrumentation.

Best for

Teams that want a Datadog or New Relic alternative with simpler pricing
PHP shops running CodeIgniter, Lumen, Phalcon, Laravel, Symfony, or Magento

Pricing

APM priced per request volume; no per-user or per-host charges
Custom pricing based on infrastructure size, data volume, and monitoring needs
14-day free trial with no credit card

Pros

PHP agent supports PHP 5.6 and above with step-by-step installation for Debian, RedHat, Docker, and Heroku
APM tracks transactions, exceptions, HTTP failures, session traces, databases, and external requests
Full-stack platform: APM, RUM, infrastructure, logs, Kubernetes, and synthetic monitoring
On-premises deployment option available

Cons

No dedicated PHP-FPM pool status metrics (active processes, max children, listen queue)
APM pricing is custom and quote-based rather than transparent self-serve
Smaller ecosystem and fewer community resources than Datadog or New Relic

Verdict

Atatus is a credible PHP APM with broad framework support and an on-premises option that regulated teams will appreciate. Like the other APM entries, it does not read FPM pool internals, so pool saturation remains invisible. Quote-based pricing means you will not know the cost without a sales conversation. Reasonable as an APM choice; bring a separate tool for the FPM pool.

Atatus PHP agent docs -> Atatus pricing ->

Frequently asked questions

What PHP-FPM metrics should I monitor?

Start with active, idle, and total processes, which are the core pool health signals. Track max_children_reached, the counter of how many times pm.max_children was hit since pool start, because it is the clearest sign of undersized pools. Watch listen queue size and queue utilization for connections waiting on a worker, and slow requests for anything exceeding request_slowlog_timeout. Accepted connections and request rate give you a throughput baseline. Tools like Netdata and php-fpm_exporter also expose request duration, CPU, and memory per request, which matter when individual requests are the reason workers stay occupied.

How do I enable the PHP-FPM status page for monitoring?

Set pm.status_path = /status and ping.path = /ping in the FPM pool configuration, then configure Nginx or Apache location blocks to route those URLs to the FPM pool. Restart PHP-FPM and verify with curl http://localhost/status?json. Some tools can skip the web server entirely: Netdata, php-fpm_exporter, and Datadog (with use_fastcgi) talk to FPM directly over TCP or a Unix socket. See the PHP-FPM guides for the full configuration walkthrough.

Why does PHP-FPM monitoring need per-second collection?

Pool saturation events like max_children_reached spikes and listen queue buildups happen in seconds, often during deploys or traffic bursts. A 60-second polling interval can miss the spike entirely or render it as a flat line that looks like a non-event. Per-second collectors like Netdata catch the exact moment a pool exhausts its workers, which is what you need during incident response. Coarse polling is acceptable for capacity planning trends, just not for diagnosing why users saw errors at 14:03.

Can I scrape PHP-FPM directly with Prometheus?

Yes, if you run PHP 8.1 or later: the status page natively supports the OpenMetrics format via ?format=openmetrics, so Prometheus can scrape it without an exporter. Older PHP versions need an exporter such as hipages/php-fpm_exporter. The exporter can connect directly to FPM over TCP or a Unix socket without routing through the web server. Grafana has community dashboards for both direct scraping and exporter-based collection.

How do I monitor multiple PHP-FPM pools?

Each pool needs its own status URL or socket path. Netdata supports multiple jobs in go.d/phpfpm.conf for local and remote instances. Datadog supports multiple pools via proxy routes or direct FastCGI. Zabbix’s official templates monitor one pool per status URL, while community templates add LLD auto-discovery for multiple pools. Dynatrace accepts space-separated status page URIs for multiple pools on a host.

What causes max_children_reached and how do I alert on it?

The usual causes are pm.max_children set too low for the traffic level, slow requests or blocking external calls holding workers longer than expected, and memory limits killing and restarting workers, which reduces effective capacity. Alert on the max_children_reached counter and correlate it with slow requests and request duration to find the root cause. Note that Netdata exposes max_children_reached as a metric but ships no default alert for it, so you create the alert yourself.

Is a PHP APM tool enough for PHP-FPM monitoring?

No. APM tools like New Relic, Scout, and Atatus trace application transactions but do not expose FPM pool internals. An APM cannot tell you that pm.max_children was reached or that the listen queue is backing up. You need both signals: an FPM pool monitor for the process pool and an APM for code-level transaction performance. Netdata covers the pool side; pair it with an APM if you need Laravel or Symfony transaction traces.

How much does PHP-FPM monitoring cost?

It depends on the pricing shape. Open-source self-hosted options like Prometheus + Grafana and Zabbix have no license fee, but you run and operate them, which is a real cost. Per-node pricing (Netdata) includes unlimited metrics and retention. Per-host pricing (Datadog, Dynatrace) grows with host count and, in Dynatrace’s case, memory allocation. Per-GB ingest pricing (New Relic) grows with data volume. Per-monitor pricing (Site24x7) counts APM instances as the most expensive license type. Per-transaction pricing (Scout) grows with request volume.

What is the difference between PHP-FPM monitoring and PHP APM?

PHP-FPM monitoring tracks the process pool: active and idle processes, max children reached, listen queue, and slow requests. PHP APM tracks individual requests through the application: transaction traces, database queries, errors, and N+1 patterns. The two are causally linked - FPM pool problems cause application slowness, and slow application code exhausts pools - but they are measured differently and by different tools. A complete PHP observability setup needs both signals.

The 10 best PHP-FPM monitoring tools, ranked

How we evaluated PHP-FPM monitoring tools

Netdata

Datadog

Prometheus + Grafana

Zabbix

Dynatrace

Checkmk

Site24x7

New Relic

Scout APM

Atatus

Frequently asked questions

Book Your Free Demo