Support Laravel Debugbar 4

Plugin.php

@@ -2,17 +2,15 @@
 
 use Backend\Classes\Controller as BackendController;
 use Backend\Models\UserRole;
-use Barryvdh\Debugbar\Facades\Debugbar;
-use Barryvdh\Debugbar\LaravelDebugbar;
-use Barryvdh\Debugbar\SymfonyHttpDriver;
+use Fruitcake\LaravelDebugbar\Facades\Debugbar;
+use Fruitcake\LaravelDebugbar\LaravelDebugbar;
 use Cms\Classes\Controller as CmsController;
 use Cms\Classes\Layout;
 use Cms\Classes\Page;
 use Config;
 use Event;
 use Illuminate\Contracts\Http\Kernel as HttpKernelContract;
 use Illuminate\Foundation\AliasLoader;
-use Illuminate\Session\SessionManager;
 use System\Classes\CombineAssets;
 use System\Classes\PluginBase;
 use Twig\Extension\ProfilerExtension;
@@ -33,6 +31,11 @@ class Plugin extends PluginBase
      */
     public $elevated = true;
 
+    /**
+     * @var bool Whether Winter's models collector replaces Laravel Debugbar's.
+     */
+    protected $useWinterModelsCollector = false;
+
     /**
      * Returns information about this plugin.
      * @return array
@@ -57,20 +60,29 @@ public function register()
         // Provide the winter.debugbar config under the debugbar namespace
         Config::set('debugbar', Config::get('winter.debugbar::config'));
 
+        /*
+         * Laravel Debugbar 4 registers its collectors when its service provider boots, before this
+         * plugin boots, so turn off the collectors that Winter replaces here.
+         */
+        if (Config::get('debugbar.collectors.models', true)) {
+            $this->useWinterModelsCollector = true;
+            Config::set('debugbar.collectors.models', false);
+        }
+        if (!$this->app->runningInBackend() && Config::get('debugbar.collectors.cms', true)) {
+            // The CMS collector presents the route information instead
+            Config::set('debugbar.collectors.route', false);
+        }
+
         // Register the service provider
         $this->app->register(\Winter\Debugbar\Classes\ServiceProvider::class);
 
         // Replace the LaravelDebugbar with the WinterDebugbar
+        // Laravel Debugbar 4 configures its own HTTP driver (LaravelHttpDriver), so we only
+        // need to swap in Winter's Debugbar subclass for the custom JavascriptRenderer styling.
+        // Resolve through the container so the constructor (Application $app, Request $request)
+        // dependencies are injected (Laravel Debugbar 4 requires both).
         $this->app->singleton(LaravelDebugbar::class, function ($app) {
-            $debugbar = new WinterDebugbar($app);
-
-            if ($app->bound(SessionManager::class)) {
-                $sessionManager = $app->make(SessionManager::class);
-                $httpDriver = new SymfonyHttpDriver($sessionManager);
-                $debugbar->setHttpDriver($httpDriver);
-            }
-
-            return $debugbar;
+            return $app->make(WinterDebugbar::class);
         });
 
         // Register alias
@@ -114,14 +126,13 @@ public function boot()
      */
     public function addGlobalCollectors()
     {
-        if (Config::get('debugbar.collectors.models', true)) {
-            // Disable original models collector because it will be replaced
-            Config::set('debugbar.collectors.models', false);
-
-            /** @var \Barryvdh\Debugbar\LaravelDebugbar $debugBar */
-            $debugBar = $this->app->make(\Barryvdh\Debugbar\LaravelDebugbar::class);
+        if ($this->useWinterModelsCollector) {
+            /** @var LaravelDebugbar $debugBar */
+            $debugBar = $this->app->make(LaravelDebugbar::class);
             $modelsCollector = $this->app->make(ModelsCollector::class);
-            $debugBar->addCollector($modelsCollector);
+            if (!$debugBar->hasCollector($modelsCollector->getName())) {
+                $debugBar->addCollector($modelsCollector);
+            }
         }
     }
 
@@ -130,13 +141,10 @@ public function addGlobalCollectors()
      */
     public function addFrontendCollectors()
     {
-        /** @var \Barryvdh\Debugbar\LaravelDebugbar $debugBar */
-        $debugBar = $this->app->make(\Barryvdh\Debugbar\LaravelDebugbar::class);
+        /** @var LaravelDebugbar $debugBar */
+        $debugBar = $this->app->make(LaravelDebugbar::class);
 
         if (Config::get('debugbar.collectors.cms', true)) {
-            // Disable route collector as the CMS collector presents this info instead
-            Config::set('debugbar.collectors.route', false);
-
             Event::listen('cms.page.beforeDisplay', function (CmsController $controller, $url, ?Page $page) use ($debugBar) {
                 if ($page) {
                     $collector = new CmsCollector($controller, $url, $page);
@@ -164,8 +172,8 @@ public function addFrontendCollectors()
      */
     public function addBackendCollectors()
     {
-        /** @var \Barryvdh\Debugbar\LaravelDebugbar $debugBar */
-        $debugBar = $this->app->make(\Barryvdh\Debugbar\LaravelDebugbar::class);
+        /** @var LaravelDebugbar $debugBar */
+        $debugBar = $this->app->make(LaravelDebugbar::class);
 
         if (Config::get('debugbar.collectors.backend', true)) {
             Event::listen('backend.page.beforeDisplay', function (BackendController $controller, $action, array $params) use ($debugBar) {
@@ -183,7 +191,7 @@ public function addBackendCollectors()
     protected function registerCmsTwigExtensions()
     {
         $profile = new Profile;
-        $debugBar = $this->app->make(\Barryvdh\Debugbar\LaravelDebugbar::class);
+        $debugBar = $this->app->make(LaravelDebugbar::class);
 
         Event::listen('cms.page.beforeDisplay', function ($controller, $url, $page) use ($profile, $debugBar) {
             $twig = $controller->getTwig();
@@ -197,9 +205,11 @@ protected function registerCmsTwigExtensions()
             }
         });
 
+        // php-debugbar 2.x (shipped with Laravel Debugbar 4) no longer bundles a Twig profile
+        // collector, so only register one when the bridge class is actually available.
         if (class_exists(\DebugBar\Bridge\NamespacedTwigProfileCollector::class)) {
             $debugBar->addCollector(new \DebugBar\Bridge\NamespacedTwigProfileCollector($profile));
-        } else {
+        } elseif (class_exists(\DebugBar\Bridge\TwigProfileCollector::class)) {
             $debugBar->addCollector(new \DebugBar\Bridge\TwigProfileCollector($profile));
         }
     }

classes/ServiceProvider.php

@@ -1,22 +1,72 @@
 <?php namespace Winter\Debugbar\Classes;
 
-use Barryvdh\Debugbar\ServiceProvider as BaseServiceProvider;
+use Fruitcake\LaravelDebugbar\LaravelDebugbar;
+use Fruitcake\LaravelDebugbar\ServiceProvider as BaseServiceProvider;
+use Illuminate\Contracts\Events\Dispatcher;
 use Illuminate\Contracts\Http\Kernel;
+use Illuminate\Foundation\Http\Events\RequestHandled;
+use Illuminate\Log\Logger;
 use Winter\Debugbar\Middleware\InjectDebugbar;
 
 /**
  * ServiceProvider
  */
 class ServiceProvider extends BaseServiceProvider
 {
+    /**
+     * Bootstrap the application events.
+     *
+     * Laravel Debugbar 4 no longer registers an injection middleware; instead the base
+     * service provider injects the Debugbar via a RequestHandled event listener. We still
+     * need Winter's InjectDebugbar middleware so that injection and request storage can be
+     * gated by the winter.debugbar permissions, so we push it onto the kernel here. The
+     * middleware short-circuits the base listener (by disabling the Debugbar) whenever the
+     * current user is not permitted to view it.
+     */
+    public function boot(Dispatcher $events): void
+    {
+        /*
+         * Registered before the base listener so it runs first: a response that never passed through
+         * InjectDebugbar (for example a maintenance-mode response returned by earlier middleware) has
+         * not been permission checked, so disable the Debugbar for it.
+         */
+        $events->listen(RequestHandled::class, function (RequestHandled $event): void {
+            if (
+                $this->app->resolved(LaravelDebugbar::class)
+                && !$event->request->attributes->get(InjectDebugbar::HANDLED)
+            ) {
+                $this->app->make(LaravelDebugbar::class)->disable();
+            }
+        });
+
+        parent::boot($events);
+
+        $this->app['router']->getRoutes()->refreshNameLookups();
+
+        $this->registerMiddleware(InjectDebugbar::class);
+    }
+
+    /**
+     * Register the service provider.
+     *
+     * Debugbar's log collectors type-hint Illuminate\Log\Logger. Storm aliases that class to the
+     * "log" service, which is a LogManager, so bind it to the default channel's Logger instead.
+     */
+    public function register(): void
+    {
+        parent::register();
+
+        $this->app->bind(Logger::class, fn ($app) => $app->make('log')->driver());
+    }
+
     /**
      * Register the Debugbar Middleware
      *
      * @param  string $middleware
      */
-    protected function registerMiddleware($middleware)
+    protected function registerMiddleware(string $middleware): void
     {
         $kernel = $this->app[Kernel::class];
-        $kernel->pushMiddleware(InjectDebugbar::class);
+        $kernel->pushMiddleware($middleware);
     }
 }

classes/WinterDebugbar.php

@@ -1,21 +1,85 @@
 <?php namespace Winter\Debugbar\Classes;
 
-use Barryvdh\Debugbar\LaravelDebugbar;
+use Closure;
+use DebugBar\JavascriptRenderer;
+use Fruitcake\LaravelDebugbar\LaravelDebugbar;
 
 class WinterDebugbar extends LaravelDebugbar
 {
     /**
-     * Returns a winterized JavascriptRenderer for this instance
+     * Returns the JavascriptRenderer for this instance with Winter's styling applied.
      *
-     * @param string $baseUrl
-     * @param string $basePathng
-     * @return JavascriptRenderer
+     * Laravel Debugbar 4 performs the renderer configuration inside getJavascriptRenderer(),
+     * so we defer to the parent to build and cache the renderer and then register Winter's
+     * stylesheet via the renderer's asset API (the renderer is cached, so the CSS is only
+     * added the first time it is built).
      */
-    public function getJavascriptRenderer($baseUrl = null, $basePath = null)
+    public function getJavascriptRenderer(?string $baseUrl = null, ?string $basePath = null): JavascriptRenderer
     {
-        if ($this->jsRenderer === null) {
-            $this->jsRenderer = new JavascriptRenderer($this, $baseUrl, $basePath);
+        $alreadyBuilt = $this->jsRenderer !== null;
+
+        $renderer = parent::getJavascriptRenderer($baseUrl, $basePath);
+
+        if (!$alreadyBuilt) {
+            $renderer->addAssets(cssFiles: ['debugbar.css'], basePath: __DIR__ . '/../assets/css');
+        }
+
+        return $renderer;
+    }
+
+    /**
+     * Adds a measure, but only once the Debugbar has booted with its time collector.
+     *
+     * Laravel Debugbar 4 records measures in a time collector it creates before booting, so without this
+     * check a Debugbar that never boots (in the console or a queue worker, for example) keeps every
+     * measure until the process exits.
+     */
+    public function addMeasure(
+        string $label,
+        float $start,
+        ?float $end = null,
+        array $params = [],
+        ?string $collector = null,
+        ?string $group = null
+    ): void {
+        if ($this->hasCollector('time')) {
+            parent::addMeasure($label, $start, $end, $params, $collector, $group);
+        }
+    }
+
+    /**
+     * Measures a closure when the time collector is active, and otherwise only runs it.
+     */
+    public function measure(string $label, Closure $closure, ?string $collector = null, ?string $group = null): mixed
+    {
+        if (!$this->hasCollector('time')) {
+            return $closure();
+        }
+
+        return parent::measure($label, $closure, $collector, $group);
+    }
+
+    /**
+     * Starts a measure when the time collector is active.
+     */
+    public function startMeasure(
+        string $name,
+        ?string $label = null,
+        ?string $collector = null,
+        ?string $group = null
+    ): void {
+        if ($this->hasCollector('time')) {
+            parent::startMeasure($name, $label, $collector, $group);
+        }
+    }
+
+    /**
+     * Stops a measure when the time collector is active.
+     */
+    public function stopMeasure(string $name): void
+    {
+        if ($this->hasCollector('time')) {
+            parent::stopMeasure($name);
         }
-        return $this->jsRenderer;
     }
 }

collectors/BackendCollector.php

@@ -25,7 +25,7 @@ public function __construct(Controller $controller, $action, array $params = [])
     /**
      * {@inheritDoc}
      */
-    public function collect()
+    public function collect(): array
     {
         $ajaxHandler = $this->controller->getAjaxHandler();
 
@@ -100,19 +100,19 @@ protected function getReflector($handler)
     /**
      * {@inheritDoc}
      */
-    public function getName()
+    public function getName(): string
     {
         return 'backend';
     }
 
     /**
      * {@inheritDoc}
      */
-    public function getWidgets()
+    public function getWidgets(): array
     {
         return [
             'route' => [
-                'icon' => 'share',
+                'icon' => 'share-3',
                 'widget' => 'PhpDebugBar.Widgets.VariableListWidget',
                 'map' => 'backend',
                 'default' => '{}'