Everything the New Debug Bar can do

See what arrived, which code handled it, and what your application returned.

• Page and API requests

  Capture HTML, JSON, AJAX, Livewire, redirect, download, and streamed-response requests.

• Received → Matched → Responded

  Read the incoming request, matched route, authentication state, and response in one trace.

• Exact request identity

  Identify a profile by its method, URL, status, recording time, and ID, also returned in the X-NewDebugBar-Profile header.

• Headers and submitted input

  Inspect retained request headers, query parameters, and submitted input, then copy a detail group as JSON.

• Routes and middleware

  Find the route name, controller or action, route parameters, and captured middleware evidence.

• Authentication context

  See the guard, guest or authenticated state, authenticatable model, and a stable hashed identity reference.

• Session structure

  Inspect the session driver, key names, flash keys, and validation error-bag names without dumping session values.

• Response details

  Read retained response headers, content type, status, duration, and request or response sizes where available.

JSON, downloads, redirects, and streams can be profiled without inserting toolbar HTML into their response bodies.

See when work happened and which measured operations took the most time.

• Request performance at a glance

  Read response duration, query count, total query time, and process peak memory together.

• One chronological timeline

  Follow captured SQL, HTTP calls, models, views, logs, exceptions, events, and queue activity in time order.

• Waterfall and mobile detail

  Compare measured spans on a shared desktop time scale or use chronological activity details on smaller screens.

• Search and focus

  Search activity or source and switch between key activity, all activity, or a single inspector section.

• Activity details and source

  Inspect timestamps and available duration measurements, copy the application source, or open the related inspector.

• Long and incomplete timelines

  Load more activity as you scroll, retry failed loads, and see omitted counts when capture limits were reached.

The timeline distinguishes timed operations from point events; it is not a CPU flame graph or a complete breakdown of exclusive time.

Go from a slow page to the SQL, bindings, and application call site behind it.

• SQL, bindings, and source

  Inspect executed SQL, retained bindings, connection, duration, execution order, and the application call stack.

• Readable bound SQL

  Read and copy SQL with usable bound values when complete bindings were retained.

• Database time and query share

  See query totals, total database time, slow queries, and each query’s share of database and request time.

• Repeated query groups

  Group executions of the same query shape and compare their counts, timings, and binding differences.

• Likely N+1 detection

  Find repeated reads with changing bindings and a shared application source that suggest an N+1 problem.

• Search, filter, and sort

  Focus on slow, repeated, read, or write queries and drill into individual executions or groups.

• Transaction markers

  Locate transaction begin, commit, and rollback events with their connection and position in the profile.

• EXPLAIN query plans

  Request a plan for eligible read-only SQL on MySQL, PostgreSQL, or SQLite, with a clear reason when a plan is unavailable.

N+1 detection identifies likely patterns; EXPLAIN is an explicit local action and does not run EXPLAIN ANALYZE.

Let captured failures and performance patterns point you toward the next useful check.

• Failure leads

  Identify captured exceptions, failed requests or runtime operations, and failed outbound HTTP calls.

• Authorization and validation leads

  Surface denied decisions and validation failures with the relevant context and a concrete next check.

• Performance leads

  Find slow requests, slow queries, likely N+1 patterns, and repeated database work that crosses the analysis thresholds.

• Cache miss patterns

  Flag a high cache miss rate after enough reads have been captured to make the finding useful.

• Useful evidence and next steps

  Give agents structured findings with severity, an explanation, supporting evidence, a source when known, and a suggested next check.

• Attention where it matters

  Prioritize failures before performance leads, keep relevant inspector sections active, and move attention items up in the command palette.

Complete structured findings are available through MCP; the browser uses them to guide attention within the existing inspectors.

Trace record loads and logical changes back to application code.

• Record loads and writes

  Inspect model activity with the class, connection, table, and retained record identifiers.

• Model groups

  Group work by model and distinguish loaded records from logical change operations.

• Repeated record loads

  Spot repeated loads of identified records while keeping loads without a selected primary key visible.

• Changed attributes

  Inspect changed attribute names and captured post-change values with visible capture limits.

• Logical changes

  Read related lifecycle callbacks as one logical change instead of counting every callback as another write.

• Related SQL and sources

  Search model activity, follow application call sites, and inspect query evidence correlated by source.

Find the templates and captured data used to build the page.

• View occurrences

  See which views were composed, their order, and how often each template appeared.

• Application views first

  Group and search views, focus on application templates, and reveal framework or vendor views when needed.

• Original template sources

  Inspect and copy source paths, including original Blade sources resolved from compiled templates.

• View data and composers

  Inspect registered composer evidence and load the retained data for a selected view occurrence.

Views record composition activity; per-template Blade render durations are not measured.

See what was dispatched and which listeners were registered to handle it.

• Dispatched events

  Inspect event names, dispatch sources, broadcast markers, and sequence or timing markers.

• Payload shape

  Read argument types, public field names, counts, and truncation state without retaining event payload values.

• Listener registration

  Inspect registered listener metadata and available queued or synchronous handling evidence.

• Repeated events and duplicate listeners

  Group repeated event occurrences and spot duplicate listener registrations to check against discovery and explicit registration.

• Search and related activity

  Search event, listener, payload-shape, or source evidence and follow related framework diagnostic sections.

Understand a Gate or policy decision in the context that produced it.

• Gate and policy checks

  Inspect the ability, result, evaluated user, typed or model arguments, and application call site.

• Resolved handlers

  Identify the policy or Gate handler and inspect available source evidence.

• Decision details

  Read available decision messages, result codes, and custom HTTP statuses, or focus on denied checks.

• Blade authorization sources

  Resolve supported Blade authorization directives to the original template line and inspect repeated checks.

Find the failed fields and rules without losing the request that caused them.

• Fields, rules, and messages

  Inspect handled validation failures with failed fields, rule names, messages, and error bags.

• HTTP and Livewire failures

  Capture HTTP validation exceptions and supported Livewire failures with available source, component, and response context.

• Validation across redirects

  Show flashed errors on the redirected page as previous-request evidence and avoid duplicating the same validation exception.

Start at the failing application line and follow the cause when you need more detail.

• Exception details

  Inspect the captured exception class, message, file, line, and application location.

• Previous exception causes

  Follow retained exception causes to understand failures that were wrapped or rethrown.

• Application frames first

  Read your application’s stack frames first and reveal retained framework or vendor frames for deeper investigation.

• Source context and linked logs

  Read bounded code around the failing line and follow relationships to captured log entries when available.

Read messages with their context, channel, and application source.

• Messages, context, and channels

  Inspect log level, message, timestamp, retained context, source, and available Laravel channel information.

• Repeated message folding

  Fold consecutive identical log entries while keeping their individual occurrence details accessible.

• Search and severity filters

  Search messages, context, or source, filter by severity or attention, and copy useful details.

• Related exceptions and mail

  Follow linked exception evidence and inspect logged mail content in the Mail inspector instead of a full MIME dump.

Explore the component tree, follow state changes, and edit supported live properties.

• Mounted component tree

  Browse Livewire 4 component instances, names, IDs, parent relationships, and mounted state across nested components and multiple roots.

• Properties and sources

  Inspect public property descriptors, supported browser values, component source, and view source.

• Client and server state

  Compare client values with confirmed server values and distinguish synced, dirty, updating, locked, and unconfirmed state.

• Server lifecycle activity

  Follow captured mounts, property updates, actions, renders, effects, and failures, with component metadata refreshed on each update.

• Browser-to-server context

  Connect server records with browser activity for the specific component update you are investigating.

• Update phases and timing

  Inspect browser request and update phases with available timing gaps around state synchronization and rendering.

• Before, submitted, and confirmed values

  Compare property values before an interaction, values submitted to the server, and confirmed values after the update.

• Actions and returned effects

  Follow action parameters, property changes, returned effects, and dispatched-event evidence within capture limits.

• Event dispatch and recipients

  Inspect event names, payloads, dispatch modes, declared targets, and observed recipient components.

• Bundled interactions

  Inspect bundled component interactions individually while keeping their shared HTTP profile linked.

• Rendering and grouped activity

  Read related lifecycle records as component activity, including initial and later render-duration evidence.

• Focused component workspaces

  Search components and activity, then switch between focused property, source, and interaction details.

• Live property editing

  Edit supported primitive public properties and eligible primitive array values on a currently mounted component.

• Checked edits with Apply and Cancel

  Use type-aware controls with editability and stale-value checks, then apply a real Livewire update and inspect its request.

Property edits can trigger normal application behavior; live browser state and browser-only traces are not all saved in server profiles.

See the outbound request, the response, and the code that made the call.

• Outbound Laravel HTTP calls

  Capture method, URL, host, status, start and finish timing, and duration for Laravel HTTP-client requests.

• Request and response content

  Inspect retained headers and bounded text or JSON bodies in dedicated request and response views.

• Connection failures and redirects

  Inspect failures even without a response, and see redirect Location targets when captured.

• Slow calls and response guidance

  Identify slow or failed calls and get response-specific checks for authentication, permissions, validation, rate limits, and server errors.

• Search and application sources

  Search, filter, and sort outbound calls, then inspect the application call site and retained stack.

• Copy as cURL

  Copy a sanitized cURL representation for supported captured requests.

Capture follows Laravel HTTP-client events; multipart and binary bodies are omitted, and copied cURL reflects retained content.

Find misses, repeated lookups, and failed operations with their original application source.

• Cache operations and outcomes

  Inspect Laravel cache reads, writes, forget or delete operations, and flushes with their captured outcomes.

• Hits, misses, and repeated misses

  See total reads, hit and miss rates, and repeated misses grouped by key.

• Keys, values, tags, and expiry

  Inspect the store, retained keys and values, tags, TTL or expiry metadata, and application source where captured.

• Batch, failure, and failover evidence

  Inspect available batch context, operation timing, write or delete failures, and store failover evidence.

• Search and operation details

  Search or filter cache activity and drill into individual operations and repeated-miss groups.

Inspect direct Redis commands without counting captured cache work twice.

• Direct Redis command details

  See the command, connection, recognized command keys, duration, failure state, and available exception class.

• Cache operation deduplication

  Remove matching Redis records already represented by Laravel cache events.

• Search and command sources

  Search or filter direct command activity and follow the application call site for each operation.

Recognized keys are retained within limits; arbitrary command arguments, field values, and return values are not captured.

Follow a dispatch beyond the response to its captured worker attempts and outcome.

• Dispatched jobs

  Inspect job class, connection, queue, delay, identity, attempts, and captured timing.

• Dispatch and execution

  Distinguish dispatch activity, synchronous execution, and asynchronous worker outcomes.

• Linked worker profiles

  Follow correlated worker profiles and attempts from the originating request, or return to that request.

• Attempts, releases, and retries

  Inspect waiting, completed, and failed states, recent attempts, released jobs, and retryable failures.

• Queued mail and notifications

  Inspect queued message metadata and open a linked mail preview or worker profile when available.

• Pending outcome refresh

  Check manually for newer worker outcomes or let the open inspector refresh pending work within a bounded polling window.

• Work after the response

  Capture supported work during request termination with separate timing, and search or filter queue activity by job, queue, or outcome.

Cross-process links need profiling in the worker environment and access to the relevant retained profiles and correlation data.

Read the message your application produced, including previews and retained attachments.

• Message and transport details

  Inspect subject, mailable, sender, recipients, reply-to, date, priority, return path, source, and available mailer, transport, message ID, and sending duration.

• HTML and text previews

  Open local previews of HTML and plain-text bodies captured automatically within the body limits.

• Isolated HTML preview

  Read HTML mail in a sandbox with remote resource loading blocked.

• Download as .eml

  Download a reconstructed message file from the retained mail content.

• Attachment downloads

  Inspect attachment metadata and download retained attachment bodies within the per-message budget.

• Queued outcomes and capture limits

  Follow available queued-mail outcomes and see when previews or attachment contents were truncated or unavailable.

Read a logical notification and the individual channel attempts behind it.

• Grouped channel attempts

  Group notification activity and inspect the class, recipient context, channel, and application source.

• Content and destination evidence

  Read bounded public notification data, channel destination, returned response evidence, and captured timing.

• Delivery activity and failures

  Distinguish captured queued, pending, sent, and failed activity and inspect channel failure details.

• Related mail and worker profiles

  Search or filter notifications and follow a related mail record or worker profile when correlation is available.

Channel detail depends on the events available; a sent or completed event does not prove receipt by the recipient.

Give agents exact saved evidence in focused responses, helping reduce guessing and token use.

• Discover the right profile

  Use list-debug-profiles to filter retained profiles by method, path, status, or warnings, or use an exact response profile ID.

• Read focused inspector evidence

  Use get-debug-profile-section for a bounded summary and a page of evidence from a chosen inspector.

• Get findings and next checks

  Use get-debug-findings to read structured diagnostic leads, supporting evidence, and suggested next steps.

• Investigate SQL directly

  Use inspect-debug-queries to search, filter, sort, and page through all, repeated, slow, read, or write queries.

• Reach deeper retained values

  Use get-debug-profile-data to follow returned JSON Pointer paths into nested or derived evidence and read large retained strings in chunks.

• Local clients and bounded responses

  Connect local stdio clients such as Claude Code, Cursor, or VS Code, with paged responses and explicit errors for failed profile processing.

All five MCP tools are read-only and can retrieve only data retained after capture-time redaction and limits.

Bring supported work outside HTTP requests into the same diagnostic interface.

• Artisan command profiles

  Automatically profile supported Artisan command lifecycles with operation name, runtime context, exit code, duration, and captured diagnostics.

• Test-command context

  Recognize the Artisan test command as a test-command profile for captured activity in the profiled process.

• Individual worker-job profiles

  Inspect worker jobs with linked attempt context, supported collector activity, and originating-request relationships through MCP or available browser links.

Test-command profiles are command-level context, not per-test-case tracing or guaranteed capture of child-process activity.

Catch expensive request changes in your Laravel tests.

• Fluent profile assertions

  Build assertions from a supplied profile or a stored profile ID in your existing Laravel tests.

• Query count and time budgets

  Set maximum query count and total query time with assertQueryCountAtMost() and assertQueryTimeAtMost().

• Duration and peak-memory budgets

  Set maximum duration and process peak memory with assertDurationAtMost() and assertPeakMemoryAtMost().

• Repeated-query and N+1 checks

  Assert that repeated query patterns and likely N+1 findings are absent with dedicated assertions.

Stay on the page while you move between requests and the evidence you need.

• Compact toolbar, deep inspector

  Keep request, query, and timing information close at hand, then expand the inspector for detailed evidence.

• Toolbar placement

  Move the toolbar to the top, bottom, or a corner by dragging or using keyboard-accessible commands.

• Light, dark, and system themes

  Choose an appearance and keep that preference saved in the browser.

• Favorites and command palette

  Favorite and reorder sections, or press Command/Ctrl + Shift + P to search sections and available actions.

• Same-page request discovery

  Choose later fetch, XHR, and Livewire profiles without leaving the page, while preserving your choice when background requests arrive.

• Navigation support

  Continue through supported Livewire navigation and follow foreground Inertia visits while keeping partial reloads as background profiles.

• Readable, copyable evidence

  Read highlighted SQL, JSON, HTTP, and PHP, then copy SQL, structured data, or source locations with visible controls.

• Responsive and keyboard-friendly controls

  Use responsive list and detail navigation, focus handling, keyboard controls, and reduced-motion behavior.

• Host-page isolation and recovery

  Keep package assets and themes scoped, adjust around visible host dialogs, and recover toolbar-owned requests from stale CSRF tokens.

The request picker shows profiles discovered on the current page; source controls copy a location.

Start with a complete local debugging experience and inspect the runtime behind it.

• Install and start debugging

  Add the Laravel development dependency with automatic provider registration, local HTML injection, and diagnostic collectors enabled in the local environment.

• Free and open source

  Use the New Debug Bar under the Apache License 2.0.

• Local files, automatic retention

  Store profiles in local files with automatic age and count limits, without a package database migration.

• Runtime and framework context

  Inspect PHP, Laravel, and package versions, runtime type, locale, timezone, debug mode, driver names, and configuration, route, or event cache state.

• Useful local values by default

  Keep local SQL bindings and cache or Redis keys available, with explicit alternative capture policies.

• Adjust the limits that matter

  Publish configuration to change environments, thresholds, storage, retention, and capture limits, with omitted data reported.

• Application lifecycle isolation

  Skip the debugger’s own traffic, reset collector state between lifecycles, and preserve the host response when guarded profiling setup or capture fails.