Telescope Will Fill Your Disk and You Won't Notice Until It's Too Late
Laravel Telescope's default pruning config is fine for local dev. In production it's a slow disaster. Here's what I actually set.
Telescope's defaults are designed to make local development pleasant. They are not designed to keep your production server alive. I've watched a managed hosting client's MySQL instance balloon past 40GB because nobody thought to revisit the out-of-the-box pruning configuration. The disk alert fired at 2am. Good times.
What Telescope Is Actually Doing to Your Database
Telescope records everything it can get its hands on - HTTP requests, queries, exceptions, jobs, mail, cache hits, scheduled commands, Redis commands, model changes. That's genuinely useful when you're debugging. In production, under any real traffic, it's a firehose pointed at your telescope_entries and telescope_monitoring tables.
By default, Telescope's prune command clears records older than 24 hours. The command itself doesn't run unless you schedule it. And even when you do schedule it, the default hours argument is 24 - which means if your site does 500 requests an hour, you're storing 12,000 request entries before the first prune even runs. Each entry includes the full request payload, response body, all query bindings, headers. These rows are fat.
I've seen telescope_entries rows run 50-100KB each when you factor in the JSON blob. Do the math on a busy endpoint and you'll understand why I now treat Telescope configuration as a production deployment checklist item, not an afterthought.
The Configuration That Actually Matters
There are three places you need to touch: config/telescope.php, your scheduler, and your environment-specific watchers. Let me go through each.
1. Aggressive pruning on the scheduler
In app/Console/Kernel.php (or your routes/console.php if you're on Laravel 11):
// Laravel 10 and earlier - app/Console/Kernel.php
protected function schedule(Schedule $schedule): void
{
$schedule->command('telescope:prune --hours=12')->daily();
}
That's the minimum. For high-traffic apps I drop it to 6 hours and run it every 6 hours:
$schedule->command('telescope:prune --hours=6')->everySixHours();
The --hours flag tells Telescope to delete anything older than that window. You're not losing useful debugging data by pruning aggressively - if you haven't looked at a request entry in 6 hours, you're not going to look at it.
2. Per-watcher record limits in config/telescope.php
This is the one people miss. Each watcher accepts a limit key that caps how many records Telescope will store for that type before it starts discarding old ones. It's not documented prominently and I didn't find it until I went digging through the source.
'watchers' => [
Watchers\QueryWatcher::class => [
'enabled' => env('TELESCOPE_QUERY_WATCHER', true),
'slow' => 100, // only flag queries slower than 100ms
'limit' => 50,
],
Watchers\RequestWatcher::class => [
'enabled' => env('TELESCOPE_REQUEST_WATCHER', true),
'size_limit' => env('TELESCOPE_RESPONSE_SIZE_LIMIT', 64),
'limit' => 100,
],
Watchers\ExceptionWatcher::class => [
'enabled' => env('TELESCOPE_EXCEPTION_WATCHER', true),
'limit' => 100,
],
Watchers\JobWatcher::class => [
'enabled' => env('TELESCOPE_JOB_WATCHER', true),
'limit' => 50,
],
Watchers\MailWatcher::class => [
'enabled' => env('TELESCOPE_MAIL_WATCHER', true),
'limit' => 25,
],
// ... etc
],
The size_limit on RequestWatcher is in kilobytes. The default is 64KB per response body. I lower that to 32KB on most apps. If you're debugging a problem with a large response you can bump it temporarily and redeploy - that's fine.
3. Turn off watchers you don't need in production
This is the other lever most people don't pull. Gate your watchers on environment:
'watchers' => [
Watchers\CacheWatcher::class => [
'enabled' => env('TELESCOPE_CACHE_WATCHER', false), // off by default in prod
],
Watchers\RedisWatcher::class => [
'enabled' => env('TELESCOPE_REDIS_WATCHER', false),
],
Watchers\ModelWatcher::class => [
'enabled' => env('TELESCOPE_MODEL_WATCHER', false),
'events' => ['eloquent.created*', 'eloquent.updated*'],
'limit' => 50,
],
Watchers\QueryWatcher::class => [
'enabled' => env('TELESCOPE_QUERY_WATCHER', true),
'slow' => 100,
'limit' => 50,
],
]
In your production .env you then have:
TELESCOPE_CACHE_WATCHER=false
TELESCOPE_REDIS_WATCHER=false
TELESCOPE_MODEL_WATCHER=false
And locally or in staging you flip those on when you need them. Cache and Redis watchers are surprisingly chatty on a busy app. Model watchers on a system doing a lot of writes will generate enormous volume.
The Gotcha That Got Me
The disk-filling incident I mentioned at the top wasn't just a pruning issue - it was a pruning issue compounded by the response size limit being too generous on an app that returned large JSON payloads. The client runs an e-commerce catalog with some product detail endpoints returning 200-400KB of nested JSON (not ideal, but that's a different post). With the default 64KB cap and my failure to prune frequently enough, every one of those request records was capping out at 64KB. At a few hundred requests per hour, the math got ugly fast.
The fix was to lower size_limit to 16 for that app specifically, run a manual prune to clear the backlog, and add the aggressive scheduler entry. Table dropped from 38GB to under 200MB within the next pruning cycle.
Lesson: size_limit matters as much as prune frequency. Set both.
The pruning command doesn't chunk by default
Another thing worth knowing - telescope:prune does its deletes in a single query pass by default. On a table that's already bloated, that DELETE can take a very long time and lock your database in ways you don't want during peak traffic. If you're doing a remediation prune on an already-large table, I'd do it in steps:
php artisan telescope:prune --hours=168 # first pass: clear anything older than a week
php artisan telescope:prune --hours=48
php artisan telescope:prune --hours=24
php artisan telescope:prune --hours=12
Walk it down rather than trying to clear 30GB in one shot.
A Custom Pruning Listener
For one healthcare client I went a step further and added a Telescope filter to drop health check requests entirely - they hit our endpoints every 30 seconds and were pure noise:
// In App\Providers\TelescopeServiceProvider::boot()
Telescope::filter(function (IncomingEntry $entry) {
if (app()->environment('local')) {
return true;
}
// drop health check pings entirely
if ($entry->isRequest() && str_contains($entry->content['uri'] ?? '', '/health')) {
return false;
}
// in production, only record slow queries, exceptions, and failed jobs
return $entry->isReportableException()
|| $entry->isFailedJob()
|| $entry->isSlowQuery()
|| $entry->hasMonitoredTag();
});
That filter reduced recorded entries by probably 80% on that app. A monitoring agent pinging /health every 30 seconds is 2,880 request records per day that tell you exactly nothing.
When I'd Reach for Telescope (and When I Wouldn't)
Telescope earns its keep in staging and during active development. It's the fastest way I know to understand what an unfamiliar Laravel app is actually doing - which queries fire on a given request, what jobs enqueue, what mailable gets generated. I use it constantly when I'm onboarding to a new codebase.
In production, I keep it running but with strict gates. The filter callback approach is the right one for high-traffic apps. Only record what you'll actually look at: exceptions, slow queries, failed jobs. Everything else is noise you're paying disk and I/O to store.
I would not run Telescope in production without the scheduler configured. That's a hard rule. If the prune command isn't scheduled, you haven't deployed Telescope - you've deployed a time bomb. Same goes for teams that enable it on a production box to debug something urgent and forget to disable it. Put a calendar reminder. Seriously.
If you're on a managed database like RDS or PlanetScale and your storage tier is metered, treat this as a cost issue, not just a disk issue. I've seen Telescope add $40-80/month to an RDS bill on a medium-traffic app before anyone caught it.
The Bottom Line
Telescope is a genuinely good tool and I'd miss it if it disappeared. But it's built to be developer-friendly first, and "developer-friendly" sometimes means the defaults are wrong for production. Configure the filter, set the limits, schedule the prune, and check the table size a week after you deploy. Everything else takes care of itself.
Need help shipping something like this? Get in touch.