php dev tools in your browser

Clockwork screenshot

Clockwork is a development tool for PHP available right in your browser. Clockwork gives you an insight into your application runtime - including request data, performance metrics, log entries, database queries, cache queries, redis commands, dispatched events, queued jobs, rendered views and more - for HTTP requests, commands, queue jobs and tests.

Collect the data

Install the Clockwork server-side component via Composer to collect all the metrics.

Includes a first-class Laravel support, easy integration with vanilla or custom apps.

Logomark Layer 1

Debug and profile

Open to view and interact with the collected data.

A browser dev tools extension is also available for Chrome and Firefox.

Safari browser logo image/svg+xml Safari browser logo 03/04/2018 Apple, Inc. CMetalCore firefox-logo

Try it out!

This website has Clockwork enabled. Install the browser extension and refresh the page or try the web interface before using it in your own app.


The timeline gives you a visual representation of your application runtime.

All data collected by Clockwork is shown on the timeline, searchable and filterable by it's kind.

You can also collect your own events.


Log any kind of data from a simple string to a complex object via the clock() helper.

Objects and arrays are shown as an interactive tree structure, each message also includes a stack trace.

Messages from your standard app log will also be shown.

Database queries & more

Get an insight into what is your app doing with all kinds of collected data, all searchable with stack traces.

Toggle each feature in the config file and set a number of advanced options, like marking of slow or duplicate database queries.

User data & extensibility

Add your own tabs, like a cart tab showing cart contents in an e-commerce app.

Extend Clockwork with new data sources, framework integrations or use the Clockwork REST api and metadata format in your own tools.

Xdebug profiler

Get even more detailed performance metrics with our full-featured Xdebug profile viewer.

After a simple setup, you can toggle collecting profiles right from the Clockwork app.


Sharing lets you upload the metadata to a Clockwork share service and gives you a public link to share with others.

The share service is free to use, click on the share button in the sidebar to start.

New in 5.0

Commands, queue jobs & tests

Clockwork now supports multiple request types besides HTTP requests - commands, queue jobs and tests.

All features are supported, take a look at what database queries were run by your queue job or find out why is your unit test failing, making TDD much easier.

Client-metrics and Web Vitals

Clockwork helps you to keep your server-side performance in check. Optimizing the backend is just half of the battle though.

Clockwork can also collect client-side performance metrics. Supported are both navigation timings and Web Vitals.

Collecting these metrics requires installing a tiny javascript component.

New in 5.0


Clockwork gives you an option to show basic request information in the form of a toolbar in your app. Clicking on the blue button will show full details in the Clockwork app.

The toolbar is entirely rendered client-side with a tiny javascript component.

New in 5.0


Install the Clockwork library via Composer.

$ composer require itsgoingd/clockwork

Congratulations, you are done! To enable more features like commands or queue jobs profiling, publish the configuration file via the vendor:publish Artisan command.

Note: If you are using the Laravel route cache, you will need to refresh it using the route:cache Artisan command.

Old Laravel

For Laravel versions older than 5.5, you'll need to register the service provider, in your config/app.php:

'providers' => [   ...   Clockwork\Support\Laravel\ClockworkServiceProvider::class ]

If you'd like to use the Facade, add following to your config/app.php:

'aliases' => [   ...   'Clockwork' => Clockwork\Support\Laravel\Facade::class, ]


Install the Clockwork library via Composer.

$ composer require itsgoingd/clockwork

Once Clockwork is installed, you need to register the Clockwork service provider, in your bootstrap/app.php:


To enable more features like commands or queue jobs profiling use enviroment variables, see full list of available settings.

Note: For collecting database queries you'll need to enable $app->withEloquent() in bootstrap/app.php, this has no performance impact if your app executes database queries on most requests.


Install the Clockwork library via Composer.

$ composer require itsgoingd/clockwork

Initialize Clockwork early in your application.

$clockwork = Clockwork\Support\Vanilla\Clockwork::init();

If you are using a dependency injection container it might be a good idea register the Clockwork instance.

Right before sending a response, we need to tell Clockwork to resolve and store metadata for current request.


We also need to setup a Clockwork REST API endpoint. This endpoint is used by the Clockwork clients to load metadata for your application requests.

By default Clockwork clients expect the data at /__clockwork URI. If your application uses a router, you can simply setup a GET route for this URI and pass rest of the URL to Clockwork.

$router->get('/__clockwork/{request:.+}', function ($request) {   $clockwork = Clockwork\Support\Vanilla\Clockwork::init();     return new JsonResponse($clockwork->getMetadata($request)); }};

In a very simple app without router you can use a separate script. In this case we will also need to tell Clockwork where to load the data from using the api option.

// clockwork.php $clockwork = Clockwork\Support\Vanilla\Clockwork::init([ 'api' => '/clockwork.php?request=' ]); $clockwork->handleMetadata();

In the first example we used the getMetadata method which returns the metadata as an array, the returnMetadata will also json-ecncode the data, send it to output and set appropriate headers.

PSR-7 applications

Clockwork support in a PSR-7 application can be implemented as a middleware.

return $clockwork->usePsrMessage($request, $response)->requestProcessed();

In this case Clockwork will use the data from the PSR-7 request and return the PSR-7 response extended with Clockwork headers.


The vanilla Clockwork integration can be configured by passing a configuration array to the init method.

$clockwork = Clockwork\Support\Vanilla\Clockwork::init([   'storage_files_path' => __DIR__ . '/storage/clockwork' ]);

You can find the full list of options with descriptions in the configuration file.

You can also configure most options via environment variables, in this case you don't have to pass them to the init method.

The clock helper

Clockwork includes a clock global helper function providing easy access to Clockwork features from anywhere in the app.

The clock helper is disabled by default in the vanilla integration, to enable the helper, use the register_helpers option.

$clockwork = Clockwork\Support\Vanilla\Clockwork::init([ 'register_helpers' => true ]); clock('Log', 'something'); clock()->addDatabaseQuery('SELECT * FROM users WHERE id = 1', [], 10);

Registering database queries

There are many ways to make database queries in a vanilla PHP application. That's why unlike a framework integration, it's up to you to register the executed database queries.

To do so, you can use the Clockwork addDatabaseQuery method in your database abstraction layer. If you don't have one, you can write a simple helper function or class for making queries, eg. this helper function for executing queries using PDO and logging them to Clockwork.

function database_query($pdo, $query, $bindings) {   $time = microtime(true);     $stmt = $pdo->prepare($query);   $stmt->execute($bindings);     $results = $stmt->fetchAll();     clock()->addDatabaseQuery($query, $bindings, (microtime(true) - $time) * 1000);     return $results; }

You can use a similar approach to logging cache queries, events, sent emails, etc. see the source of the main Clockwork class for a list of all available methods.

Web interface

The Clockwork library contains an optional web interface for interacting with the collected data that can be used instead of the browser extension.

To serve the web app the vanilla integration contains a Clockwork::returnWeb api, which copies the web app assets to a publicly accessible path on the first use. You will also need to enable the web UI in the configuration, set the publicly accessible path where the assets will be copied and the uri where this path is accessible.

Note, the assets are not automatically updated, you should manually remove the assets when updating Clockwork so a new version could be installed.

If your application uses a router, you can set up a GET route calling this api, in this example we use a PSR-7 compatible router.

$router->get('/clockwork', function ($request) {   $clockwork = Clockwork\Support\Vanilla\Clockwork::init([   'web' => [   'enable' => true,   'path' => DIR . '/public/vendor/clockwork',   'uri' => '/vendor/clockwork'   ]   ]);     return $clockwork->usePsrMessage($request, new Response)->returnWeb(); }};

In a very simple app without router you can use a separate script.

// clockwork-web.php   $clockwork = Clockwork\Support\Vanilla\Clockwork::init([   'api' => '/clockwork.php?request=',   'web' => [   'enable' => true,   'path' => DIR . '/vendor/clockwork',   'uri' => '/vendor/clockwork'   ] ]);   $clockwork->returnWeb();


Install the Clockwork library via Composer.

$ composer require itsgoingd/clockwork

Once Clockwork is installed, you need to register the Clockwork bundle in config/bundles.php:

return [   ...   Clockwork\Support\Symfony\ClockworkBundle::class => ['dev' => true] ]

Clockwork routes also need to be registered in config/routes.yaml:

clockwork:   resource: '@ClockworkBundle/Resources/config/routing/clockwork.php'

Clockwork uses the Symfony profiler as the data provider, make sure it is enabled:

framework:   profiler: { collect: true }

Note: Symfony integration uses the built-in Symfony profiler. This means we can only show the same information as the Symfony Web Profiler, other Clockwork features are not available.


Install the Clockwork library via Composer.

$ composer require itsgoingd/clockwork

Once Clockwork is installed, you'll need to add the Slim middleware to your app, specifying the path for the Clockwork metadata:

$app = AppFactory::create(); $app->add(new Clockwork\Support\Slim\ClockworkMiddleware($app, __DIR__ . '/storage/clockwork'));

Slim 3 is also supported:

$app = new Slim\App(...); $app->add(new Clockwork\Support\Slim\Legacy\ClockworkMiddleware(__DIR__ . '/storage/clockwork'));

Slim 2 is also supported:

$app = new Slim(...); $app->add(new Clockwork\Support\Slim\Old\ClockworkMiddleware(__DIR__ . '/storage/clockwork'));

Upgrade guide


Estimated upgrade time: 0 to 10 minutes

Config file

The Clockwork config file contains multiple changes. Please review and re-publish the config file.

Required PHP version

The minimum required PHP version is now 5.6, previously 5.5. If you can't upgrade, you can use Clockwork 4 indefinetly.

Timeline api

The timeline api was completely reworked, please see the "timeline" section in documentation for details.

In general, the old calls can be easily converted to the new api, eg.:

clock()->startEvent('twitter-api-call', "Loading user's latest tweets via Twitter API");     ... clock()->endEvent('twitter-api-call');

clock()->event("Loading user's latest tweets via Twitter API")->start();     ... clock()->event("Loading user's latest tweets via Twitter API")->end();

Global log and timeline instances

The global log and timeline instances were moved to the request instance.

// old api $log = clock()->getLog();   // new api $log = clock()->getRequest()->log();

Request's log and timelineData attributes should never be manually modified in custom data sources, the log or timeline instances should be used instead, eg.:

// old api $request->log = array_merge($request->log, $localLog->toArray());   // new api $request->log()->merge($localLog);

The clockwork.log and Clockwork\Request\Log::class are no longer registered in Laravel container.

The clockwork.controller.start and clockwork.controller.end events are no longer used and can be removed.

Central Clockwork class api

Central Clockwork class getters and setters are replaced with a single unified methods, eg. getRequest() -> request(), setRequest($request) -> request($request).

Old getters and setters are still available but deprecated.

Removed deprecated Clockwork::subrequest() method, use Clockwork::addSubrequest().

Slim 4 support

Slim 4 support has been added, original middleware namespaces were changed.

use Clockwork\Support\Slim\ClockworkMiddleware; // for Slim 4 use Clockwork\Support\Slim\Legacy\ClockworkMiddleware; // for Slim 3 use Clockwork\Support\Slim\Old\ClockworkMiddleware; // for Slim 2

See also the Slim installation section in the documentation.


Collecting data

The Clockwork server-side component collects and stores data about your application.

Clockwork is only active when your app is in debug mode and running on a local domain - localhost, .local, .test, .wip and - by default. You can choose to explicitly enable or disable Clockwork, or even set Clockwork to always collect data without exposing them for further analysis.

We collect a whole bunch of useful data by default, but you can enable more features or disable features you don't need in the config file.

Some features might allow for advanced options, eg. for database queries you can set a slow query threshold or enable detecting of duplicate (N+1) queries. Check out the config file to see all what Clockwork can do.

There are several options that allow you to choose for which requests Clockwork is active.

On-demand mode will collect data only when Clockwork app is open. You can even specify a secret to be set in the app settings to collect request. Errors only will record only requests ending with 4xx and 5xx responses. Slow only will collect only requests with responses above the set slow threshold. You can also filter the collected and recorded requests by a custom closure. CORS pre-flight requests will not be collected by default.

New in Clockwork 4.1, artisan commands, queue jobs and tests can now also be collected, you need to enable this in the config file.

Clockwork also collects stack traces for data like log messages or database queries. Last 10 frames of the trace are collected by default. You can change the frames limit or disable this feature in the configuration file.

Artisan commands

Clockwork supports collecting data about executed Artisan commands with optional support for collecting the command output. This is disabled by default and needs to be enabled in the config file.

Queue jobs

Clockwork supports collecting data about executed queue jobs with support for both the default Laravel queue worker and Laravel Horizon. This is disabled by default and needs to be enabled in the config file.


Clockwork supports collecting data about ran tests with support for the default Laravel PHPUnit or Pest testing setup. This is disabled by default and needs to be enabled in the config file.

PHPUnit 10 or Pest

To collect data about executed tests, you also need to register a Clockwork PHPUnit extension. Add following to your phpunit.xml:

<extensions> <bootstrap class="Clockwork\Support\Laravel\Tests\ClockworkExtension" /> </extensions>

PHPUnit 9 or older

To collect data about executed tests, you also need to add and boot a Clockwork testing trait in your tests/TestCase.php:

use Clockwork\Support\Laravel\Tests\UsesClockwork;   abstract class TestCase extends BaseTestCase {   use CreatesApplication, RefreshDatabase, UsesClockwork;     protected function setUp() :void   {   parent::setUp();   $this->setUpClockwork();   } }

Viewing data

Web interface

Open to view and interact with the collected data.

The app will show all executed requests, which is useful when the request is not made by browser, but for example a mobile application you are developing an API for.

Browser extension

A browser dev tools extension is also available for Chrome and Firefox:


Clockwork now gives you an option to show basic request information in the form of a toolbar in your app.

The toolbar is fully rendered client-side and requires installing a tiny javascript library.

Use the following script tag to load the library from cdn:

<script src=""></script>

The cdn builds are transpiled to support all browsers with more than 1% market share. The cdn bundle sizes are 7.11K for metrics.js and 24.2K for toolbar.js.

Alternatively, you can install the library via npm:

npm install clockwork-browser

And import into your javascript bundle, no further configuration needed:

import 'clockwork-browser/toolbar'

The toolbar implementation uses cookies, if your website can't use cookies you might want to disable this feature.


You can log any variable via the clock() helper, from a simple string to an array or object, even multiple values:

clock(User::first(), auth()->user(), $username)

The clock() helper function returns it's first argument, so you can easily add inline debugging statements to your code:


If you want to specify a log level, you can use the long-form call:

clock()->info("User {$username} logged in!")

You can add a context to the log message via the second argument, serializer options can be passed in the context array:

clock()->info("Trace this message!", [ 'trace' => true ])

You can use the performance option to make the log message appear in the performance tab.

clock()->info("Api request {$method} {$uri}, took too long! ({$time})", [ 'performance' => true ])

All data logged using the standard Laravel log methods will also be collected.


Timeline gives you a visual representation of your application runtime.

To add an event to the timeline - start it with a description, execute the tracked code and finish the event. A fluent api is available to further configure the event.

// using timeline api with begin/end and fluent configuration clock()->event('Importing tweets')->color('purple')->begin(); ... clock()->event('Importing tweets')->end();

Alternatively you can execute the tracked code block as a closure. You can also choose to use an array based configuration instead of the fluent api.

// using timeline api with run and array-based configuration clock()->event('Updating cache', [ 'color' => 'green' ])->run(function () {     ... });

Events have an optional unique name in case the description is not unique.

foreach ($users as $i => $user) {     clock()->event('Importing tweets')->name("importing-tweets-{$i}")->begin();     ...     clock()->event("importing-tweets-{$i}")->end(); }

All possible event properties are - description, name, start, end, duration, color and data.

// manually adding event with start and end time clock()->event('Importing tweets')     ->start($startTime)     ->end($endTime)     ->color('purple');

// manually adding event with start time and duration (in ms) clock()->event('Updating cache')     ->start($startTime)     ->duration($durationMs)     ->color('green');


Clockwork helps you to keep your server-side performance in check. Optimizing the backend is just half of the battle though. Javascript processing can still make your application feel sluggish. Fortunately we have some great web performance intiatives like Web Vitals and browser apis to help us measure how are we doing on this front.

With Clockwork 5 you are now be able to collect these client-side performance metrics. Supported are both navigation timings (like how long it took for the DOM interactive or complete event) and Web Vitals. You will find the collected metrics in a new client-side section in the performance tab.

Collecting client-side metrics requires installing a tiny javascript library.

Use the following script tag to load the library from cdn:

<script src=""></script>

The cdn builds are transpiled to support all browsers with more than 1% market share. The cdn bundle sizes are 7.11K for metrics.js and 24.2K for toolbar.js.

Alternatively, you can install the library via npm:

npm install clockwork-browser

And import into your javascript bundle, no further configuration needed:

import 'clockwork-browser/metrics'

The metrics implementation uses cookies, if your website can't use cookies you might want to disable this feature.


Sharing a request uploads the metadata to a Clockwork share service and gives you a public link to share with others. On this link you will find a fully working Clockwork app showing the request you shared. Append .png to the url and you will get a screenshot of the performance tab you can easily embed to a GitHub issue. You can also choose to share only part of the request, like the database tab.

The share service is free to use. The shared data is hosted on DigitalOcean servers and will never be shared with third-parties. Old shares will be purged form time to time. You can also delete the shared requests manually at any time.

Sometimes you might just want to link to a request on your own Clockwork instance. You will find that the request id on the bottom of the sidebar now links to the current request.

User data

While you can log anything using the rich logging capabilities or add custom timeline events, sometimes your app has a specific data you'd like to be easily accessible for each request.

With user data you can add custom data, shown as a new tab in the Clockwork app, formatted as a table or as counters (similar to performance tab).

Let's say we are building an eshop app. Instead of logging the cart contents and looking for them in the log tab, we can make a new "Cart" tab which will show some stats and the cart contents:

$cart = clock()->userData('cart')   ->title('Cart');   $cart->counters([   'Products' => 3,   'Value' => '949.80€' ]);   $cart->table('Products', [   [ 'Product' => 'iPad Pro 10.5" 256G Silver', 'Price' => '849 €' ],   [ 'Product' => 'Smart Cover iPad Pro 10.5 White', 'Price' => '61.90 €' ],   [ 'Product' => 'Apple Lightning to USB 3 Camera Adapter', 'Price' => '38.90 €' ] ]);

We are using static data for demonstration, in a real implementation the data would come from a database or session based on your cart implementation.



Clockwork collects a lot of sensitive data. Typically you will run Clockwork only in your local development environment where this is not an issue. In some cases though, you might have a shared development or staging server.

For these situations Clockwork comes with a simple authentication using a single shared password. To use authentication, enable it and set a password in the Clockwork configuration file.

The authentication system is extensible, to see how to add your own authentication methods see the "extending authentication" section.

It is still not recommended to run Clockwork in production or environments that might contain sensitive customer data. Please make sure you understand the details of the authentication implementation if you plan to use it in a sensitive environment.

Metadata storage

Clockwork stores the collected data in a persistent manner.

The old data is automatically cleaned up after a specified cleanup interval, 30 days by default.

By default we store the metadata in a flat JSON file storage, located at storage/clockwork. This is both simple and fast storage and doesn't require any particular PHP extensions.

Clockwork also includes an SQL storage implementation. SQL storage works great with a simple Sqlite database, but also supports MySQL and PostgreSQL. This can also be useful in a case where you need to use the collected metadata outside of Clockwork, eg. you could build an admin UI showing all requests to your application.

Another option is a Redis storage implementation, especially useful in cloud scenarios with no persistent file-system or SQL database available.

You can also extend Clockwork with your own metadata storage implementation, to learn how to do so, check out the "extending metadata storage".

Xdebug profiler

While Clockwork provides a lot of performance metrics and profiling features like timeline events, finding the problematic spot in your application can still be hard. Xdebug is a PHP extension, which provides an advanced profiler, collecting metrics about every single function call. Clockwork comes with a full-featured Xdebug profiler UI, you can find it in the performance tab.

The profiler UI will show you a breakdown of all function calls with their self and inclusive cost. You can toggle between execution time or memory usage metrics, exact or pecentual representation and of course the data is orderable and filterable.


Install the Xdebug extension via PECL (part of your PHP installation):

$ pecl install xdebug

Enable the PHP extension in your php.ini (location of php.ini and the xdebug extension path will depend on your operating system):


Now we need to enable the Xdebug profiler itself. You could enable the profiling for all requests, but collecting Xdebug profiles slows down the response time dramatically. That's why it's a good idea to enable Xdebug profiling only for certain requests. To do so, add following setting to your php.ini and you will be able to toggle whether Xdebug profiles should be collected in Clockwork profiler UI itself:

; Xdebug 3 xdebug.mode = profile xdebug.start_with_request = trigger   ; Xdebug 2 xdebug.profiler_enable_trigger = 1

For more detailed information about installation and other awesome Xdebug features, check out the Xdebug website.



This section describes how Clockwork internals work. While not needed for normal usage, this can be useful if you are planning on extending Clockwork with custom data sources, storage implementations, adding more in-depth support for your custom applications or unsupported frameworks or even writing a custom Clockwork client apps.

Clockwork consists of two components:

  • server-side library - responsible for collecting the data and exposing it to the clients
  • client application - responsible for presenting the collected data to the user

The communication between the two components happens via a rest-like HTTP API using JSON metadata format.

Server-side library

The Clockwork server-side library consists of several components:

  • DataSources - classes responsible for the metadata collection itself
  • Request - data objects for storing the metadata
  • Storage - classes responsible for persisting and retrieving the metadata
  • Support - various supporting files for frameworks and libraries, like service providers, middleware, etc.

Clockwork also has a main Clockwork class that ties everything together and includes bunch of helper methods.

While different Clockwork integrations work in different ways a typical usage looks like this:

  • a new request is received by the application
  • main Clockwork class is instantiated, this automatically creates new Request instance for holding the metadata
  • one or more data sources are added to the Clockwork instance via $clockwork->addDataSource calls
  • a storage class is instantiated and set on the Clockwork instance via $clockwork->setStorage call
  • application runs
  • $clockwork->resolveRequest is called, causing Request object to pass through resolve method on all configured data sources, each adding relevant data to the Request instance
  • $clockwork->storeRequest is called, persisting the Request object via set storage implementation
  • X-Clockwork-Version and X-Clockwork-Id headers are set on the response

Check out the "extending data sources" and "extending metadata storage" for information on writing your custom data sources and storage implementations.

Metadata HTTP API

The metadata HTTP API is the glue between the server-side data collecting library and the application presenting the data. By having a well specified rest-like API we can keep different versions of the Clockwork applications and the server-side library compatible and you could event write a fully custom Clockwork application compatible with the official server-side or vice-versa.

/__clockwork/{id} is the main and most important API endpoint. Application requests metadata about request identified by a particular ID, server-side returns the metadata in a JSON format.

While this is the only endpoint that is really required for the browser extensions to work and was the only endpoint available in the first version, there is a couple more endpoints required for various application features.

/__clockwork/latest returns the metadata about the last executed request. Used in extension to show the last request when first time opened and required for web UI.

/__clockwork/{id}|latest/next/{limit?} returns metadata for requests executed after request with specified ID or the latest request, with an optional limit. Required for the web UI.

/__clockwork/{id}|latest/previous/{limit?} returns metadata for requests executed before request with specified ID or the latest request, with an optional limit. Used to load older requests in applications.

Browser extension

The browser extension checks HTTP responses for the X-Clockwork-Version and X-Clockwork-Id headers. The X-Clockwork-Version header contains the version of the server-side component, while the header is required, the content is not important and is used only for new version notifications. More important is the X-Clockwork-Id which contains the unique identifier for the current HTTP request.

Once a request containing both of these headers is received, Clockwork retrieves the request metadata via a HTTP GET request to /__clockwork/{ID}. The metadata endpoint URI can be overridden via a X-Clockwork-Path header, if present, the request ID will be appended to the end of the header value. This endpoint should return the request metadata in the Clockwork metadata format.

Web UI

The web UI uses the same code as the browser extension, with only difference in the metadata retrieval. As we are not running as a browser extension and can't observe all executed HTTP requests, we use ajax polling instead.

When opened, the application makes a request to the /__clockwork/latest endpoint to load the latest request. After that we poll the /__clockwork/{id}/next endpoint with the last request id to get all newer requests.

Data sources

Data sources are a pattern for collecting the metadata in an extensible way in the Clockwork server-side library. Each data source collects data about a particular topic, eg. a PhpDataSource, LaravelDataSource, or DoctrineDataSource.

Creating a new data source is as simple as creating a class implementing the Clockwork\DataSource\DataSourceInterface interface. Though instead of implementing the interface we recommend extending the Clockwork\DataSource\DataSource base class, which will make you compliant with future interface changes.

You need to implement a single resolve(Request $request) method that will receive the Request data object and extends it with your custom data.

For example, our application uses a custom session implementation, let's create a data source that adds the session data to Clockwork:

use Clockwork\DataSource\DataSource; use Clockwork\Helpers\Request;   class SessionDataSource extends DataSource {   public function resolve(Request $request)   {   $request->session = session()->all();   } }

To use the new data source we need to register it with the main Clockwork class:

clock()->addDataSource(new SessionDataSource);

For more inspiration take a look at the existing data sources included in Clockwork.

Metadata storage

Clockwork stores the collected data in a persistent manner.

By default we use a flat JSON file storage implementation and we also include an optional SQL storage implementation. To learn how to use included implementation see the "advanced metadata storage" section.

While in most cases you will want to use one of the included options, you can write a custom one (eg. using Redis or unsupported SQL database).

To create a storage implementation you will need to implement the Clockwork\Storage\StorageInterface interface, though it's recommended to extend the Clockwork\Storage\Storage base class instead.

The interface contains a bunch of methods for reading requests, a save and a cleanup method. All read methods should return either single or an array of Clockwork\Helpers\Request instances.

  • all() returns all stored requests
  • find($id) returns a single request with specified ID or null
  • latest() returns a single latest request or null
  • previous($id, $count = null) returns an array of requests received before specified ID, optionally limited to specified count
  • next($id, $count = null) returns an array of requests received after specified ID, optionally limited to specified count
  • store(Request $request) store the request
  • cleanup() clean up old requests, the algorithm is up to you

To use the custom storage implementation we need to set it on the main Clockwork class:

clock()->setStorage(new RedisStorage);

Feel free to take a look at existing storage implementations for inspiration.


The authentication in Clockwork works very simple. Each metadata request contains an authentication token, which is passed to the authenticator to decide whether we should return the metadata. If the Clockwork app receives a forbidden response, it will assume an authentication is required and asks for username, password or both as required by the authenticator. Submitting this form will make an authentication attempt on authenticator which will return a new authentication token when successful.

To create an authenticator implementation you will need to implement the Clockwork\Authentication\AuthenticatorInterface interface.

  • attempt(array $credentials) receives an array of credentials (username, password or both), if the credentials are valid, returns an authentication token, returns null for invalid credentials
  • check($token) receives an authentication token, returns true if the token is valid
  • requires() returns an array of required credentials, this will be either AuthenticatorInterface::REQUIRES_USERNAME or AuthenticatorInterface::REQUIRES_PASSWORD, the Clockwork app will then show one or both fields

To use the custom authenticator we need to set it on the main Clockwork class:

clock()->setAuthenticator(new EloquentAuthenticator);

Feel free to take a look at existing authenticator implementations for inspiration.


Here you can find various 3rd party extensions, clients and projects with Clockwork support.

Clockwork libraries

Clockwork clients

Alternative implementations

Projects with Clockwork support

  • Laravel Debugbar - integrates PHP Debug Bar for Laravel, includes Clockwork support
  • Laravel Doctrine - a drop-in Doctrine2 implementation for Laravel 5+, includes Clockwork support

Did you make your own Clockwork related project? Let us know at


Installation and some updates of the Clockwork browser extension require some privacy permissions.

Since our browsers handle a lot of personal information, we feel it's important to explain what we can do with each permission and why do we need them.

Permission to "Read your browsing history"

Clockwork uses the webNavigation API, used to detect navigation events, eg. entering URLs to address bar, clicking links, etc.

Used for the preserve log feature. When preserve log is off, we use this API to know when to clear the requests list.

Clockwork also uses the tabs API, used for interacting with open browser tabs.

Used for retrieving current page URL required for setting up metadata requests and Xdebug profiler cookies.

Permission to "Read and change all your data on the websites you visit"

Clockwork uses the webRequest API, used for observing HTTP requests made by the browser, including submitted data, URLs, full response content, with ability to block or modify these requests.

Used for observing incoming HTTP requests for Clockwork-enabled applications and loading Clockwork metadata from headers.

We immediately disregard any requests to non Clockwork-enabled applications, we never modify or store requests.

The extension available in the Chrome Web Store or Firefox Addons is always the latest tagged commit with no modifications.


5.2 21 Feb 2024

  • added new security protection - running Clockwork is now restricted to local domains unless explicitly enabled
  • added Redis storage implementation (implemented by christopherh0rn, thanks!)
  • added support for collecting tests with Pest 2 and PHPUnit 10 (reported by CadenP, idea by kdevan, thanks!)
  • added support for all Twig versions in the Twig profiler integration (idea by ericktucto, thanks!)
  • improved collecting of notifications in Laravel to support latest version of laravel/slack-notification-channel (implemented by maximepvrt, thanks!)
  • improved Laravel installation process to be able to use "clockwork" tag for publishing the config file
  • improved default Laravel config to ignore Telescope Toolbar requests by default (implemented by lloricode, thanks!)
  • improved Eloquent data source to support Crate PDO (implemented by JulianMar, thanks!)
  • improved Slim integration to support retrieving latest requests in the rest api (implemented by UlrichEckhardt, thanks!)
  • fixed compatibility with Laravel
  • fixed compatibility with Laravel 5.6 when client-metrics or toolbar is enabled (reported by Smolinsky, thanks!)
  • fixed checking of notification type when collecting Laravel notifications (reported by faraweilyas, idea by jameshulse, thanks!)
  • fixed collecting of Slack notifications content in Laravel (implemented by maximepvrt, thanks!)
  • fixed collecting of Laravel cache expiration times (implemented by FeBe95, thanks!)
  • fixed ability to use custom should-collect and should-record callbacks (implemented by thattomperson, thanks!)
  • fixed a possible crash with SQL storage when creating backup table or inserting duplicate ids (reported by davidp-celtra, thanks!)
  • fixed an exception being thrown when Clockwork metadata path is not writable even when Clockwork was disabled (reported by joelharkes, thanks!)
  • fixed an issue with file storage causing some non-http requests might not be shown in the app (reported by mattvb91, thanks!)
  • fixed compatibility with using Filebeat to collect Clockwork metadata (implemented by JConseil, thanks!)
  • fixed Request::addModelAction method not storing the action properly (reported by UlrichEckhardt, thanks!)
  • Running Clockwork is now restricted to local domains - localhost, local, test, wip and - unless explicitly enabled. If you want to use Clockwork on a different domain, please explicitly enable it by setting `CLOCKWORK_ENABLE` to true.

5.1.12 13 Dec 2022

  • improved Timeline event run method to stop the event in case of an exception (implemented by UlrichEckhardt, thanks!)
  • fixed some deprecation warnings on PHP 8.2 (implemented by faytekin, thanks!)
  • fixed some deprecation warnings on PHP 8.1 (implemented by villermen, thanks!)

5.1.11 02 Nov 2022

  • fixed crash when resolving authenticated user in Laravel without using Eloquent (reported by m-thalmann-athesia, thanks!)

5.1.10 19 Oct 2022

  • fixed crash when resolving authenticated user in Laravel (reported by LucaRed, thanks!)

5.1.9 19 Oct 2022

  • added support for Eloquent strict mode (reported by Sergiobop, thanks!)

5.1.8 25 Sep 2022

  • updated list of built-in Laravel commands to ignore when collecting commands and included Horizon commands
  • fixed collecting of Laravel queue jobs when used with Horizon
  • fixed collecting of authanticated user name when the User model includes name() method (implemented by devfrey, thanks!)

5.1.7 14 Aug 2022

  • added support for authentiaction in the Vanilla integration
  • added support for compressed Xdebug profiles
  • improved collecting of Laravel Artisan commands to support abbreviated commands (implemented by mike-peters90, thanks!)
  • fixed doubled backslashes in collected Laravel database query bindings (reported by pys1992, thanks!)
  • fixed compatibility with PostgreSQL in SQL storage (implemented by screw, thanks!)
  • fixed possible crash during file storage cleanup when used with Laravel Octane (reported by flexchar, thanks!)
  • fixed infinite loop when collecting queries in Doctrine 3.x (reported by N-M, thanks!)

5.1.6 12 Apr 2022

  • added Monolog 2.x compatible handler (idea by mahagr, thanks!)
  • improved log to handle all Throwable classes as exceptions (idea by EdmondDantes, thanks!)
  • fixed support for capturing console output in Laravel 9 (reported by mikerockett, thanks!)

5.1.5 13 Feb 2022

  • removed support for psr/log
  • fixed some typos (implemented by fridzema, thanks!)
  • `Clockwork\Request\Log` no longer implements the PSR log interface, it is unlikely you are using this class directly

5.1.4 30 Jan 2022

  • added Laravel 9 support
  • added support for manually registering Clockwork middleware in Laravel
  • fixed some failing tests might not been collected in Laravel (reported by ajcastro, thanks!)
  • fixed not respecting the collect tests setting in Laravel (reported by SimBig, thanks!)
  • fixed some deprecation warnings on PHP 8.1 (implemented by usernotnull, thanks!)

5.1.3 24 Dec 2021

  • added PSR to the default filtered namespaces from stack traces in the Laravel integration
  • fixed not being able to log non-string values when using psr/log >=2.0 (reported by Wit3, thanks!)
  • fixed some deprecation warnings on PHP 8.1 (reported by Pinnokkio, thanks!)
  • fixed wrong redirect when accessing web ui with an url including a trailing slash (implemented by ssnepenthe, thanks!)
  • fixed update-token could be leaked via the Clockwork rest api (implemented by ssnepenthe, thanks!)

5.1.2 07 Dec 2021

  • fixed some deprecation warnings on PHP 8.1 (reported by Codomic, thanks!)

5.1.1 01 Nov 2021

  • added support for psr/log 2.0 (used in recent Laravel versions) (implemented by byGits, thanks!)
  • improved timeline api event run method to return the return value of passed closure
  • improved collecting Laravel database queries to not quote integers (implemented by thisiskj, thanks!)
  • improved toolbar details link to always be absolute and work with subdirectories (reported by superDuperCyberTechno, thanks!)
  • fixed some depecation warnings on PHP 8.1 (implemented by gharlan, thanks!)
  • fixed collecting Laravel database queries to produce correct queries when bindings contain question marks (reported by woshixiaobai, thanks!)
  • fixed filtering collected and recorded requests by closure (implemented by ssnepenthe, thanks!)
  • fixed some inconsistencies in the Clockwork metadata api
  • fixed some web UI assets being server with wrong mime-types (implemented by ssnepenthe, thanks!)
  • fixed missing method on storage interface and missing default parameter value in sql storage (implemented by ssnepenthe, thanks!)
  • timeline api event run method now returns the return value of passed closure instead of the event instance

5.1 07 Aug 2021

  • Read Clockwork 5.1 released with database queries highlighting and more on blog
  • added initial support for Laravel Octane
  • added support for Web UI in the vanilla integration
  • added support for collecting Laravel cache queries without values (implemented by akalongman, thanks!)
  • added ability to filter Laravel routes from particular namespaces (idea by hailwood, thanks!)
  • improved collecting of request URL to include full URL including the query string
  • improved Clockwork Browser payload to include Web UI path
  • updated Clockwork App (5.1)
  • fixed logging falsy values via Clockwork::log (reported by Karmalakas, thanks!)
  • fixed PHP 8 incompatibility when processing some Laravel notifications (implemented by nanaya, thanks!)
  • fixed request body being collected even when already parsed into POST data
  • fixed collecting request URLs with non-standard ports

5.0.8 27 Apr 2021

  • fixed crash when collecting Laravel mailables built via MailMessage (implemented by cbl, thanks!)
  • fixed crash when collecting artisan command in Lumen (reported by 2Attack, thanks!)
  • fixed crash when collecting database queries in Laravel with connection implementation not using PDO (implemented by lenssoft, thanks!)
  • fixed crash when HTTP request body contains valid json which does not contain array (eg. a number) (reported by Mradxz, thanks!)
  • fixed collected jobs dispatched from other jobs not having a correct parent job set (implemented by josvar, thanks!)

5.0.7 14 Mar 2021

  • changed delay listening to events until the app is booted (improves comatibility with some other packages)
  • changed default settings to enable toolbar (separately installed component)
  • changed default except requests filter to include debugbar api (implemented by edgardmessias, thanks!)
  • fixed wrong type-hint for the timeline event run method (reported by hferradj, thanks!)
  • fixed on-demand mode not working in Laravel (reported by yemenifree, thanks!)
  • fixed crash when collecting Laravel notifications with recipient names (reported by iainheng, thanks!)
  • fixed possible crashes and other issues when collecting Laravel notifications (reported by beekmanbv, thanks!)
  • fixed crash when creating runnable queries in DBAL data source (implemented by N-M, thanks!)

5.0.6 27 Dec 2020

  • fixed vanilla integration overriding other cookies when used with a PSR-7 response (reported by leemason, thanks!)

5.0.5 21 Dec 2020

  • added support for toolbar in the vanilla integration (idea by reeslo, thanks!)
  • added support for client metrics in the vanilla integration
  • improved PSR-7 support in the vanilla integration
  • fixed toolbar might not work when not collecting database models
  • fixed crash collecting Slack and Nexmo notifications (reported by abalozz, thanks!)
  • fixed timeline api usage not being updated in the Slim integration leading to crash (reported by jiaojie1989, implemented by seanhamlin, thanks!)
  • fixed api path being interpreted as regex in the vanilla integration (implemented by pqr, thanks!)
  • fixed Symfony storage not being updated for latest storage api (implemented by auchanhub, thanks!)

5.0.4 01 Dec 2020

  • fixed Lumen integration crash (implemented by alexbegoon, thanks!)
  • fixed PHP 5.6 incompatibility (implemented by sanis, thanks!)

5.0.3 30 Nov 2020

  • fixed PHP 8.0 incompatibility in log (implemented by mtorromeo, thanks!)

5.0.2 24 Nov 2020

  • updated Clockwork App (5.0.2)
  • fixed data sources not being initialized for extended data requests (reported by tmishutin, thanks!)
  • fixed inconsistent handling of time and duration arguments in various Request::add* methods (reported by mahagr, thanks!)

5.0.1 22 Nov 2020

  • updated Clockwork App (5.0.1)
  • fixed performance issues related to collecting stack traces for Eloquent models actions (reported by mstaack, thanks!)
  • fixed collecting database and unsupported Laravel notifications (implemented by YannikFirre, thanks!)
  • fixed log and timeline sorting leading to invalid metadata format

5.0 15 Nov 2020

  • Read Clockwork 5.0 released with client-side metrics, toolbar and more on blog
  • added collecting of client-metrics and web-vitals
  • added collecting of Eloquent models actions and retrieved, created, updated and deleted models counts
  • added collecting of Laravel notifications
  • added reworked timeline api
  • added configurable web ui path (default changed to /clockwork)
  • added toolbar support
  • added on-demand mode (with optional secret)
  • added option to collect error requests only (requests with 4xx and 5xx responses)
  • added option to specify slow threshold and collect slow requests only
  • added option to sample collected requests (collect only 1 in x requests)
  • added option to collect only specified urls
  • added option to not collect pre-flight requests (enabled by default)
  • added option to filter collected and recorded requests by closure
  • added Laravel controller timeline event
  • added support for updating existing requests
  • added Slim 4 support
  • updated to Clockwork App 5.0
  • improved reworked the central Clockwork class api
  • improved requests recording to use a terminate callback
  • improved global log instance to live on the request instance
  • improved global timeline instance to live on the request instance
  • improved Symfony routes registration to register web ui paths only when enabled
  • improved SQL storage to be more compatible with different PDO error modes
  • improved Clockwork rest api with only/except filters
  • improved handling of corrupted index records in file storage
  • improved cleaned up the code-base, added and improved comments, use modern php features
  • removed Laravel total, initalization, boot and run timeline events
  • removed legacy clockwork.controller events
  • removed duplicate file/line information from collected metadata
  • fixed authentication route not being registered when web ui is disabled
  • fixed database queries not being collected for queue jobs
  • fixed multi-line database queries not being counted properly (implemented by edgardmessias, thanks!)
  • fixed StackFrame not processing Windows paths correctly
  • multiple changes to the Laravel config file, please review and re-publish
  • the timeline api was reworked, please see documentation for details
  • the global log instance was moved to request instance, please see documentation for details
  • the central Clockwork class api was reworked, old api is available but deprecated
  • changed Slim middleware namespaces
  • please see the upgrade guide for details

4.1.8 17 Sep 2020

  • fixed handling of index file locking failures in file storage (reported by mahagr, thanks!)

4.1.7 25 Aug 2020

  • fixed a rare crash in Eloquent duplicate queries detection (reported by mstaack, thanks!)
  • fixed code-style in the Laravel config (implemented by fgilio, thanks!)

4.1.6 25 Jul 2020

  • added support for filtering collected requests by method to Laravel integration (options requests filtered by default) (idea by mortenscheel, thanks!)
  • added support for filtering collected requests by uri and method to vanilla integration
  • fixed handling of failed file operations on index file in file storage (reported by staabm, thanks!)

4.1.5 29 May 2020

  • fixed crash on initialization in Lumen apps using queue (reported by gramparallelo, thanks!)

4.1.4 25 May 2020

  • added support for a time property to the Request:add* apis, defaults to "current time - duration"
  • fixed crash when collecting console commands with array arguments or options in the Laravel integration (implemented by mortenscheel, thanks!)
  • fixed default storage directory being one level too deep in vanilla integration

4.1.3 2 May 2020

  • fixed file storage not unlocking index when cleanup has nothing to clean (implemented by Nacoma, thanks!)

4.1.2 26 Apr 2020

  • updated to Clockwork App 4.1.1
  • fixed interaction when making HTTP requests in feature tests when collecting tests in Laravel

4.1.1 15 Apr 2020

  • added ext-json to composer.json require section (idea by staabm, thanks!)
  • fixed Clockwork being initialized too soon in Laravel integration leading to possible crashes (reported by tminich,

4.1 6 Apr 2020

  • Read Clockwork 4.1 released with commands, queue jobs, tests profiling and more on blog
  • added support for command type requests with command specific metadata (commandName, commandArguments, commandArgumentsDefaults, commandOptions, commandOptionsDefaults, commandExitCode, commandOutput)
  • added support for collecting executed artisan commands in Laravel integration
  • added support for queue-job type requests with queue-job specific metadata (jobName, jobDescription, jobStatus, jobPayload, jobQueue, jobConnection, jobOptions)
  • added support for collecting executed queue-jobs in Laravel integration (also supports Laravel Horizon)
  • added support for test type requests with test specific metadata (testName, testStatus, testStatusMessage, testAsserts)
  • added support for collecting test runs in Laravel integration using PHPunit
  • added support for disabling collection of view data when collecting rendered views (new default is to collect views without data)
  • added Twig data source using the built-in Twig profiler to collect more precise Twig profiling data
  • added support for setting parent requests on requests
  • improved collecting of database queries, cache queries, dispatched queue jobs and redis commands to also collect time
  • improved the data sources filters api to allow multiple filter types
  • improved collecting of Laravel views to use a separate data source
  • improved Eloquent data source to have an additional "early" filter applied before the query is added to query counts
  • improved Eloquent data source now passes raw stack trace as second argument to filters
  • improved Laravel data source to work when response is not provided
  • improved Laravel events data source to include Laravel namespace in the default ignored events
  • improved Laravel views data source to strip view data prefixed with __
  • improved PHP data source to not set request time for cli commands
  • improved serializer to ommit data below depth limit, support debugInfo, jsonSerialize and toArray methods (partially implemented by mahagr, thanks!)
  • improved log to allow overriding serializer settings via context, no longer enabled toString by default
  • improved Request class now has pre-populated request time on creation
  • improved StackTrace helper with limit option, last method, fixed filter output keys
  • improved Lumen queue and redis feature detection
  • improved vanilla integration to allow manually sending the headers early (implemented by tminich, thanks!)
  • updated to Clockwork App 4.1
  • fixed Symfony support, added support for latest Symfony 5.x and 4.x (reported by llaville, thanks!)
  • removed dark theme for the web UI setting (now configurable in the Clockwork app itself)
  • multiple new settings were added to the Laravel config file
  • DataSourceInterface::reset method was added, default empty implementation is provided in the base DataSource class
  • LaravelDataSource constructor arguments changed to reflect removing the views collecting support

4.0.17 4 Feb 2020

  • improved performance and memory usage when doing file storage cleanup (reported by ikkez, thanks!)
  • fixed crash after running file storage cleanup
  • fixed typo in clockwork:clean argument description

4.0.16 31 Jan 2020

  • fixed Laravel middleware being registered too late, causing "collect data always" setting to not work (reported by Youniteus, thanks!)

4.0.15 9 Jan 2020

  • fixed cleanup not working with file storage (implemented by LucidTaZ, thanks!)

4.0.14 25 Nov 2019

  • fixed compatibility with Laravel 5.4 and earlier when resolving authenticated user

4.0.13 21 Oct 2019

  • fixed stack traces processing not handling call_user_func frames properly leading to wrong traces (reported by marcus-at-localhost, thanks!)
  • fixed wrong stack traces skip namespaces defaults leading to wrong traces
  • fixed vanilla integration config file missing and no longer used settings

4.0.12 13 Oct 2019

  • added a simple index file locking to the file storage
  • improved handling of invalid index data in the file storage (reported by nsbucky and tkaven, thanks!)
  • fixed Laravel data source crash when running without auth service (implemented by DrBenton, thanks!)

4.0.11 28 Sep 2019

  • updated web UI (Clockwork App 4.0.6)

4.0.10 26 Sep 2019

  • fixed wrong file:line for log messages (requires enabled stack traces atm)

4.0.9 21 Sep 2019

  • improved the default .gitignore for metadata storage to ignore compressed metadata as well (implemented by clugg, thanks!)
  • fixed duplicate queries detection reporting all relationship queries instead of only duplicates (reported by robclancy, thanks!)

4.0.8 3 Sep 2019

  • updated web UI (Clockwork App 4.0.5)

4.0.7 7 Aug 2019

  • updated web UI (Clockwork App 4.0.4)

4.0.6 26 Jul 2019

  • updated web UI (Clockwork App 4.0.3)
  • fixed possible crash in LaravelDataSource when resolving authenticated user in non-standard auth implementations (4.0 regression) (implemented by zarunet, thanks!)
  • fixed StackTrace::filter calling array_filter with swapped arguments (implemented by villermen, thanks!)
  • fixed PHP 5.x incompatibility renaming the Storage\Search empty and notEmpty methods to isEmpty and isNotEmpty (reported by eduardodgarciac, thanks!)

4.0.5 19 Jul 2019

  • updated web UI (Clockwork App 4.0.2)
  • fixed multiple issues causing FileStorage cleanup to not delete old metadata or crash (partially implemented by jaumesala, reported by SerafimArts, thanks!)

4.0.4 16 Jul 2019

  • fixed web UI not working (4.0.2 regression) (reported by williamqian and lachlankrautz, thanks!)

4.0.3 15 Jul 2019

  • fixed crash when using SQL storage (reported by sebastiaanluca, thanks!)

4.0.2 12 Jul 2019

  • updated web UI (Clockwork App 4.0.1)

4.0.1 11 Jul 2019

  • fixed Lumen support (reported by Owlnofeathers, thanks!)

4.0 26 Jun 2019

  • Read Clockwork 4.0 released with app rewrite, requests search and more on blog
  • added "features" configuration
  • added requests search (extended storage api)
  • added collecting request body data (idea by lkloon123, thanks!)
  • added collecting of dispatched queue jobs
  • added collecting Redis commands (idea by tillkruss, thanks!)
  • added collecting of database query stats separate from queries
  • added collecting of executed middleware
  • added ability to specify slow database query threshold
  • added ability to collect only slow database queries
  • added ability to disable collecting of database queries keeping database stats
  • added ability to disable collecting of cache queries keeping cache stats
  • added duplicate (N+1) database query detection (inspired by beyondcode/laravel-query-detector, thanks!)
  • added configuration to limit number of collected frames for stack traces (defaults to 10)
  • added configuration to specify skipped vendors, namespaces and files for stack traces
  • added index file to file storage
  • added support for compression in file storage
  • added new filters api to data sources
  • improved file and sql storage to support search api
  • improved symfony storage to work with file storage changes
  • improved log api to allow passing custom stack traces in context
  • improved refactored and cleaned up Laravel service provider
  • improved Lumen integration to share more code with Laravel integration
  • improved refactored sql storage a bit
  • improved timeline api, description is now optional and defaults to event name when calling startEvent (idea by robclancy, thanks!)
  • updated web UI
  • fixed regexp in vanilla integration Clockwork REST api processing
  • removed storage filter support (replaced by features configuration)
  • BREAKING configuration format changes, please re-deploy if using customized Clockwork config
  • NOTE metadata files from previous versions will need to be manually removed on upgrade


  • update the required Clockwork version to ^4.0 in your composer.json
  • delete all previous collected metadata files from storage/clockwork/
  • re-deploy the Clockwork config file

3.1.4 21 Mar 2019

  • improved DBALDataSource to work with custom types (thanks villermen)

3.1.3 26 Feb 2019

  • updated LaravelCacheDataSource to support Laravel 5.8

3.1.2 23 Dec 2018

  • fixed missing use statement in vanilla integration (thanks micc83)

3.1.1 6 Dec 2018

  • exposed the Request::setAuthenticatedUser method on the main Clockwork class
  • fixed possible crash in LaravelDataSource when resolving authenticated user in non-standard auth implementations (thanks freshleafmedia, motia)

3.1 3 Dec 2018

  • added new integration for vanilla PHP (thanks martbean)
  • added support for collecting authenticated user info
  • added bunch of helper methods for adding data like databse queries or events to Clockwork
  • added serializer options to the config files
  • updated web UI to match latest Chrome version
  • improved collecting of exceptions
  • improved filtered uris implementation in Laravel to no longer have any performance overhead (thanks marcusbetts)
  • improved compatibility with Laravel Telescope
  • fixed numeric keys being lost on serialization of arrays (thanks ametad)
  • fixed serialization of parent class private properties
  • fixed a possible crash when resolving stack traces (thanks mbardelmeijer)
  • deprecated Clockwork::subrequest method in favor of Clockwork::addSubrequest

3.0.2 30 Aug 2018

  • fixed infinite redirect if dark web theme is enabled on Laravel or Lumen

3.0.1 1 Aug 2018

  • improved LaravelDataSource to not collect views data if it is filtered (by default)

3.0 30 Jul 2018

  • Read Clockwork 3.0 now available on blog
  • updated web UI to match latest Chrome version
  • added new api for user-data (custom tabs in Clockwork app)
  • added support for authentication (thanks xiaohuilam)
  • added support for collecting stack traces for log messages, queries, etc. (thanks sisve)
  • added new api for recording subrequests (thanks L3o-pold)
  • added Symfony integration beta
  • added Xdebug profiler support
  • added collecting of full URLs for requests
  • added collecting of peak memory usage
  • added ability to use dark theme for the web UI
  • added new extend-api to data soruces for extending data when it's being sent to the application
  • improved data serialization implementation - handles recursion, unlimited depth, type metadata, clear marking for protected and private properties
  • improved data serialization with configurable defaults, limit and blackboxing of classes
  • improved handling of binary bindings in EloquentDataSource (thanks sergio91pt and coderNeos)
  • improved stack traces collection to resolve original view names
  • BREAKING improved Laravel integration to type-hint contracts instead of concrete implementations (thanks robclancy)
  • improved default configuration to not collect data for Laravel Horizon requests (thanks fgilio)
  • improved LaravelDataSource view data collecting to remove Laravel Twigbridge metadata
  • changed Laravel integration to register middleware in the boot method instead of register (thanks dionysiosarvanitis)
  • changed Laravel and Lumen integrations to use a single shared Log instance
  • fixed Clockwork HTTP API returning empty object instead of null if request was not found
  • fixed Clockwork routes not returning 404 when disabled on runtime with route cache enabled (thanks joskfg)
  • BREAKING dropped Laravel 4 support
  • BREAKING dropped PHP 5.4 support, requires PHP 5.5


  • update the required Clockwork version to ^3.0 in your composer.json
  • PHP 5.4 is no longer supported, you can continue using the latest 2.x version
  • Laravel 4 is no longer supported, you can continue using the lastest 2.x version
  • DataSourceInterface has a new extend method, make sure to implement it if using the interface directly in your custom data sources

2.3 30 Jul 2018

  • updated web UI to match latest Chrome version

2.2.4 31 Mar 2018

  • changed SQL storage schema URI column type from VARCHAR to TEXT (thanks sumidatx)
  • fixed possible crash in file storage cleanup if the file was already deleted (thanks bcalik)
  • fixed event handling in Eloquent data source compatibility with some 3rd party packages (thanks erikgaal)

2.2.4 31 Mar 2018

  • drop support for collecting Laravel controller middleware (as this can have unexpected side-effects) (thanks phh)

2.2.3 14 Mar 2018

  • improved Server-Timing now uses the new header format (thanks kohenkatz)
  • fixed Laravel crash when gathering middleware if the controller class doesn't exist

2.2.2 13 Mar 2018

  • fixed compatibility with Laravel 5.2 (thanks peppeocchi)

2.2.1 9 Mar 2018

  • fixed Laravel 4.x support once again (thanks bcalik)

2.2 8 Mar 2018

  • added support for collecting route middleware (thanks Vercoutere)
  • added support for collecting routes and middleware in newer Lumen versions
  • updated Web UI ti match Clockwork Chrome 2.2
  • improved Laravel support to register most event handlers only when collecting data
  • fixed Lumen middleware not being registered automatically (thanks lucian-dragomir)
  • fixed published Lumen config not being loaded

2.1 26 Feb 2018

  • updated Web UI to match Clockwork Chrome 2.1
  • improved Laravel support to load the default config and use env variables in the default config
  • improved Lumen support to use the standard config subsystem instead of directly accessing env variables (thanks davoaust, SunMar)
  • improved reliability of storing metadata in some cases (by using JSON_PARTIAL_OUTPUT_ON_ERROR when supported)
  • fixed wrong mime-type for javascript assets in Web UI causing it to not work in some browsers (thanks sleavitt)
  • fixed path checking in Web UI causing it to not work on Windows (thanks Malezha)
  • fixed parameters conversion in DBALDataSource (thanks andrzejenne)

2.0.4 12 Dec 2017

  • improved mkdir error handling in FileStorage (thanks FBnil)
  • fixed crash in LaravelEventsDataSource when firing events with associative array as payload

2.0.3 5 Oct 2017

  • fixed Clockwork now working when used with Laravel route cache

2.0.2 3 Oct 2017

  • fixed crash on attempt to clean up file storage if the project contains Clockwork 1.x metadata

2.0.1 29 Sep 2017

  • fixed Web UI not working in Firefox

2.0 29 Sep 2017

  • introductory blog post
  • added Web UI
  • added new Laravel cache data source
  • added new Laravel events data source
  • added new more robust metadata storage API
  • added automatic metadata cleanup (defaults to 1 week)
  • added better metadata serialization including class names for objects
  • added PostgreSQL compatibility for the SQL storage (thanks oldskool73)
  • added Slim 3 middleware (thanks sperrichon)
  • added PSR message data source (thanks sperrichon)
  • added Doctrine DBAL data source (thanks sperrichon)
  • changed Clockwork request ids now use dashes instead of dots (thanks Tibbelit)
  • changed Laravel and Lumen integrations to no longer log data for console commands
  • changed simplified the clock Laravel helper (thanks Jergus Lejko)
  • fixed wrong version data logged in SQL storage
  • removed PHP 5.3 support, code style changes
  • removed CodeIgniter support
  • removed ability to register additional data sources via Clockwork config


  • update the required Clockwork version to ^2.0 in your composer.json
  • PHP 5.3 - no longer supported, you can continue using the latest 1.x version
  • CodeIgniter - no longer supported, you can continue using the lastest 1.x version
  • Slim 2 - update the imported namespace from Clockwork\Support\Slim to Clockwork\Support\Slim\Legacy
  • ability to register additional data sources via Clockwork config was removed, please call app('clockwork')->addDataSource(...) in your own service provider

1.14.5 15 Sep 2017

  • fixed incompatibility with Laravel 4.1 an 4.2 (introduced in 1.14.3)

1.14.4 13 Sep 2017

  • added support for Lumen 5.5 (thanks nebez)

1.14.3 30 Aug 2017

  • added support for Laravel 5.5 package auto-discovery (thanks Omranic)
  • added automatic registration of the Laravel middleware (no need to edit your Http/Kernel.php anymore, existing installations don't need to be changed)
  • updated Laravel artisan clockwork:clean command for Laravel 5.5 (thanks rosswilson252)
  • fixed crash when retrieving all requests from Sql storage (thanks pies)

1.14.2 31 May 2017

  • fixed missing imports in Doctrine data source (thanks jenssegers)

1.14.1 19 May 2017

  • fixed collecting Eloquent queries when using PDO_ODBC driver for real (thanks abhimanyu003)

1.14 5 May 2017

  • added support for Server-Timing headers (thanks Garbee)
  • fixed compatibility with Lumen 5.4 (thanks Dimasdanz)
  • fixed collecting Eloquent queries with bindings containing backslashes (thanks fitztrev)
  • fixed collecting Eloquent queries when using PDO_ODBC driver (thanks abhimanyu003)
  • fixed collecting Doctrine queries with array bindings (thanks RolfJanssen)
  • fixed PHP 5.3 compatibility
  • replaced Doctrine bindings preparation code with more complete version from laravel-doctrine

1.13.1 25 Jan 2017

  • fixed compatibility with Lumen 5.4 (thanks meanevo)

1.13 24 Jan 2017

  • added support for Laravel 5.4 (thanks KKSzymanowski)
  • improved Laravel "clock" helper function now takes multiple arguments to be logged at once (eg. clock($foo, $bar, $baz))

1.12 18 Jun 2016

  • added collecting of caller file name and line number for queries and model name (Laravel 4.2+) for ORM queries to the Eloquent data source (thanks OmarMakled and fitztrev for the idea)
  • added collecting of context, caller file name and line number to the logger (thanks crissi for the idea)
  • fixed crash in Lumen data source when running unit tests with simulated requests on Lumen
  • fixed compatibility with Laravel 4.0

1.11.2 19 May 2016

  • switched to PSR-4 autoloading
  • fixed Swift data source crash when sending email with no from/to address specified (thanks marksecurelogin)

1.11.1 17 Mar 2016

  • added support for DateTimeImmutable in Doctrine data source (thanks morfin)
  • fixed not being able to log null values via the "clock" helper function
  • fixed Laravel 4.2-dev not being properly detected as 4.2 release (thanks DemianD)

1.11 23 Feb 2016

  • added support for Lumen 5.2 (thanks lukeed)
  • added "clock" helper function
  • removed Laravel log dependency from Doctrine data source
  • fixed data sources being initialized too late (thanks morfin)
  • fixed code style in Doctrine data source
  • NOTE laravel-doctrine provides ootb support for Clockwork, you should use this instead of included Doctrine data source with Laravel

1.10.1 7 Jan 2016

  • fixed collecting of database queries in Laravel 5.2 (thanks sebastiandedeyne)

1.10 23 Dec 2015

  • added Laravel 5.2 support (thanks jonphipps)
  • improved file storage to allow configuring directory permissions (thanks patrick-radius)
  • fixed interaction with PHPUnit in Lumen (thanks troyharvey)
  • removed "router dispatch" timeline event for now (due to Laravel 5.2 changes)

1.9 1 Sep 2015

  • added Lumen support (thanks dawiyo)
  • added aliases for all Clockwork parts so they can be resolved by the IoC container in Laravel and Lumen
  • fixed Laravel framework initialisation, booting and running timeline events not being recorded properly (thanks HipsterJazzbo, sisve)
  • fixed how Laravel clockwork:clean artisan command is registered (thanks freekmurze)
  • removed Lumen framework initialisation, booting and running timeline events as they are not supported by Lumen

1.8.1 6 Jul 2015

  • fixed SQL data storage initialization if PDO is set to throw exception on error (thanks YOzaz)

1.8 3 Jul 2015

  • added SQL data storage implementation
  • added new config options for data storage for Laravel (please re-publish the config file)
  • fixed not being able to use the Larvel route caching when using Clockwork (thanks Garbee, kylestev, cbakker86)

1.7 4 Feb 2015

  • added support for Laravel 5 (thanks Garbee, slovenianGooner)
  • improved support for Laravel 4.1 and 4.2, Clockwork data is now available for error responses
  • added Doctrine data source (thanks matiux)
  • fixed compatibility with some old PHP 5.3 versions (thanks hailwood)
  • updated Laravel data source to capture the context for log messages (thanks hermanzhu)

1.6 25 Sep 2014

  • improved Eloquent data source to support multiple databases (thanks ingro)
  • improved compatibility with Laravel apps not using database
  • improved compatibility with various CodeIngiter installations
  • fixed a bug where log messages and timeline data might not be sorted correctly
  • fixed missing static keyword in CodeIgniter hook (thanks noevidenz)
  • changed Timeline::endEvent behavior to return false instead of throwing exception when called for non-existing event

1.5 14 Feb 2014

  • improved Slim support to use DI container to share Clockwork instance instead of config
  • improved Slim support now adds all messages logged via Slim's log interface to Clockwork log as well
  • improved CodeIgniter support to make Clockwork available through the CI app (tnx BradEstey)
  • fixed Laravel support breaking flash messages (tnx hannesvdvreken)
  • fixed CodeIgniter support PSR-0 autoloading and other improvements (tnx pwhelan)
  • fixed file storage warning when recursive data is collected

1.4.4 22 Jan 2014

  • changed Laravel support to disable permanent data collection by default (tnx jenssegers)
  • improved Laravel support to return Clockwork data with proper Content-Type (tnx maximebeaudoin)
  • fixed CodeIgniter support compatibility with PHP 5.3 (tnx BradEstey)

1.4.3 14 Jan 2014

  • fixed incorrect requests ids being generated depending on set locale

1.4.2 13 Jan 2014

  • fixed Laravel support compatibility with PHP 5.3

1.4.1 13 Jan 2014

  • fixed Laravel support compatibility with PHP 5.3

1.4 12 Jan 2014

  • added support for collecting emails and views data
  • added support for CodeIgniter 2.1 (tnx pwhelan)
  • added data source and plugin for collecting emails data from Swift mailer
  • added support for collecting emails and views data from Laravel
  • added --age argument to Laravel artisan clockwork::clean command, specifies how old the request data must be to be deleted (in hours)
  • improved Laravel service provider
  • fixed compatibilty with latest Laravel 4.1

1.3 20 Dec 2013

  • NOTE: Clockwork\Request\Log::log method arguments have been changed from log($message, $level) to log($level, $message), levels are now specified via Psr\Log\LogLevel class, it's recommended to use shortcut methods for various levels (emergency, alert, critical, error, warning, notice, info and debug($message))
  • clockwork log class now implements PSR logger interface, updated Laravel and Monolog support to use all available log levels
  • clockwork log now accepts objects and arrays as input and logs their json representation
  • added support for specifying additional headers on metadata requests (Laravel) (tnx philsturgeon)

1.2 5 Dec 2013

  • added support for Laravel 4.1
  • added facade for Laravel
  • added ability to disable collecting data about requests to specified URIs in Laravel
  • added clockwork:clean artisan command for cleaning request metadata for Laravel
  • added an easy way to add timeline events and log records via main Clockwork class
  • added support for Slim apps running in subdirs (requires Clockwork Chrome 1.1+)
  • file storage now creates default gitignore file for the request data when creating the storage dir
  • fixed a few bugs which might cause request data to not appear in Chrome extension
  • fixed a few bugs that could lead to PHP errors/exceptions

1.1 27 Sep 2013

  • added support for Laravel 4 apps running in subdirs (requires Clockwork Chrome 1.1+)
  • added data-protocol version to the request data
  • updated Laravel 4 service provider to work with Clockwork Web
  • fixed a bug where Clockwork would break Laravel 4 apps not using database
  • fixed a bug where calling Timeline::endEvent after Timeline::finalize caused exception to be thrown
  • fixed a bug where using certain filters would store incorrect data

0.9.1 10 Jul 2013

  • added support for application routes (ootb support for Laravel 4 only atm)
  • added configuration file for Laravel 4
  • added support for filtering stored data in Storage
  • added library version constant Clockwork::VERSION

0.9.0 24 Jun 2013

  • initial release

5.1 07 Aug 2021

  • Read Clockwork 5.1 released with database queries highlighting and more on blog
  • added database queries syntax highlighting (implemented by edgardmessias, thanks!)
  • added database queries prettifying (implemented by edgardmessias, thanks!)
  • added official Edge build
  • added support for overriding metadata path via settings
  • improved compatibility with Firefox when handling cookies (reported by DarkVen0m, thanks!)
  • improved Data sidebar section styles (reprted by DarkVen0m, thanks!)
  • improved behavior of standalone mode with "keep requests log" disabled (reported by piperone, thanks!)
  • improved monospace font stack and styles
  • updated suggested Sublime url handler (idea by peterthomson, thanks!)
  • updated dependencies
  • fixed stack traces popovers placement issues (reported by JackWH, thanks!)
  • fixed high-precision timings from Xdebug 3 not being shown correctly in profiler (reported by tsukasagenesis, thanks!)
  • fixed not being able to show previous exception of chained eceptions in the log tab
  • fixed npm build scripts breaking with latest Node

5.0.2 24 Nov 2021

  • fixed user tabs not being shown (reported by martbean, thanks!)
  • fixed timeline not working if two events have the exact same start and end time (reported by mahagr, thanks!)
  • fixed flickering profiler controls when enabled

5.0.1 22 Nov 2021

  • fixed broken performance tab for requests with performance log data (reported by sinnbeck, thanks!)
  • fixed some UI glitches, wrong spinner colors in dark theme

5.0 15 Nov 2020

  • Read Clockwork 5.0 released with client-side metrics, toolbar and more on blog
  • added many design tweaks, refinements and consistent iconography
  • added reworked timeline with new UI, condensed mode, self and children times, event details, default "total" event, custom colors
  • added client-side metrics and web-vitals to the performance tab
  • added new "models" tab showing models actions with details, retrieved, created, updated and deleted models counts
  • added new "notifications" tab showing all kinds of notifications (replaces emails tab)
  • added email previews to the notifications tab
  • added ability to share requests
  • added ability to link to the current request in standalone mode
  • added credits modal and app version to settings modal
  • added on-demand mode (with optional secret)
  • improved tab bar styles and behavior
  • improved requests sidebar to show basic request info
  • improved settings and "what's new" to use a new modal UI
  • improved performance chart with simplified styles
  • improved performance issues to be a separate performance tab section
  • improved performance pofiler UI
  • improved log tab to likify urls in log messages
  • improved metadata loading with automatic retry in case of failure
  • improved metadata polling to use a simple dynamic interval
  • improved additional metadata loading to not transfer the whole request metadata
  • improved metadata loading error handling
  • improved clockwork api endpoint detection in standalone mode
  • improved date handling to use date-fns instead of momentjs (~30% lower bundle size)
  • changed moved requests search to the requests list
  • changed moved clear button to the requests list
  • changed moved preserve log settings to the settings modal
  • updated to vue-cli 4
  • fixed clearing requests list in standalone mode (implemented by edgardmessias, thanks!)
  • fixed requests list behavior where a request might not be selectable
  • fixed expanded sidebar sections state not being persisted
  • fixed profiler unnecessary re-parsing of profiles, sorting, changing requests not updating content and the docs url
  • fixed polling not being throttled on inactivity in extension mode
  • fixed multi-line database queries timeline descriptions (implemented by edgardmessias, thanks!)

4.1.1 26 Apr 2020

  • added support for the "" api as a fall-back persistent settings storage if localStorage is not available
  • improved behavior if we have no persistent storage, warning is now shown in the settings modal and what's new message is no longer shown (reported by ci_trex, thanks!)
  • fixed authentication UI might not be shown as expected when running as an extension
  • fixed pretty printing showing objects with empty string keys as infinitely recursive (reported by mahagr, thanks!)

4.1.0 6 Apr 2020

  • Read Clockwork 4.1 released with commands, queue jobs, tests profiling and more on blog
  • added support for command type requests, showing command name and exit code in requests list and arguments and options in sidebar
  • added command output tab showing ansi formatted command output
  • added support for queue-job type requests, showing job name and status in requests list and payload, connection, queue and options in sidebar
  • added support for dispatched jobs status in the queue tab and ability to show queue-job request details
  • added support for test type requests, showing test name and status in requests list and executed asserts in sidebar
  • added database quries, events, cache queries, queue jobs, redis commands, views and emails to the timeline
  • added tags support for timeline events with ability to hide individual tags
  • added support for parent requests, with ability to load and show parent request
  • added new settings modal, settings are now applied and saved right-away on change
  • added appearance setting (auto, light, dark), default auto option will use theme according to OS or Dev Tools settings
  • added settings to hide command, queue-job and test type requests
  • added setting to disable automatically showing incoming requests (idea by robclancy, thanks!)
  • added "what's new" overlay showing new features when Clockwork app gets updated
  • improved requests list to mark ajax requests, incoming ajax requests are no longer automatially shown
  • improved search to support name (command, queue-job or test) and request type
  • improved database tab to show bindings if available (idea by tminich, thanks!)
  • improved views tab to use a timeline view instead of a simple table (idea by rhukster, thanks!)
  • improved views tab to support memory usage data
  • improved views tab to not show empty view data
  • improved requests switching behavior to show default performance tab if current selected tab is not available
  • improved requests list to keep requests sorted by request time
  • improved requests list to not show database timings if no shown requests have database timings (idea by rhukster, thanks!)
  • updated npm dependencies
  • fixed pagination breaking timeline layout
  • fixed very long event descriptions breaking timeline layout
  • fixed stack traces rendering as icons with empty popups when no trace is available
  • fixed missing number rounding filter

4.0.7 30 Oct 2019

  • fixed requests list behavior when "preserve log" is disabled (reported by Vai2kas, thanks!)
  • fixed PHPStorm editor links (implemented by zlodes, thanks!)

4.0.6 28 Sep 2019

  • fixed timeline and sidebar sections not rendering when showing too many records (partially implemented by Zuken, thanks!)

4.0.5 3 Sep 2019

  • fixed entire performance log not being shown if the request doesn't have slow queries (reported by sebastiaanluca, thanks!)

4.0.4 7 Aug 2019

  • fixed crash in standalone mode when resolving cookie values (reported by christophmayrhofer, Tongzzzzz and spaceemotion, thanks!)

4.0.3 26 Jul 2019

  • fixed database, queue and redis tab "connection" and queue tab "queue" columns never being shown (implemented by fitztrev, thanks!)
  • fixed broken layout in the responsive column view if the details pane has a lot of content
  • updated npm deps

4.0.2 18 Jul 2019

  • fixed sorting tables by columns with numeric data (reported by fitztrev, thanks!)

4.0.1 12 Jul 2019

  • fixed tables pagination being preserved when changing requests leading to broken pagination state

4.0 12 Jul 2019

  • Read Clockwork 4.0 released with app rewrite, requests search and more on blog
  • fully rewritten in Vue.js
  • added requests history search
  • added request sidebar (replaces request tab)
  • added request body data (pretty-printing of json data) to request sidebar
  • added executed middleware to request sidebar
  • added request date and Clockwork id to request sidebar
  • added Queue tab showing dispatched queue jobs
  • added Redis tab showing executed Redis commands
  • added slow queries count and highlight slow queries in Database tab
  • added performance warnings to the Performance tab (eg. duplicate queries)
  • added slow queries to the Performance tab
  • added support for database stats in metadata
  • added simple pagination to large tables (significantly improving performance)
  • added messages overlay showing update notifications, exception and parent request info
  • added build scripts for all supported platforms (chrome, firefox, web)
  • improved requests list styles (cleaner, method before URIs, color-coded response status)
  • improved requests list to shorten the controller name if narrow
  • improved column view and responsive styles in general
  • improved session tab is now part of the request sidebar
  • improved requests list, sidebar and sidebar sections toggling is now preserved after closing Clockwork
  • improved raw Cookie header is no longer shown (since we already have full Cookies section)
  • improved standalone mode to throttle requests list updates when the browser tab is not active
  • improved stack trace popover alignment
  • improved build scripts to be platform-independent (implemented by Ir00man, thanks!)
  • fixed some cases when empty tabs were shown
  • fixed Firefox incompatibility in standalone mode

3.1.3 6 Feb 2019

  • fixed ordering database queries table by the query column (thanks fitztrev)

3.1.2 23 Dec 2018

  • fixed Clockwork not working when "Block third-party cookies" is enabled in Chrome (thanks betawax)
  • note, if "Block third-party cookies" is enabled, settings, theme, authentication tokens and dismissed update notifications won't be preserved when you close Clockwork

3.1.1 6 Dec 2018

  • added new server-side update notification

3.1 3 Dec 2018

  • added showing of last exception to the request tab for HTTP 500 responses
  • added authenticated user info to the session tab
  • added support for opening files in editor in stack traces (thanks xiaohuilam)
  • improved displaying exceptions in the log tab now show the class, code, correct stack trace and support chained exceptions
  • fixed xdebug installation instructions link pointing nowhere
  • fixed error handling in some cases where metadata can't be retrieved
  • fixed pretty printing not rendering numeric value "0" correctly
  • fixed subrequest processing missing urldecode
  • fixed some minor styles issues
  • fixed metadata requests having wrong Content-Type when running as standalone (thanks ssnepenthe)

3.0.1 30 Aug 2018

  • fixed Clockwork not working in incognito mode (thanks YummyTofu)
  • fixed requests not showing up in some rare cases (thanks alextime)

3.0 30 Jul 2018

  • Read Clockwork 3.0 now available on blog
  • added performance metrics and renamed the timeline tab to performance tab
  • added new timeline component UI
  • added peak memory usage to the performance tab
  • added support for filtering all tables (thanks Gennnji)
  • added support for reordering all tables
  • added support for user-data (custom tabs)
  • added request method, url, controller, response status and the ability to copy the url to the request tab (thanks sisve)
  • added query counts and time on top of the database tab (thanks fgilio)
  • added distinct colors to errors and warning in the log tab (thanks Gennnji)
  • added support for stack traces in the log, events, database and cache tabs (thanks sisve)
  • added total number of queries to the cache tab
  • added Xdebug profiler to the performance tab
  • added support for authentication (thanks xiaohuilam)
  • added support for subrequests
  • added support for dark theme when running as a standalone app
  • improved pretty printing - arrays are shown as Array with items count, supports new type metadata, fixed showing booleans, added distinct styles to booleans, nulls, resources and anonymous functions
  • improved the requests list behaviour, reliability of metadata loading and error handling
  • improved performance dropping jQuery and other minor improvements
  • improved dark theme highlight color to be a bit more contrasting (thanks robclancy)
  • fixed requests table header to compensate for scrollbar
  • fixed standalone app opening in a broken state if the web app have no metadata yet (thanks spaceemotion)
  • dropped support for resizing requests table columns

2.2 8 Mar 2018

  • learn more about privacy when using Clockwork extensions -
  • added support for displaying route middleware (thanks Vercoutere)
  • updated to latest Angular 1.x
  • fixed not being able to load metadata if the url contains hash

2.1 26 Feb 2018

  • added "preserve log" feature (works similar as in the Dev Tools network tab)
  • improved requests list behavior, requests are now shown in loading state while we are loading metadata, error message is shown if metadata fails to load
  • changed to use webRequest api for observing HTTP request in both Chrome and Firefox (fixes latest Chrome Beta/Canary)
  • fixed requests with redirect responses not being shown in Firefox
  • fixed no requests being shown in Firefox if multiple instances of Clockwork are open

2.0.3 8 Dec 2017

  • fixed some layout issues (fixes firefox scrolling issue) (thanks spaceemotion)

2.0.1 2 Oct 2017

  • fixed not being able to scroll using the mouse wheel (thanks KKSzymanowski)
  • fixed update notifications showing if the server-side has higher version (thanks KKSzymanowski)

2.0 29 Sep 2017

  • introductory blog post
  • added cache tab, including stats like reads, hits, misses, writes, deletes, time and full cache query log with pretty-printed values and caller file support
  • added events tab for apps using event dispatching
  • added dark theme
  • added showing of last request when Clockwork is opened
  • added ability to load older requests
  • added ability to collapse the requests list
  • added support for showing classes of pretty-printed objects
  • added support for running as a standalone app
  • added Firefox compatibility
  • added Clockwork server-side update notifications
  • changed UI tweaks, new tab bar, tweaked colors and whitespace
  • changed headers, get and post data, cookies and session data are now sorted alphabetically by name
  • changed refactored whole metadata handling code and a lot of the UI code
  • changed styles are now in SCSS using node-sass for compilation
  • changed handling of invalid metadata to be more robust
  • changed X-Clockwork-Version header is now optional
  • changed deprecated Chrome api usage
  • updated angular, jquery and other 3rd party libraries, switched to the "slim" jquery version
  • cleaned up styles and markup

1.6 18 Jun 2016

  • added support for model and caller file name and line number in database tab (thanks OmarMakled and fitztrev for the idea)
  • added support for caller file name and line number in log tab (thanks crissi for the idea)
  • added support for context in the log tab (thanks crissi for the idea)
  • improved pretty jason component to lazy-render objects improving UI performance a ton when logging large objects like Eloquent collections
  • updated angular, jquery and other 3rd party libraries
  • cleaned up and refactored some internal parts
  • fixed sorting of database, log, view and emails tables not working
  • fixed minor style issues with requests list error/warning count overlay on dark background
  • fixed HTML injection in the pretty-jason component

1.5 31 Jul 2015

  • added support for resizing requests table columns
  • added tooltips to requests table showing cell values
  • added errors and warnings counts to the requests table
  • changed incoming requests behavior, incoming requests are no longer automatically shown when other then last request was manually selected, selecting last request or clearing requests resets the default behaviour
  • changed toolbar implementation to a custom one to save some vertical space
  • changed timeline and log tabs to not be shown when there are no records to show
  • fixed requests table not scrolling to new requests properly

1.4.3 5 Nov 2014

  • fixed compatibility with web server sending lowercase headers (thanks EvanDarwin)

1.4.2 25 Sep 2014

  • added connection column to database tab when there are queries from multiple connections in request data

1.4.1 14 Feb 2014

  • fixed a bug where numeric values were displayed as empty objects

1.4 12 Jan 2014

  • added views and emails tabs
  • empty tabs are no longer shown
  • improved compatibility when incomplete data is received

1.3.1 20 Dec 2013

  • added support for custom headers on metadata requests specified by client via X-Clockwork-Header-NAME headers
  • log level is now specified as string by client, allowing any level names
  • fixed non-string and object values not being pretty-printed correctly

1.2 5 Dec 2013

  • updated design for the new flatter dev tools look comming in Chrome 32
  • json values in request data, logs, session and cookies now displayed as interactive elements similar to Chrome javascript console
  • fixed compatibility with some older versions of the Clockwork php library
  • fixed wrong order of the timeline events

1.1 27 Sep 2013

  • added support for custom Clockwork data uri (used for apps running in subdirs for example)

1.0 21 Sep 2013

  • released on Chrome Web Store! -
  • added new standalone web app version -
  • changed extension logo

0.9.1 10 Jul 2013

  • added application routes tab

0.9.0 24 Jun 2013

  • initial release


Friendly support is an important part of good user-experience. Please don't hesitate to contact us with any questions, issues, bug reports or feature requests.

Sponsored by

This project is a labour of love, made entirely in my free time. If you find anything I do useful, sponsoring on GitHub might be a great way to show your support. Thank you.