Bound the debug data kept in memory, log to files from the console, record the app type #593

Summary

Since #539 the debug toolbar reads its tabs at render time from data the packages keep in memory: the debug-mode logger's messages, the mailer's transport log and the database's query log. Nothing bounds them. In a web request the process ends after the response, so they stay small, but a console command or worker in debug mode keeps every log line, every SMTP line and every query for its whole run, and no toolbar ever reads them. Its log lines are never written to a file either.

Bound the logger and the mailer buffers with a limit from each package's own config, keep the console's log lines in the log file, and keep Idiorm's query log off outside debug mode. For that the app context records whether the run is the web app or the console, read through is_web_app() and is_console_app(), and the error handler uses the same fact instead of checking PHP_SAPI.

Current state (checked on master)

Proposed change

1. The app context knows its type. AppContext::__construct(string $baseDir, DiContainer $container, string $type) takes AppType::WEB or AppType::CONSOLE, and getType() returns it. AppFactory passes the type it creates; WebContext and ConsoleContext copy it. Two helpers in src/App/Helpers/app.php, is_web_app() and is_console_app(), read it, so no package compares the type itself.
2. The error handler uses it. ErrorHandler::handleException() chooses the console output when is_console_app() and the web page otherwise. A request served by php -S (php qt serve) is the web app, as before.
3. The console logs to files in debug mode. LoggerFactory forces the message adapter only when is_web_app(). A console command in debug mode logs to the configured adapter, still at every level.
4. The debug-mode logger keeps its last messages. MessageAdapter keeps the last logging.message.limit messages (default 1000) and drops the oldest; 0 means no limit. It trims after each message.
5. The mailer's transport log keeps its last lines. At the start of each send(), the transport log is cut to its last mailer.transport_log_limit lines (default 1000, 0 means no limit). The start of send() is the one point every send reaches, also after a previous send threw, so the log holds at most the limit plus the lines of the send in progress. Both writers stay as they are.
6. The query log is off outside debug mode. Idiorm's logging option reads is_debug_mode(), which converts the text "false" from .env to false. In debug mode the web app and the console keep their query log as before, so Database::lastQuery(), queryLog() and the toolbar's queries tab work in both.

Each package reads only its own config key, so the logger and the mailer stay independent of each other.

Out of scope

• Clearing the buffers per request or per job in long-running processes belongs to the deferred and long-running execution work (Possibility to run defer tasks after response #168).
• Capping Idiorm's query log. In debug mode it still keeps every query of a long-running command. Idiorm calls its own logging through self:: and keeps the log in a protected static property, so it cannot be capped from outside; that needs Quantum to record the queries itself, as a follow-up.

Behavior changes

The toolbar's tabs read the same sources as before; they change only once a limit is reached.

Breaking changes

• AppContext::__construct() takes a third, required $type argument. Code that goes through AppFactory is unaffected.

Tests

• AppContext::getType() returns the given type; AppFactory creates a web and a console context with the right type; WebContext and ConsoleContext keep it.
• is_web_app() and is_console_app() are each true for their own type and false for the other.
• ErrorHandler::handleException() writes the console output for a console context and renders the web page for a web context.
• LoggerFactory in debug mode resolves message for the web app and the configured or requested adapter for the console.
• MessageAdapter keeps the last limit messages in order, keeps everything with 0, and uses 1000 without the key.
• The transport log is cut to its last limit lines at the next send, keeps everything with 0, and never cuts the lines of the send in progress.
• Idiorm's logging option is on in debug mode for the web app and the console, and off outside debug mode, also when debug mode is the text "false".

Acceptance criteria

• a console command in debug mode writes its log lines to the configured log file
• the debug-mode logger and the mailer's transport log are bounded by their own config keys
• Idiorm keeps no query log outside debug mode
• no PHP_SAPI check is left in src; the web-or-console decision goes through is_web_app() or is_console_app()
• composer test, composer cs:check, composer phpstan and composer rector:check pass

Notes

Relevant code:

• src/App/AppContext.php, src/App/Factories/AppFactory.php, src/App/Adapters/Web/WebContext.php, src/App/Adapters/Console/ConsoleContext.php, src/App/Helpers/app.php
• src/Tracer/ErrorHandler.php
• src/Logger/Factories/LoggerFactory.php, src/Logger/Adapters/MessageAdapter.php
• src/Mailer/Traits/MailerTrait.php
• src/Database/Adapters/Idiorm/IdiormDbal.php

Follows #539.