Ability to log all errors in development mode

[maryo]

We'd like to be able to log all errors in development mode so they are both displayed in the bar but also logged using (our instance of) ILogger.
This would help up us not only when debugging errors during AJAX calls or some server-server requests, there are multiple use cases where this is useful (we have a special page with links to all older bluescreens).

Currently, the are DevelopmentStrategy and ProductionStrategy classes but they are both internal and final. I understand it is for a reason but...
In 2.9.7, the internal method getStrategy has no return typehint so it is still possible to do some black magic like decorating the strategy to do both 😇 👿.

\Closure::bind(
    static function () {
        Debugger::$strategy[false] = new LoggingDevelopmentStrategy(Debugger::getStrategy());
    },
    null,
    Debugger::class
)();

Since 2.10.0 the getStrategy has ProductionStrategy|DevelopmentStrategy return typehint so this ugly hack is not possible anymore.
Wouldn't it be possible to support such a feature or somehow make this ugly hack possible again 😇?

[dg]

Thanks for the detailed writeup. I agree this is a legitimate use case (especially the archive of older bluescreens scenario).

For 2.x I'd prefer to keep the current strategies internal/final as they are – loosening them now would lock us into the current shape. But for 3.0 I'd like to design a proper extension point for this. A few directions I'm considering:

• making the strategy a public, documented interface so it can be replaced/decorated cleanly;
• or, probably nicer, keeping strategies internal and instead exposing a hook/listener API (e.g. "on bluescreen rendered" / "on error handled") so you can plug logging in without replacing the whole rendering pipeline;
• possibly a first-class "log in development too" switch on Debugger, since that part of your use case seems common enough to deserve a built-in option.

I'm leaning towards the second option combined with the third, but I'd be happy to hear your thoughts – especially what the decorator in your codebase actually does, so the new API covers the real need rather than a guessed one. Leaving this open as a 3.0 candidate.

[maryo]

Thank you.

possibly a first-class "log in development too" switch on Debugger, since that part of your use case seems common enough to deserve a built-in option.

It does exactly this, so for our use case, this third option would be good great enough.

If code helps, I “temporarily” copied ProductionStrategy after return type hints were introduced — without the final keyword (to avoid using bypass-finals outside tests and registered it in the Nette namespace using a classmap) — and then created/registered this class.

class LoggingDevelopmentStrategy extends ProductionStrategy
{
    private DevelopmentStrategy $developmentStrategy;

    public function __construct(DevelopmentStrategy $developmentStrategy)
    {
        $this->developmentStrategy = $developmentStrategy;
    }

    public static function register(): void
    {
        if (!Debugger::isEnabled()) {
            throw new LogicException('Unable to register development Tracy logging strategy because Tracy Debugger is not enabled.');
        }

        $strategy = Debugger::getStrategy();

        if ($strategy instanceof self) {
            throw new LogicException('Logging development strategy is already registered.');
        } elseif ($strategy instanceof ProductionStrategy) {
            throw new LogicException('Unable to register development Tracy logging strategy because Tracy is in production mode.');
        }

        \Closure::bind(
            static function () use ($strategy) {
                $developmentStrategy = &Debugger::$strategy[false];
                $developmentStrategy = new LoggingDevelopmentStrategy($strategy);
            },
            null,
            Debugger::class,
        )();
    }

    public function initialize(): void
    {
        $this->developmentStrategy->initialize();
        parent::initialize();
    }

    public function handleException(Throwable $exception, bool $firstTime): void
    {
        $this->developmentStrategy->handleException($exception, $firstTime);
        parent::handleException($exception, false);
    }

    public function handleError(int $severity, string $message, string $file, int $line): void
    {
        $this->developmentStrategy->handleError($severity, $message, $file, $line);

        // Errors in strict mode are converted to exceptions, so they're also logged in self::handleException.
        // See DevelopmentStrategy->handleError.
        if (
            (is_bool(Debugger::$strictMode) ? Debugger::$strictMode : (Debugger::$strictMode & $severity))
            && !isset($_GET['_tracy_skip_error'])
        ) {
            return;
        }

        parent::handleError($severity, $message, $file, $line);
    }

    public function sendAssets(): bool
    {
        return $this->developmentStrategy->sendAssets();
    }

    public function renderLoader(): void
    {
        $this->developmentStrategy->renderLoader();
    }

    public function renderBar(): void
    {
        $this->developmentStrategy->renderBar();
    }
}