Merge pull request #18 from webman-tech/fix/17-debugbar-db-connections

krissss · web-flow · commit 71bc49b4a75d · 2026-05-16T11:39:44.000+08:00
fix(debugbar): 修复主动初始化未使用数据库连接
diff --git a/packages/debugbar/src/Bootstrap/LaravelQuery.php b/packages/debugbar/src/Bootstrap/LaravelQuery.php
@@ -3,29 +3,26 @@
 namespace WebmanTech\Debugbar\Bootstrap;
 
 use Illuminate\Database\Capsule\Manager as Capsule;
+use Illuminate\Container\Container;
+use Illuminate\Contracts\Events\Dispatcher;
 use support\Db;
+use Throwable;
 use Webman\Bootstrap;
 use WebmanTech\Debugbar\DataCollector\LaravelQueryCollector;
 use WebmanTech\Debugbar\DebugBar;
 
 class LaravelQuery implements Bootstrap
 {
+    private static bool $registered = false;
+
     /**
      * @inheritDoc
      */
     public static function start($worker)
     {
-        if (!class_exists(Capsule::class)) {
-            return;
-        }
-        $connections = array_keys((array)config('database.connections', []));
-        if ($default = config('database.default')) {
-            $connections[] = $default;
-        }
-        if (!$connections) {
+        if (!class_exists(Capsule::class) || !class_exists(Db::class)) {
             return;
         }
-        $connections = array_unique($connections);
 
         $collectorName = (new LaravelQueryCollector())->getName();
         $debugBar = DebugBar::instance();
@@ -36,8 +33,30 @@ public static function start($worker)
         /** @var LaravelQueryCollector $collector */
         $collector = $debugBar->getCollector($collectorName);
 
-        foreach ($connections as $connection) {
-            $collector->addListener(Db::connection((string)$connection));
+        self::listenForQueryEvents($collector);
+    }
+
+    private static function listenForQueryEvents(LaravelQueryCollector $collector): void
+    {
+        if (self::$registered) {
+            return;
+        }
+
+        $container = Container::getInstance();
+        if (!$container->bound('events')) {
+            return;
+        }
+
+        $dispatcher = $container->make('events');
+        if (!$dispatcher instanceof Dispatcher) {
+            return;
+        }
+
+        try {
+            $collector->addEventDispatcherListener($dispatcher);
+            self::$registered = true;
+        } catch (Throwable) {
+            // Ignore debug collector listener registration errors.
         }
     }
 }
diff --git a/packages/debugbar/src/DataCollector/LaravelQueryCollector.php b/packages/debugbar/src/DataCollector/LaravelQueryCollector.php
@@ -3,6 +3,7 @@
 namespace WebmanTech\Debugbar\DataCollector;
 
 use DebugBar\DataCollector\TimeDataCollector as DebugBarTimeDataCollector;
+use Illuminate\Contracts\Events\Dispatcher;
 use Illuminate\Database\Connection;
 use Illuminate\Database\Events\QueryExecuted;
 use Illuminate\Database\Events\TransactionBeginning;
@@ -149,69 +150,91 @@ public function addListener(Connection $db): void
             return;
         }
 
-        $event->listen(function (QueryExecuted $event) use ($db): void {
-            $connection = $event->connection;
-            if (!$this->isEventConnectionEqual($db, $connection)) {
-                return;
-            }
-            $bindings = $event->bindings;
-            $time = $event->time;
-            $query = $event->sql;
-
-            $threshold = $this->config['slow_threshold'];
-            if (!$threshold || $time > $threshold) {
-                if ($collector = $this->getRequestThisCollector()) {
-                    $collector->addQuery($query, $bindings, $time, $connection);
-                }
-            }
+        $this->addEventListeners($event, $db);
+    }
+
+    public function addEventDispatcherListener(Dispatcher $event): void
+    {
+        $this->addEventListeners($event);
+    }
+
+    private function addEventListeners(Dispatcher $event, ?Connection $connection = null): void
+    {
+        $event->listen(function (QueryExecuted $event) use ($connection): void {
+            $this->collectQueryEvent($event, $connection);
         });
 
-        $event->listen(TransactionBeginning::class, function (TransactionBeginning $transaction) use ($db): void {
-            if (!$this->isEventConnectionEqual($db, $transaction->connection)) {
-                return;
-            }
-            if ($collector = $this->getRequestThisCollector()) {
-                $collector->collectTransactionEvent('Begin Transaction', $transaction->connection);
-            }
+        $event->listen(TransactionBeginning::class, function (TransactionBeginning $transaction) use ($connection): void {
+            $this->collectTransactionConnectionEvent('Begin Transaction', $transaction->connection, $connection);
         });
 
-        $event->listen(TransactionCommitted::class, function (TransactionCommitted $transaction) use ($db): void {
-            if (!$this->isEventConnectionEqual($db, $transaction->connection)) {
-                return;
-            }
-            if ($collector = $this->getRequestThisCollector()) {
-                $collector->collectTransactionEvent('Commit Transaction', $transaction->connection);
-            }
+        $event->listen(TransactionCommitted::class, function (TransactionCommitted $transaction) use ($connection): void {
+            $this->collectTransactionConnectionEvent('Commit Transaction', $transaction->connection, $connection);
         });
 
-        $event->listen(TransactionRolledBack::class, function (TransactionRolledBack $transaction) use ($db): void {
-            if (!$this->isEventConnectionEqual($db, $transaction->connection)) {
-                return;
-            }
-            if ($collector = $this->getRequestThisCollector()) {
-                $collector->collectTransactionEvent('Rollback Transaction', $transaction->connection);
-            }
+        $event->listen(TransactionRolledBack::class, function (TransactionRolledBack $transaction) use ($connection): void {
+            $this->collectTransactionConnectionEvent('Rollback Transaction', $transaction->connection, $connection);
         });
 
-        $event->listen('connection.*.beganTransaction', function ($event, $params): void {
-            if ($collector = $this->getRequestThisCollector()) {
-                $collector->collectTransactionEvent('Begin Transaction', $params[0]);
-            }
+        $event->listen('connection.*.beganTransaction', function ($event, $params) use ($connection): void {
+            $this->collectWildcardTransactionEvent('Begin Transaction', $params, $connection);
         });
 
-        $event->listen('connection.*.committed', function ($event, $params): void {
-            if ($collector = $this->getRequestThisCollector()) {
-                $collector->collectTransactionEvent('Commit Transaction', $params[0]);
-            }
+        $event->listen('connection.*.committed', function ($event, $params) use ($connection): void {
+            $this->collectWildcardTransactionEvent('Commit Transaction', $params, $connection);
         });
 
-        $event->listen('connection.*.rollingBack', function ($event, $params): void {
-            if ($collector = $this->getRequestThisCollector()) {
-                $collector->collectTransactionEvent('Rollback Transaction', $params[0]);
-            }
+        $event->listen('connection.*.rollingBack', function ($event, $params) use ($connection): void {
+            $this->collectWildcardTransactionEvent('Rollback Transaction', $params, $connection);
         });
     }
 
+    private function collectQueryEvent(QueryExecuted $event, ?Connection $expectedConnection = null): void
+    {
+        if (!$this->shouldCollectConnection($event->connection, $expectedConnection)) {
+            return;
+        }
+
+        $threshold = $this->config['slow_threshold'];
+        if ($threshold && $event->time <= $threshold) {
+            return;
+        }
+
+        if ($collector = $this->getRequestThisCollector()) {
+            $collector->addQuery($event->sql, $event->bindings, $event->time, $event->connection);
+        }
+    }
+
+    private function collectTransactionConnectionEvent(
+        string $label,
+        Connection $eventConnection,
+        ?Connection $expectedConnection = null,
+    ): void {
+        if (!$this->shouldCollectConnection($eventConnection, $expectedConnection)) {
+            return;
+        }
+
+        if ($collector = $this->getRequestThisCollector()) {
+            $collector->collectTransactionEvent($label, $eventConnection);
+        }
+    }
+
+    /**
+     * @param array<mixed> $params
+     */
+    private function collectWildcardTransactionEvent(
+        string $label,
+        array $params,
+        ?Connection $expectedConnection = null,
+    ): void {
+        $eventConnection = $params[0] ?? null;
+        if (!$eventConnection instanceof Connection) {
+            return;
+        }
+
+        $this->collectTransactionConnectionEvent($label, $eventConnection, $expectedConnection);
+    }
+
     /**
      * 获取 request 下每次新的当前 collector 对象
      * @return static|null
@@ -238,4 +261,13 @@ protected function isEventConnectionEqual(Connection $connection, Connection $ev
     {
         return $connection->getName() === $eventConnection->getName();
     }
+
+    private function shouldCollectConnection(Connection $eventConnection, ?Connection $expectedConnection = null): bool
+    {
+        if ($expectedConnection === null) {
+            return true;
+        }
+
+        return $this->isEventConnectionEqual($expectedConnection, $eventConnection);
+    }
 }
diff --git a/tests/Unit/Debugbar/LaravelQueryTest.php b/tests/Unit/Debugbar/LaravelQueryTest.php
@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+
+use Illuminate\Container\Container;
+use Illuminate\Contracts\Events\Dispatcher;
+use WebmanTech\Debugbar\Bootstrap\LaravelQuery;
+use WebmanTech\Debugbar\DataCollector\LaravelQueryCollector;
+
+function debugbar_laravel_query_listen_for_query_events(LaravelQueryCollector $collector): void
+{
+    $method = new ReflectionMethod(LaravelQuery::class, 'listenForQueryEvents');
+    $method->setAccessible(true);
+    $method->invoke(null, $collector);
+}
+
+beforeEach(function () {
+    $property = new ReflectionProperty(LaravelQuery::class, 'registered');
+    $property->setAccessible(true);
+    $property->setValue(null, false);
+
+    $container = Container::getInstance();
+    $this->originalEvents = $container->bound('events') ? $container->make('events') : null;
+});
+
+afterEach(function () {
+    $container = Container::getInstance();
+    if ($this->originalEvents) {
+        $container->instance('events', $this->originalEvents);
+        return;
+    }
+
+    $container->forgetInstance('events');
+});
+
+it('registers query event listener only once', function () {
+    $container = Container::getInstance();
+    $dispatcher = $this->createMock(Dispatcher::class);
+    $collector = $this->getMockBuilder(LaravelQueryCollector::class)
+        ->disableOriginalConstructor()
+        ->onlyMethods(['addEventDispatcherListener'])
+        ->getMock();
+
+    $container->instance('events', $dispatcher);
+
+    $collector->expects($this->once())
+        ->method('addEventDispatcherListener')
+        ->with($dispatcher);
+
+    debugbar_laravel_query_listen_for_query_events($collector);
+    debugbar_laravel_query_listen_for_query_events($collector);
+});
+
+it('ignores query event listener registration failures', function () {
+    $container = Container::getInstance();
+    $dispatcher = $this->createMock(Dispatcher::class);
+    $collector = $this->getMockBuilder(LaravelQueryCollector::class)
+        ->disableOriginalConstructor()
+        ->onlyMethods(['addEventDispatcherListener'])
+        ->getMock();
+
+    $container->instance('events', $dispatcher);
+
+    $collector->expects($this->once())
+        ->method('addEventDispatcherListener')
+        ->with($dispatcher)
+        ->willThrowException(new RuntimeException('listener unavailable'));
+
+    debugbar_laravel_query_listen_for_query_events($collector);
+});
