Symfony 2 exceptions de journalisation dans la console

Question

Pourquoi les erreurs de tâches de la console ne sont pas connecté. Par exemple Exception sur avertissement php:

[ErrorException]
Notice: Undefined offset: 1 in /var/www/project/vendor/doctrine/lib/Doctrine/ORM/Query.php line 298

Je vois ce imprimé dans stdout, mais rien connecté aux journaux. (I utiliser les commandes de la console dans cron). Dans web ces exceptions enregistrées avec backtrace, qui dans cette situation est plus que juste d'information cette exception.

En tant que solution: Je joins toutes les fonctions de processus dans try..catch bloc et enregistrer les manuellement backtrace

.

Quelqu'un est-il savoir comment activer ou la journalisation de configuration dans les tâches de la console. Je pense que ce doit être quelque part.

Answer 1

Comme je l'ai suivi le code, il est en fait pas une telle option pour activer la journalisation des commandes. Dans app/console est ce code:

use Symfony\Bundle\FrameworkBundle\Console\Application;

...

$application = new Application($kernel);
$application->run();

Il appelle Symfony\Component\Console\Application::run() où il y a bloc try / catch. PRÉCONISÉE exception renderException() est appelée, mais pas l'exploitation forestière arrive partout.

Notez également que app/console toujours par les sorties par défaut avec le code d'erreur en cas d'exception.

Vous pouvez vous créer votre propre classe Application extension Symfony\Bundle\FrameworkBundle\Console\Application et modifier app/console à utiliser. Que vous pouvez remplacer la méthode de run() et ajoutez l'enregistrement des erreurs.

Vous pouvez modifier seulement app/console et poignée erros comme ceci:

// $application->run();
$application->setCatchExceptions(false);
try {
    $output = new Symfony\Component\Console\Output\ConsoleOutput();
    $application->run(null, $output);
} catch (Exception $e) {
    ... error logging ...

    $application->renderException($e, $output);

    $statusCode = $e->getCode();
    $statusCode = is_numeric($statusCode) && $statusCode ? $statusCode : 1;
    exit($statusCode);
}

Answer 2

Si c'est la question de comprendre simplement ce qui a mal tourné où, vous pouvez exécuter votre application avec le drapeau bavard -v ou --verbose, qui sera imprimer automatiquement la trace d'exception sur l'écran.

Answer 3

TL; DR : il suffit d'utiliser ce paquet

Du livre de cuisine :

Pour obtenir l'application de la console pour se connecter automatiquement des exceptions non rattrapées pour toutes vos commandes, vous pouvez utiliser des événements de la console.

Créer un service étiqueté comme un écouteur d'événement pour l'événement console.exception:

# services.yml
services:
    kernel.listener.command_dispatch:
    class: Acme\DemoBundle\EventListener\ConsoleExceptionListener
    arguments:
        logger: "@logger"
    tags:
        - { name: kernel.event_listener, event: console.exception }

Vous pouvez maintenant faire ce que vous voulez avec des exceptions de la console:

<?php
// src/Acme/DemoBundle/EventListener/ConsoleExceptionListener.php
namespace Acme\DemoBundle\EventListener;

use Symfony\Component\Console\Event\ConsoleExceptionEvent;
use Psr\Log\LoggerInterface;

class ConsoleExceptionListener
{
    private $logger;

    public function __construct(LoggerInterface $logger)
    {
    $this->logger = $logger;
    }

    public function onConsoleException(ConsoleExceptionEvent $event)
    {
    $command = $event->getCommand();
    $exception = $event->getException();

    $message = sprintf(
        '%s: %s (uncaught exception) at %s line %s while running console command `%s`',
        get_class($exception),
        $exception->getMessage(),
        $exception->getFile(),
        $exception->getLine(),
        $command->getName()
    );

    $this->logger->error($message);
    }
}

Answer 4

Une autre façon est d'implémenter votre propre classe OutputInterface personnalisée et remplacer la méthode writeln pour enregistrer l'erreur là. Ensuite, utilisez la nouvelle classe lorsque vous exécutez la méthode run().

De cette façon, vous pouvez adhérer à la Open / Close Principe de Symfony sans avoir à modifier les classes de base et encore atteindre vos objectifs.