web-dev-qa-db-fra.com

Comment écrire sur la console depuis un contrôleur Laravel?

J'ai donc un Laravel:

class YeahMyController extends BaseController {
    public function getSomething() {
        Console::info('mymessage'); // <-- what do I put here?
        return 'yeahoutputthistotheresponse';
    }
}

Actuellement, j'utilise l'application avec artisan (qui exploite le serveur Web de développement intégré de PHP sous le capot):

php artisan serve

J'aimerais enregistrer les messages de la console dans le pipe STDOUT pour le processus artisan.

phplaravelloggingconsole
38
Jrop

Aha!

Cela peut être fait avec la fonction PHP suivante:

error_log('Some message here.');

Vous avez trouvé la réponse ici: Imprimez quelque chose dans PHP)

58
Jrop

La question concerne le service via artisan et la réponse de Jrop est donc idéale dans ce cas. C'est à dire, error_log connexion au journal Apache.

Cependant, si vous utilisez un serveur Web standard, utilisez simplement les fonctions de journalisation spécifiques Laravel:

\Log::info('This is some useful information.');

\Log::warning('Something could be going wrong.');

\Log::error('Something is really going wrong.');

Avec les versions actuelles de laravel comme ceci pour info:

info('This is some useful information.');

Cela enregistre dans le fichier journal de Laravel situé à l'adresse /laravel/storage/logs/laravel-<date>.log (laravel 5.0). Surveillez le journal - linux/osx: tail -f /laravel/storage/logs/laravel-<date>.log

66
wired00

Je n'ai pas essayé cela moi-même, mais un rapide aperçu de la bibliothèque suggère que vous puissiez le faire:

$output = new Symfony\Component\Console\Output\ConsoleOutput();
$output->writeln("<info>my message</info>");

Je ne pouvais pas trouver de raccourci pour cela, alors vous voudrez probablement créer une façade pour éviter les doublons.

18
Dave Morrissey

C'est très simple.

Vous pouvez l'appeler de n'importe où dans APP.

$out = new \Symfony\Component\Console\Output\ConsoleOutput();
$out->writeln("Hello from Terminal");
11
Googlian

Pour mieux expliquer la réponse de Dave Morrissey, j’ai fait ces étapes pour envelopper avec la classe Console Output dans une façade laravel.

1) Créez une façade dans votre dossier de préférence (dans mon cas, l'application\Façades):

class ConsoleOutput extends Facade {

 protected static function getFacadeAccessor() { 
     return 'consoleOutput';
 }

}

2) Enregistrez un nouveau fournisseur de service dans app\Providers comme suit:

class ConsoleOutputServiceProvider extends ServiceProvider
{

 public function register(){
    App::bind('consoleOutput', function(){
        return new \Symfony\Component\Console\Output\ConsoleOutput();
     });
 }

}

3) Ajoutez tous ces éléments dans le fichier config\app.php en enregistrant le fournisseur et l’alias.

 'providers' => [
   //other providers
    App\Providers\ConsoleOutputServiceProvider::class
 ],
 'aliases' => [
  //other aliases
   'ConsoleOutput' => App\Facades\ConsoleOutput::class,
 ],

Voilà, maintenant, à n'importe quel endroit de votre application Laravel, appelez simplement votre méthode de cette façon:

ConsoleOutput::writeln('hello');

J'espère que cela vous aidera.

9
Tudor

Si vous voulez vous connecter à STDOUT, vous pouvez utiliser l’un des moyens suivants: Laravel fournit, par exemple (à partir de la réponse de wired00):

Log::info('This is some useful information.');

La magie STDOUT peut être réalisée avec les éléments suivants (vous configurez le message fichier où les messages info sont envoyés):

Log::useFiles('php://stdout', 'info');

Attention: ceci est strictement pour le débogage. Ne pas utiliser rien en production, vous ne comprenez pas bien.

5
vbence

Je voulais que mes informations de journalisation soient envoyées à stdout, car il est facile de demander au service de conteneur (ECS) d'Amazon de collecter stdout et de l'envoyer à CloudWatch Logs. Donc, pour que cela fonctionne, j'ai ajouté une nouvelle entrée stdout à mon config/logging.php fichier comme ceci:

    'stdout' => [
        'driver' => 'monolog',
        'handler' => StreamHandler::class,
        'with' => [
            'stream' => 'php://stdout',
        ],
        'level' => 'info',
    ],

Ensuite, j'ai simplement ajouté "stdout" comme l'un des canaux du canal de journalisation de la pile:

    'default' => env('LOG_CHANNEL', 'stack'),

    'stack' => [
        'driver' => 'stack',
        'channels' => ['stdout', 'daily'],
    ],

De cette façon, je reçois toujours des journaux dans un fichier pour le développement local (ou même sur l'instance si vous pouvez y accéder), mais plus important encore, ils sont envoyés à la sortie standard qui est enregistrée dans CloudWatch Logs.

3
alexkb

Si vous voulez le commande fantaisie IO de Laravel (comme le style, la demande et le tableau)), alors j'ai créé cette classe ci-dessous

Instructions

Je n'ai pas entièrement vérifié partout que c'EST LA solution la plus propre, etc., mais cela fonctionne bien ( mais je ne l'ai testée que dans un scénario de test unitaire, sous Laravel 5.5).

Donc, vous pouvez probablement l'utiliser comme bon vous semble:

$cmd = new ConsoleCommand;

$cmd->error("Aw snap!");
$cmd->table($headers, $rows);
$answer = $cmd->ask("Tell me, what do you need?");

//even Symfony's progress bar
$cmd->outputStyle->progressStart(5);  //set n = 100% (here 100% is 5 steps)
$cmd->outputStyle->progressAdvance(); //you can call it n times
$cmd->outputStyle->progressFinish();  //set to 100%

Bien sûr, vous pouvez également envelopper votre propre façade, certains singleton statiques, etc., ou comme vous le souhaitez.

La classe elle-même

class ConsoleCommand extends \Illuminate\Console\Command
{
    protected $name = 'NONEXISTENT';
    protected $hidden = true;

    public $outputSymfony;
    public $outputStyle;

    public function __construct($argInput = null)
    {
        parent::__construct();

        $this->input = new \Symfony\Component\Console\Input\StringInput($argInput);

        $this->outputSymfony = new \Symfony\Component\Console\Output\ConsoleOutput();
        $this->outputStyle = new \Illuminate\Console\OutputStyle($this->input, $this->outputSymfony);

        $this->output = $this->outputStyle;
    }

}
2
Tomeg

Un peu en retard à cela ... Je suis surpris que personne n'ait mentionné le composant VarDumper de Symfony que Laravel inclut, en partie, ses dd() (et fonctions moins connues, dump()).

$dumpMe = new App\User([ 'name' => 'Cy Rossignol' ]);

(new Symfony\Component\VarDumper\Dumper\CliDumper())->dump( 
    (new Symfony\Component\VarDumper\Cloner\VarCloner())->cloneVar($dumpMe)
);

Un peu plus de code est nécessaire, mais en retour, nous obtenons un format Nice lisible dans la console, ce qui est particulièrement utile pour le débogage d'objets ou de tableaux complexes:

App\User {#17
  #attributes: array:1 [
    "name" => "Cy Rossignol"
  ]
  #fillable: array:3 [
    0 => "name"
    1 => "email"
    2 => "password"
  ]
  #guarded: array:1 [
    0 => "*"
  ]
  #primaryKey: "id"
  #casts: []
  #dates: []
  #relations: []
  ... etc ...
}

Pour aller plus loin, nous pouvons même coloriser la sortie! Ajoutez cette fonction d'assistance au projet pour enregistrer des opérations de frappe:

function toConsole($var) 
{
    $dumper = new Symfony\Component\VarDumper\Dumper\CliDumper();
    $dumper->setColors(true);

    $dumper->dump((new Symfony\Component\VarDumper\Cloner\VarCloner())->cloneVar($var));
}

Si nous exécutons l'application derrière un serveur Web complet (comme Apache ou Nginx - pas artisan serve), Nous pouvons modifier légèrement cette fonction pour envoyer la sortie prédéfinie du dumper dans le journal (généralement stockage/logs/laravel.log):

function toLog($var) 
{
    $lines = [ 'Dump:' ];
    $dumper = new Symfony\Component\VarDumper\Dumper\CliDumper();
    $dumper->setColors(true);
    $dumper->setOutput(function ($line) use (&$lines) { 
        $lines[] = $line;
    });

    $dumper->dump((new Symfony\Component\VarDumper\Cloner\VarCloner())->cloneVar($var));

    Log::debug(implode(PHP_EOL, $lines));
}

... et, bien sûr, regardez le journal en utilisant:

$ tail -f storage/logs/laravel.log

La error_log() de PHP fonctionne bien pour une inspection rapide et ponctuelle de valeurs simples, mais les fonctions présentées ci-dessus simplifient grandement le débogage de certaines classes plus complexes de Laravel.

1
Cy Rossignol

Vous pouvez utiliser echo et le préfixe "\ 033", simplement:

Artisan::command('mycommand', function () {
   echo "\033======== Start ========\n";
});

Et changez le texte de couleur:

if (App::environment() === 'production') {
    echo "\033[0;33m======== WARNING ========\033[0m\n";
}
0
Top-tompak