Most of the time, we find out about these things after something breaks. LaraScope fixes that, it's a Laravel package I built to give you real-time visibility into every HTTP request your app handles, with zero setup friction.

In this article, I'll walk you through what LaraScope does, how it works, and how to get it running in your project in under 5 minutes.

The Problem

Debugging performance issues in Laravel usually means one of the following:

• Dumping queries with DB::enableQueryLog() and forgetting to remove it

• Installing Laravel Telescope (great tool, but heavy if you only care about HTTP + SQL)

• Paying for an external APM service and sending your data to a third party

I wanted something in the middle, lightweight, self-hosted, and focused.

Introducing LaraScope

LaraScope is a Laravel package that automatically logs every HTTP request passing through your app, capturing:

• ✅ HTTP method, URL, path, and named route

• ✅ Response status code

• ✅ Request duration (ms)

• ✅ Peak memory usage (MB)

• ✅ Every SQL query fired, with raw SQL, bindings, and execution time

• ✅ Slow query detection with a configurable threshold

• ✅ Authenticated user ID

• ✅ Request headers (with sensitive ones stripped by default)

All of this is stored in your own database, and browsable through a built-in dashboard, no external service, no API key, no data leaving your infrastructure.

Installation

Getting started is a single command:

composer require amjad-ah/larascope

Then publish the config and migration:

php artisan vendor:publish --tag=larascope-config
php artisan vendor:publish --tag=larascope-migrations
php artisan migrate

That's it. LaraScope automatically injects itself into your web and api middleware groups. No manual Kernel.php edits, no service provider registration, it just works.

The Dashboard

Once installed, navigate to /larascope in your browser and you'll see the live request log.

The list gives you an at-a-glance view of every request: method badge, path, status code, how long it took, how many queries it ran, and peak memory. You can immediately spot the slow ones.

Filtering

The dashboard comes with built-in filters so you're not drowning in noise:

You can filter by:

• HTTP Method: show only POST or GET requests

• Status Code: find all 500 errors or 404s in seconds

• Path: search by partial path, e.g. /api/users

🚧 Coming soon: I'm working on advanced filters, think filtering by slow queries, response time ranges, and more. The goal is to make the dashboard a proper debugging tool, not just a log viewer.

Request Detail

Click any entry to drill into the full detail view:

Here you get:

• The full URL and route name

• All SQL queries with their raw SQL, bindings, execution time, and a "slow" badge if they exceeded your threshold

• Request headers (after filtering out Authorization, Cookie, and X-CSRF-TOKEN)

• Peak memory usage

• Total request duration

Slow Query Detection

One of my favourite features. Every captured SQL query is automatically compared against a configurable threshold:

// config/larascope.php
'queries' => [
    'enabled'           => true,
    'slow_threshold_ms' => 100, // flag any query taking over 100ms
],

If a query exceeds the threshold, it gets flagged as slow. The RequestLog model even exposes a helper for this:

$log->hasSlowQueries(); // true if any query was slow

Privacy First

LaraScope is designed to be production-safe out of the box.

Request and response bodies are disabled by default. You have to explicitly opt in:

'logging' => [
    'include_request_headers' => true,
    'include_request_body'    => false,  // opt-in
    'include_response_body'   => false,  // opt-in

    // Sensitive headers are always stripped:
    'exclude_headers' => [
        'authorization',
        'cookie',
        'x-csrf-token',
    ],
],

You can also exclude entire paths or HTTP methods from being logged:

'exclude_paths'   => ['health', '_debugbar/*', 'telescope/*'],
'exclude_methods' => ['OPTIONS'],

💡 Dashboard routes (/larascope/*) are always auto-excluded to prevent infinite log growth.

Securing the Dashboard

By default the dashboard is open. Before going to production, add auth to its middleware:

'dashboard' => [
    'path'       => env('LARASCOPE_DASHBOARD_PATH', 'larascope'),
    'middleware' => ['web', 'auth'], // 👈 add this
],

Keeping Logs Under Control

LaraScope ships with a built-in prune command to clean up old records:

php artisan larascope:prune

By default it retains 30 days of logs. Schedule it so you never have to think about it:

// routes/console.php (Laravel 11+)
Schedule::command('larascope:prune')->daily();

Octane Compatible

LaraScope is built to work correctly with Laravel Octane. Since the middleware can be a singleton in a persistent runtime, every request resets its own state at the start of handle(), preventing query data from bleeding across requests.

LaraScope vs. Telescope

A fair question: why not just use Telescope?

If you need full-stack observability, jobs, mail, notifications, exceptions, Telescope is the right call. If you want fast, focused HTTP + SQL monitoring with minimal setup, LaraScope is a great fit.

Wrapping Up

LaraScope started as a personal tool because I kept reaching for DB::enableQueryLog() in the same five situations over and over. Packaging it up properly forced me to think about edge cases I hadn't considered, Octane state isolation, privacy defaults, log growth, and the result is something I actually use in my own projects.

If it solves a problem you've had, give it a try and drop a ⭐ on the repo.

GitHub: github.com/amjadAH/larascope

composer require amjad-ah/larascope

Have a feature request or found a bug? Open an issue on GitHub, contributions are welcome!

ACID:

A: Atomicity:

it ensures that all steps or statements in a transaction are fully applied committed, or fully reverted rolled-back,

for example, if we have an ordering system, which has orders table, and order_items table, while placing an order, we want to insert the order first, them the order items, imagine that the connection lost or any error occurred after inserting the order, now we have an empty order without any items in it, this is where we will need to roll-back the order insertion, to avoid the empty order.

C: Consistency:

it ensures that the data integrity, even when we have multiple users using the system at the same time,

for example, let’s build on the example before, let’s imagine that orders table has a column named total, which refers to the total amount of the order, and order_items table has a column named price, the value of orders.total should be exactly sum(order_items.price.

I: Isolation:

it ensures that any new transaction should wait for other transactions which are working on the same records to finish, to make sure that concurrent transactions don’t interfere with each other,

for example, let’s continue building on the same example, imagine a user is order the last item of a specific product, and at the same time another one is trying to buy the same product, the second transaction should wait for the first one to finish so it can proceed.

D: Durability:

it ensures that once a transaction is committed to the database, it will never get lost, even if the system experienced failure or anything,

for example, in the same ordering system, once you have placed an order, it can never be lost

BASE:

BA: Basically Available:

it means that the system will always respond to requests, even if some parts of it are failing or operating with degraded performance. Instead of guaranteeing immediate consistency (like ACID), the system prioritizes availability by allowing temporary inconsistencies.

S: Soft State:

it means that the state of the data can be changed automatically, even without any external triggers or inputs, This contrasts with a strictly consistent state (like ACID), where the data is immediately consistent after each transaction.

E: Eventually consistent:

it means the system may allow temporarily inconsistent data, that will eventually converge to a consistent state after a period of time, as long as no new updates are made.

Key Differences Between ACID and BASE: