refactor: replace error_log with Yii logger

dacheng-gao · dacheng-gao · commit 0dbf9626bc5d · 2025-11-06T00:01:44.000+08:00
Replace error_log() calls with Yii::error() for better log management
and consistency. Keep error_log() in critical paths (logging system
itself, shutdown handlers) to avoid recursion and ensure messages are
captured when Yii is unavailable.

Changes:
- Use Yii::error() for connection pool errors
- Use Yii::error() for component cleanup errors
- Remove redundant debug error_log() in queue worker
- Add clear comments explaining remaining error_log() usage
diff --git a/src/Coroutine/CoroutineApplication.php b/src/Coroutine/CoroutineApplication.php
@@ -119,15 +119,15 @@ public function resetCoroutineContext(): void
             try {
                 $store['db']->close();
             } catch (\Throwable $e) {
-                error_log("[CoroutineApplication] Error closing db: " . $e->getMessage());
+                \Yii::error('Error closing db: ' . $e->getMessage(), __CLASS__);
             }
         }
         
         if (isset($store['redis']) && is_object($store['redis']) && method_exists($store['redis'], 'close')) {
             try {
                 $store['redis']->close();
             } catch (\Throwable $e) {
-                error_log("[CoroutineApplication] Error closing redis: " . $e->getMessage());
+                \Yii::error('Error closing redis: ' . $e->getMessage(), __CLASS__);
             }
         }
         
diff --git a/src/Db/CoroutineDbConnection.php b/src/Db/CoroutineDbConnection.php
@@ -74,7 +74,7 @@ public function close(): void
             try {
                 $this->ensurePool()->release($pdo);
             } catch (\Throwable $e) {
-                error_log('[CoroutineDbConnection] Error releasing connection to pool: ' . $e->getMessage());
+                \Yii::error('Error releasing connection to pool: ' . $e->getMessage(), __CLASS__);
             }
         } else {
             parent::close();
@@ -208,7 +208,7 @@ private static function registerShutdownHandler(): void
                 try {
                     self::shutdownAllPools();
                 } catch (\Throwable $e) {
-                    // Silently handle errors during shutdown handler
+                    // Use error_log here to avoid dependency on Yii during shutdown
                     error_log('[CoroutineDbConnection] Error in shutdown handler: ' . $e->getMessage());
                 }
             }
diff --git a/src/Log/CoroutineFileTarget.php b/src/Log/CoroutineFileTarget.php
@@ -138,6 +138,7 @@ private function writeFormattedMessages(array $formattedMessages): void
         }
 
         if (($fp = @fopen($this->logFile, 'a')) === false) {
+            // Use error_log here to avoid recursion in logging system
             error_log("Unable to append to log file: {$this->logFile}");
             return;
         }
@@ -150,6 +151,7 @@ private function writeFormattedMessages(array $formattedMessages): void
             $this->rotateFilesSync();
             
             if (($fp = @fopen($this->logFile, 'a')) === false) {
+                // Use error_log here to avoid recursion in logging system
                 error_log("Unable to reopen log file after rotation: {$this->logFile}");
                 return;
             }
@@ -207,6 +209,7 @@ public function shutdown(): void
             try {
                 $this->worker->stop();
             } catch (\Throwable $e) {
+                // Use error_log here to avoid recursion in logging system
                 error_log('[CoroutineFileTarget] Error stopping worker: ' . $e->getMessage());
             }
             $this->worker = null;
@@ -220,6 +223,7 @@ public function __destruct()
         try {
             $this->shutdown();
         } catch (\Throwable $e) {
+            // Use error_log here to avoid recursion in logging system
             error_log('[CoroutineFileTarget] Error during destruct: ' . $e->getMessage());
         }
     }
diff --git a/src/Log/LogWorker.php b/src/Log/LogWorker.php
@@ -81,10 +81,12 @@ public function stop(): void
         $this->writeBufferedMessages();
 
         if (!empty($this->messageBuffer)) {
+            // Use error_log here to avoid recursion in logging system
             error_log('[LogWorker] Warning: ' . count($this->messageBuffer) . ' messages remain after stop');
         }
-
+        
         if ($this->droppedMessages > 0) {
+            // Use error_log here to avoid recursion in logging system
             error_log('[LogWorker] Warning: ' . $this->droppedMessages . ' messages were dropped (buffer full)');
         }
     }
@@ -134,6 +136,7 @@ private function writeMessages(array $messages): void
         $success = @file_put_contents($this->logFile, $text, FILE_APPEND | LOCK_EX);
         
         if ($success === false) {
+            // Use error_log here to avoid recursion in logging system
             error_log("LogWorker: Unable to write to log file: {$this->logFile}");
             return;
         }
diff --git a/src/Queue/CoroutineRedisQueue.php b/src/Queue/CoroutineRedisQueue.php
@@ -154,7 +154,6 @@ public function run($repeat, $timeout = 0)
                             $duration = round(microtime(true) - $startTime, 2);
                             $rate = $duration > 0 ? round($jobCount / $duration, 2) : 0;
                             \Yii::info("Shutdown requested, stopping worker after current job. Processed {$jobCount} jobs in {$duration}s ({$rate} jobs/s)", __METHOD__);
-                            error_log("[Queue] Breaking from serial worker loop due to shutdown");
                             break;
                         }
                     } catch (\yii\redis\SocketException $e) {
@@ -168,12 +167,9 @@ public function run($repeat, $timeout = 0)
                         }
                     }
                 }
-                
-                error_log("[Queue] Exited serial worker loop");
             } finally {
                 // Return connection to pool when worker stops
                 $this->redis->close();
-                error_log("[Queue] Serial worker cleanup complete");
             }
         });
     }
diff --git a/src/Redis/CoroutineRedisConnection.php b/src/Redis/CoroutineRedisConnection.php
@@ -514,7 +514,7 @@ private static function registerShutdownHandler(): void
                 try {
                     self::shutdownAllPools();
                 } catch (\Throwable $e) {
-                    // Silently handle errors during shutdown handler
+                    // Use error_log here to avoid dependency on Yii during shutdown
                     error_log('[CoroutineRedisConnection] Error in shutdown handler: ' . $e->getMessage());
                 }
             }
diff --git a/src/Server/RequestDispatcher.php b/src/Server/RequestDispatcher.php
@@ -95,15 +95,15 @@ public function dispatch(Request $request, Response $response, SwooleCoroutineHt
                     try {
                         $store['db']->close();
                     } catch (\Throwable $e) {
-                        error_log('[RequestDispatcher] Error closing DB: ' . $e->getMessage());
+                        Yii::error('Error closing DB: ' . $e->getMessage(), __CLASS__);
                     }
                 }
                 
                 if (isset($store['redis']) && is_object($store['redis']) && method_exists($store['redis'], 'close')) {
                     try {
                         $store['redis']->close();
                     } catch (\Throwable $e) {
-                        error_log('[RequestDispatcher] Error closing Redis: ' . $e->getMessage());
+                        Yii::error('Error closing Redis: ' . $e->getMessage(), __CLASS__);
                     }
                 }
             }
diff --git a/src/Server/ShutdownHelper.php b/src/Server/ShutdownHelper.php
@@ -29,7 +29,7 @@ class ShutdownHelper
      * 2. Stops log workers (which flush their buffers to disk)
      * 3. Shuts down all log targets cleanly
      * 
-     * @param bool $verbose Whether to output progress messages to error_log
+     * @param bool $verbose Whether to output progress messages (currently unused, errors always logged)
      */
     public static function flushLogs(bool $verbose = true): void
     {
@@ -61,6 +61,7 @@ public static function flushLogs(bool $verbose = true): void
                         }
                     }
                 } catch (\Throwable $e) {
+                    // Use error_log here to avoid recursion in logging system during shutdown
                     error_log("Error stopping log worker '{$targetName}': {$e->getMessage()}");
                 }
             }
@@ -71,31 +72,35 @@ public static function flushLogs(bool $verbose = true): void
                     try {
                         $target->shutdown();
                     } catch (\Throwable $e) {
+                        // Use error_log here to avoid recursion in logging system during shutdown
                         error_log("Error shutting down log target '{$targetName}': {$e->getMessage()}");
                     }
                 }
             }
         } catch (\Throwable $e) {
+            // Use error_log here to avoid recursion in logging system during shutdown
             error_log('Error flushing logs: ' . $e->getMessage());
         }
     }
 
     /**
      * Closes all database and Redis connection pools
      * 
-     * @param bool $verbose Whether to output progress messages to error_log
+     * @param bool $verbose Whether to output progress messages (currently unused, errors always logged)
      */
     public static function closeConnectionPools(bool $verbose = true): void
     {
         try {
             CoroutineDbConnection::shutdownAllPools();
         } catch (\Throwable $e) {
+            // Use error_log during shutdown to ensure message is captured
             error_log('Error closing DB pools: ' . $e->getMessage());
         }
         
         try {
             CoroutineRedisConnection::shutdownAllPools();
         } catch (\Throwable $e) {
+            // Use error_log during shutdown to ensure message is captured
             error_log('Error closing Redis pools: ' . $e->getMessage());
         }
     }
@@ -106,7 +111,7 @@ public static function closeConnectionPools(bool $verbose = true): void
      * This executes both log flushing and connection pool closing
      * in the correct order.
      * 
-     * @param bool $verbose Whether to output progress messages to error_log
+     * @param bool $verbose Whether to output progress messages (currently unused, errors always logged)
      */
     public static function performGracefulShutdown(bool $verbose = true): void
     {
diff --git a/src/Server/SignalHandler.php b/src/Server/SignalHandler.php
@@ -33,6 +33,7 @@ class SignalHandler
     public function register(): void
     {
         if (!extension_loaded('pcntl')) {
+            // Use error_log here since Yii may not be initialized yet
             error_log('[SignalHandler] PCNTL extension not loaded, signal handling disabled');
             return;
         }
@@ -99,11 +100,13 @@ private function handleShutdownSignal(int $signo): void
         $signalName = $signo === SIGTERM ? 'SIGTERM' : 'SIGINT';
         
         if ($this->shutdownRequested) {
+            // Use error_log during shutdown to ensure message is captured
             error_log("Forcing immediate exit");
             exit(1);
         }
         
         $this->shutdownRequested = true;
+        // Use error_log during shutdown to ensure message is captured
         error_log("Shutting down server...");
         
         // Perform graceful shutdown in a coroutine
@@ -135,18 +138,21 @@ private function performGracefulShutdown(): void
             $elapsed = microtime(true) - $this->shutdownStartTime;
             
             if ($elapsed >= self::SHUTDOWN_TIMEOUT) {
+                // Use error_log during shutdown to ensure message is captured
                 error_log("Shutdown timeout reached, skipping remaining callbacks");
                 break;
             }
             
             try {
                 $config['callback']();
             } catch (\Throwable $e) {
+                // Use error_log during shutdown to ensure message is captured
                 error_log("Error in shutdown callback '{$name}': {$e->getMessage()}");
             }
         }
         
         $totalTime = microtime(true) - $this->shutdownStartTime;
+        // Use error_log during shutdown to ensure message is captured
         error_log(sprintf('Server shutdown completed in %.3f seconds', $totalTime));
         
         // Wait briefly for remaining coroutines to complete
@@ -176,6 +182,7 @@ public function waitForInflightRequests(callable $checkCallback, float $maxWaitT
             Coroutine::sleep(self::CHECK_INTERVAL);
         }
         
+        // Use error_log during shutdown to ensure message is captured
         error_log('Request timeout, proceeding with shutdown');
     }
 
@@ -203,6 +210,7 @@ private function waitForRemainingCoroutines(float $maxWaitTime): void
         $stats = Coroutine::stats();
         $remaining = (int)($stats['coroutine_num'] ?? 0);
         if ($remaining > 2) {
+            // Use error_log during shutdown to ensure message is captured
             error_log("Warning: {$remaining} coroutines still active");
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -119,15 +119,15 @@ public function resetCoroutineContext(): void`
`119`	`119`	`try {`
`120`	`120`	`$store['db']->close();`
`121`	`121`	`} catch (\Throwable $e) {`
`122`		`- error_log("[CoroutineApplication] Error closing db: " . $e->getMessage());`
	`122`	`+ \Yii::error('Error closing db: ' . $e->getMessage(), __CLASS__);`
`123`	`123`	`}`
`124`	`124`	`}`
`125`	`125`
`126`	`126`	`if (isset($store['redis']) && is_object($store['redis']) && method_exists($store['redis'], 'close')) {`
`127`	`127`	`try {`
`128`	`128`	`$store['redis']->close();`
`129`	`129`	`} catch (\Throwable $e) {`
`130`		`- error_log("[CoroutineApplication] Error closing redis: " . $e->getMessage());`
	`130`	`+ \Yii::error('Error closing redis: ' . $e->getMessage(), __CLASS__);`
`131`	`131`	`}`
`132`	`132`	`}`
`133`	`133`
Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@ public function close(): void`
`74`	`74`	`try {`
`75`	`75`	`$this->ensurePool()->release($pdo);`
`76`	`76`	`} catch (\Throwable $e) {`
`77`		`- error_log('[CoroutineDbConnection] Error releasing connection to pool: ' . $e->getMessage());`
	`77`	`+ \Yii::error('Error releasing connection to pool: ' . $e->getMessage(), __CLASS__);`
`78`	`78`	`}`
`79`	`79`	`} else {`
`80`	`80`	`parent::close();`
`@@ -208,7 +208,7 @@ private static function registerShutdownHandler(): void`
`208`	`208`	`try {`
`209`	`209`	`self::shutdownAllPools();`
`210`	`210`	`} catch (\Throwable $e) {`
`211`		`- // Silently handle errors during shutdown handler`
	`211`	`+ // Use error_log here to avoid dependency on Yii during shutdown`
`212`	`212`	`error_log('[CoroutineDbConnection] Error in shutdown handler: ' . $e->getMessage());`
`213`	`213`	`}`
`214`	`214`	`}`
Original file line number	Diff line number	Diff line change
`@@ -138,6 +138,7 @@ private function writeFormattedMessages(array $formattedMessages): void`
`138`	`138`	`}`
`139`	`139`
`140`	`140`	`if (($fp = @fopen($this->logFile, 'a')) === false) {`
	`141`	`+ // Use error_log here to avoid recursion in logging system`
`141`	`142`	`error_log("Unable to append to log file: {$this->logFile}");`
`142`	`143`	`return;`
`143`	`144`	`}`
`@@ -150,6 +151,7 @@ private function writeFormattedMessages(array $formattedMessages): void`
`150`	`151`	`$this->rotateFilesSync();`
`151`	`152`
`152`	`153`	`if (($fp = @fopen($this->logFile, 'a')) === false) {`
	`154`	`+ // Use error_log here to avoid recursion in logging system`
`153`	`155`	`error_log("Unable to reopen log file after rotation: {$this->logFile}");`
`154`	`156`	`return;`
`155`	`157`	`}`
`@@ -207,6 +209,7 @@ public function shutdown(): void`
`207`	`209`	`try {`
`208`	`210`	`$this->worker->stop();`
`209`	`211`	`} catch (\Throwable $e) {`
	`212`	`+ // Use error_log here to avoid recursion in logging system`
`210`	`213`	`error_log('[CoroutineFileTarget] Error stopping worker: ' . $e->getMessage());`
`211`	`214`	`}`
`212`	`215`	`$this->worker = null;`
`@@ -220,6 +223,7 @@ public function __destruct()`
`220`	`223`	`try {`
`221`	`224`	`$this->shutdown();`
`222`	`225`	`} catch (\Throwable $e) {`
	`226`	`+ // Use error_log here to avoid recursion in logging system`
`223`	`227`	`error_log('[CoroutineFileTarget] Error during destruct: ' . $e->getMessage());`
`224`	`228`	`}`
`225`	`229`	`}`
Original file line number	Diff line number	Diff line change
`@@ -81,10 +81,12 @@ public function stop(): void`
`81`	`81`	`$this->writeBufferedMessages();`
`82`	`82`
`83`	`83`	`if (!empty($this->messageBuffer)) {`
	`84`	`+ // Use error_log here to avoid recursion in logging system`
`84`	`85`	`error_log('[LogWorker] Warning: ' . count($this->messageBuffer) . ' messages remain after stop');`
`85`	`86`	`}`
`86`		`-`
	`87`	`+`
`87`	`88`	`if ($this->droppedMessages > 0) {`
	`89`	`+ // Use error_log here to avoid recursion in logging system`
`88`	`90`	`error_log('[LogWorker] Warning: ' . $this->droppedMessages . ' messages were dropped (buffer full)');`
`89`	`91`	`}`
`90`	`92`	`}`
`@@ -134,6 +136,7 @@ private function writeMessages(array $messages): void`
`134`	`136`	`$success = @file_put_contents($this->logFile, $text, FILE_APPEND \| LOCK_EX);`
`135`	`137`
`136`	`138`	`if ($success === false) {`
	`139`	`+ // Use error_log here to avoid recursion in logging system`
`137`	`140`	`error_log("LogWorker: Unable to write to log file: {$this->logFile}");`
`138`	`141`	`return;`
`139`	`142`	`}`
Original file line number	Diff line number	Diff line change
`@@ -154,7 +154,6 @@ public function run($repeat, $timeout = 0)`
`154`	`154`	`$duration = round(microtime(true) - $startTime, 2);`
`155`	`155`	`$rate = $duration > 0 ? round($jobCount / $duration, 2) : 0;`
`156`	`156`	`\Yii::info("Shutdown requested, stopping worker after current job. Processed {$jobCount} jobs in {$duration}s ({$rate} jobs/s)", __METHOD__);`
`157`		`- error_log("[Queue] Breaking from serial worker loop due to shutdown");`
`158`	`157`	`break;`
`159`	`158`	`}`
`160`	`159`	`} catch (\yii\redis\SocketException $e) {`
`@@ -168,12 +167,9 @@ public function run($repeat, $timeout = 0)`
`168`	`167`	`}`
`169`	`168`	`}`
`170`	`169`	`}`
`171`		`-`
`172`		`- error_log("[Queue] Exited serial worker loop");`
`173`	`170`	`} finally {`
`174`	`171`	`// Return connection to pool when worker stops`
`175`	`172`	`$this->redis->close();`
`176`		`- error_log("[Queue] Serial worker cleanup complete");`
`177`	`173`	`}`
`178`	`174`	`});`
`179`	`175`	`}`
Original file line number	Diff line number	Diff line change
`@@ -514,7 +514,7 @@ private static function registerShutdownHandler(): void`
`514`	`514`	`try {`
`515`	`515`	`self::shutdownAllPools();`
`516`	`516`	`} catch (\Throwable $e) {`
`517`		`- // Silently handle errors during shutdown handler`
	`517`	`+ // Use error_log here to avoid dependency on Yii during shutdown`
`518`	`518`	`error_log('[CoroutineRedisConnection] Error in shutdown handler: ' . $e->getMessage());`
`519`	`519`	`}`
`520`	`520`	`}`
Original file line number	Diff line number	Diff line change
`@@ -95,15 +95,15 @@ public function dispatch(Request $request, Response $response, SwooleCoroutineHt`
`95`	`95`	`try {`
`96`	`96`	`$store['db']->close();`
`97`	`97`	`} catch (\Throwable $e) {`
`98`		`- error_log('[RequestDispatcher] Error closing DB: ' . $e->getMessage());`
	`98`	`+ Yii::error('Error closing DB: ' . $e->getMessage(), __CLASS__);`
`99`	`99`	`}`
`100`	`100`	`}`
`101`	`101`
`102`	`102`	`if (isset($store['redis']) && is_object($store['redis']) && method_exists($store['redis'], 'close')) {`
`103`	`103`	`try {`
`104`	`104`	`$store['redis']->close();`
`105`	`105`	`} catch (\Throwable $e) {`
`106`		`- error_log('[RequestDispatcher] Error closing Redis: ' . $e->getMessage());`
	`106`	`+ Yii::error('Error closing Redis: ' . $e->getMessage(), __CLASS__);`
`107`	`107`	`}`
`108`	`108`	`}`
`109`	`109`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ class ShutdownHelper`
`29`	`29`	`* 2. Stops log workers (which flush their buffers to disk)`
`30`	`30`	`* 3. Shuts down all log targets cleanly`
`31`	`31`	`*`
`32`		`- * @param bool $verbose Whether to output progress messages to error_log`
	`32`	`+ * @param bool $verbose Whether to output progress messages (currently unused, errors always logged)`
`33`	`33`	`*/`
`34`	`34`	`public static function flushLogs(bool $verbose = true): void`
`35`	`35`	`{`
`@@ -61,6 +61,7 @@ public static function flushLogs(bool $verbose = true): void`
`61`	`61`	`}`
`62`	`62`	`}`
`63`	`63`	`} catch (\Throwable $e) {`
	`64`	`+ // Use error_log here to avoid recursion in logging system during shutdown`
`64`	`65`	`error_log("Error stopping log worker '{$targetName}': {$e->getMessage()}");`
`65`	`66`	`}`
`66`	`67`	`}`
`@@ -71,31 +72,35 @@ public static function flushLogs(bool $verbose = true): void`
`71`	`72`	`try {`
`72`	`73`	`$target->shutdown();`
`73`	`74`	`} catch (\Throwable $e) {`
	`75`	`+ // Use error_log here to avoid recursion in logging system during shutdown`
`74`	`76`	`error_log("Error shutting down log target '{$targetName}': {$e->getMessage()}");`
`75`	`77`	`}`
`76`	`78`	`}`
`77`	`79`	`}`
`78`	`80`	`} catch (\Throwable $e) {`
	`81`	`+ // Use error_log here to avoid recursion in logging system during shutdown`
`79`	`82`	`error_log('Error flushing logs: ' . $e->getMessage());`
`80`	`83`	`}`
`81`	`84`	`}`
`82`	`85`
`83`	`86`	`/**`
`84`	`87`	`* Closes all database and Redis connection pools`
`85`	`88`	`*`
`86`		`- * @param bool $verbose Whether to output progress messages to error_log`
	`89`	`+ * @param bool $verbose Whether to output progress messages (currently unused, errors always logged)`
`87`	`90`	`*/`
`88`	`91`	`public static function closeConnectionPools(bool $verbose = true): void`
`89`	`92`	`{`
`90`	`93`	`try {`
`91`	`94`	`CoroutineDbConnection::shutdownAllPools();`
`92`	`95`	`} catch (\Throwable $e) {`
	`96`	`+ // Use error_log during shutdown to ensure message is captured`
`93`	`97`	`error_log('Error closing DB pools: ' . $e->getMessage());`
`94`	`98`	`}`
`95`	`99`
`96`	`100`	`try {`
`97`	`101`	`CoroutineRedisConnection::shutdownAllPools();`
`98`	`102`	`} catch (\Throwable $e) {`
	`103`	`+ // Use error_log during shutdown to ensure message is captured`
`99`	`104`	`error_log('Error closing Redis pools: ' . $e->getMessage());`
`100`	`105`	`}`
`101`	`106`	`}`
`@@ -106,7 +111,7 @@ public static function closeConnectionPools(bool $verbose = true): void`
`106`	`111`	`* This executes both log flushing and connection pool closing`
`107`	`112`	`* in the correct order.`
`108`	`113`	`*`
`109`		`- * @param bool $verbose Whether to output progress messages to error_log`
	`114`	`+ * @param bool $verbose Whether to output progress messages (currently unused, errors always logged)`
`110`	`115`	`*/`
`111`	`116`	`public static function performGracefulShutdown(bool $verbose = true): void`
`112`	`117`	`{`
Original file line number	Diff line number	Diff line change
`@@ -33,6 +33,7 @@ class SignalHandler`
`33`	`33`	`public function register(): void`
`34`	`34`	`{`
`35`	`35`	`if (!extension_loaded('pcntl')) {`
	`36`	`+ // Use error_log here since Yii may not be initialized yet`
`36`	`37`	`error_log('[SignalHandler] PCNTL extension not loaded, signal handling disabled');`
`37`	`38`	`return;`
`38`	`39`	`}`
`@@ -99,11 +100,13 @@ private function handleShutdownSignal(int $signo): void`
`99`	`100`	`$signalName = $signo === SIGTERM ? 'SIGTERM' : 'SIGINT';`
`100`	`101`
`101`	`102`	`if ($this->shutdownRequested) {`
	`103`	`+ // Use error_log during shutdown to ensure message is captured`
`102`	`104`	`error_log("Forcing immediate exit");`
`103`	`105`	`exit(1);`
`104`	`106`	`}`
`105`	`107`
`106`	`108`	`$this->shutdownRequested = true;`
	`109`	`+ // Use error_log during shutdown to ensure message is captured`
`107`	`110`	`error_log("Shutting down server...");`
`108`	`111`
`109`	`112`	`// Perform graceful shutdown in a coroutine`
`@@ -135,18 +138,21 @@ private function performGracefulShutdown(): void`
`135`	`138`	`$elapsed = microtime(true) - $this->shutdownStartTime;`
`136`	`139`
`137`	`140`	`if ($elapsed >= self::SHUTDOWN_TIMEOUT) {`
	`141`	`+ // Use error_log during shutdown to ensure message is captured`
`138`	`142`	`error_log("Shutdown timeout reached, skipping remaining callbacks");`
`139`	`143`	`break;`
`140`	`144`	`}`
`141`	`145`
`142`	`146`	`try {`
`143`	`147`	`$config['callback']();`
`144`	`148`	`} catch (\Throwable $e) {`
	`149`	`+ // Use error_log during shutdown to ensure message is captured`
`145`	`150`	`error_log("Error in shutdown callback '{$name}': {$e->getMessage()}");`
`146`	`151`	`}`
`147`	`152`	`}`
`148`	`153`
`149`	`154`	`$totalTime = microtime(true) - $this->shutdownStartTime;`
	`155`	`+ // Use error_log during shutdown to ensure message is captured`
`150`	`156`	`error_log(sprintf('Server shutdown completed in %.3f seconds', $totalTime));`
`151`	`157`
`152`	`158`	`// Wait briefly for remaining coroutines to complete`
`@@ -176,6 +182,7 @@ public function waitForInflightRequests(callable $checkCallback, float $maxWaitT`
`176`	`182`	`Coroutine::sleep(self::CHECK_INTERVAL);`
`177`	`183`	`}`
`178`	`184`
	`185`	`+ // Use error_log during shutdown to ensure message is captured`
`179`	`186`	`error_log('Request timeout, proceeding with shutdown');`
`180`	`187`	`}`
`181`	`188`
`@@ -203,6 +210,7 @@ private function waitForRemainingCoroutines(float $maxWaitTime): void`
`203`	`210`	`$stats = Coroutine::stats();`
`204`	`211`	`$remaining = (int)($stats['coroutine_num'] ?? 0);`
`205`	`212`	`if ($remaining > 2) {`
	`213`	`+ // Use error_log during shutdown to ensure message is captured`
`206`	`214`	`error_log("Warning: {$remaining} coroutines still active");`
`207`	`215`	`}`
`208`	`216`	`}`