Clockwork

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 and Lumen support, easy integration with vanilla or custom apps and limited support for Symfony and Slim framework.

Logomark
Layer 1

Debug and profile

Install the Chrome or Firefox extension to view and interact with the collected data.

You can also use a web interface included with the server-side component available at your.app/__clockwork.

firefox-logo Safari browser logo image/svg+xml Safari browser logo 03/04/2018 Apple, Inc. CMetalCore https://fthmb.tqn.com/gnIDz9kkyZVRsWbJJOlHIYf_42g=/768x0/filters:no_upscale()/Safari-Yosemite-56a01c725f9b58eba4af0427.jpg

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.

Timeline

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.

Logging

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.

Symfony support

While Clockwork server-side focuses on Laravel, we also include a limited Symfony support.

This integration uses the built-in Symfony profiler, this means we can only display the same information as the Symfony Web Profiler.

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.

New in 4.1

Installation

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, ]

Lumen

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:

$app->register(Clockwork\Support\Lumen\ClockworkServiceProvider::class);

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.

Vanilla

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.

$clockwork->requestProcessed();

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->returnMetadata();

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.

Configuration

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

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

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);     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.

Symfony

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.

Slim

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 = new Slim\App(...); $app->add(new Clockwork\Support\Slim\ClockworkMiddleware(__DIR__ . '/storage/clockwork'));

Slim 2 is also supported:

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

Features

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 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.

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.

Tests

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

To collect data about ran 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

Clockwork app is available as a browser extension:

The server-side component also includes a full copy of the Clockwork app available at your.app/__clockwork.

This way you can use Clockwork anywhere, without installing extensions, yet we still don't inject anything to your application output. Web UI 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.

Logging

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:

User::create(clock($request->all()))

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

Timeline gives you a visual representation of your application runtime.

Clockwork will automatically add some default events, but you can also add custom ones.

To add a custom event to the timeline, you'll need to start an event with an unique name and description first:

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

After executing the tracked block of code, you can end the event, using it's unique name.

clock()->endEvent('twitter-api-call')

Events that are not stopped explicitly will simply finish when the application runtime ends.

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.

Advanced

Authentication

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.

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.

Setup

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):

zend_extension="/usr/local/php/modules/xdebug.so"

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.profiler_enable_trigger=1

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

Extending

Implementation

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.

Authentication

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.

Extensions

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

Clockwork extensions

Clockwork clients

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 info@underground.works.

Privacy

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.

Changelog

4.1 6 Apr 2020

  • Read Clockwork 4.1 released with commands, queue jobs, tests profiling and more on underground.works 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)
  • BREAKING
  • 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 underground.works 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

UPGRADING

  • 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 underground.works 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

UPGRADING

  • 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

UPGRADING

  • 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

4.1.0 6 Apr 2020

  • Read Clockwork 4.1 released with commands, queue jobs, tests profiling and more on underground.works 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 underground.works 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 underground.works 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 - underground.works/clockwork/docs/extension-privacy
  • 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! - https://chrome.google.com/webstore/detail/clockwork/dmggabnehkmmfmdffgajcflpdjlnoemp
  • added new standalone web app version - https://github.com/itsgoingd/clockwork-web
  • changed extension logo

0.9.1 10 Jul 2013

  • added application routes tab

0.9.0 24 Jun 2013

  • initial release

Support

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.

Created by

its

I'm an independent software creator from Slovakia. I make open-source software under the underground.works label with the goal of making people's lives better with a good design, programming and support.

This project would not be possible without these amazing people, sharing code, ideas, feedback and engaging in the community. Thank you.

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.