J'ai donc créé une class qui hérite de cette classe: MultiLoggerCollection

<?php
/**
 * Manages the Multi loggers of the application
 *
 * @package lib.core
 * @subpackage logging
 *
 * @author nsurian
 *
 */

class MultiLoggerCollection extends sfAggregateLogger
{
    /**
     * Logs a alert message.
     *
     * @param string $message The message to write in the log file.
     * @param string $name The name of the logger where dispatch the message.
     */

    public function alertM( $message, $name )
    {
        $this->doLogM( $message, $name, sfLogger::ALERT ) ;
    }

    /**
     * Logs a critical message.
     *
     * @param string $message The message to write in the log file.
     * @param string $name The name of the logger where dispatch the message.
     */

    public function criticalM( $message, $name )
    {
        $this->doLogM( $message, $name, sfLogger::CRIT ) ;
    }

    /**
     * Logs a debug message.
     *
     * @param string $message The message to write in the log file.
     * @param string $name The name of the logger where dispatch the message.
     */

    public function debugM( $message, $name )
    {
        $this->doLogM( $message, $name, sfLogger::DEBUG ) ;
    }

    /**
     * Logs a emerg message.
     *
     * @param string $message The message to write in the log file.
     * @param string $name The name of the logger where dispatch the message.
     */

    public function emergM( $message, $name )
    {
        $this->doLogM( $message, $name, sfLogger::EMERG ) ;
    }

    /**
     * Logs a error message.
     *
     * @param string $message The message to write in the log file.
     * @param string $name The name of the logger where dispatch the message.
     */

    public function errM( $message, $name )
    {
        $this->doLogM( $message, $name, sfLogger::ERR ) ;
    }

    /**
     * Returns the logger if exists.
     * @param String $name
     * @return mixed Logger if exists or NULL
     */

    public function getLogger( $name )
    {
        $loggers = $this->getLoggers() ;
        foreach( $loggers as $logger )
        {
            if( $logger instanceof MultiLogger && $logger->name === $name )
            {
                return $logger;
            }
        }
        $this->log( 'The instance of the logger "' . $name . '" does not exist!', sfLogger::ERR ) ;
        return null ;
    }

    /**
     * Logs a info message.
     *
     * @param string $message The message to write in the log file.
     * @param string $name The name of the logger where dispatch the message.
     */

    public function infoM( $message, $name )
    {
        $this->doLogM( $message, $name, sfLogger::INFO );
    }

    /**
     * Logs a notice message.
     *
     * @param string $message The message to write in the log file.
     * @param string $name The name of the logger where dispatch the message.
     */

    public function noticeM( $message, $name )
    {
        $this->doLogM( $message, $name, sfLogger::NOTICE );
    }

    /**
     * Logs a warning message.
     *
     * @param string $message The message to write in the log file.
     * @param string $name The name of the logger where dispatch the message.
     */

    public function warningM( $message, $name )
    {         $this->doLogM( $message, $name, sfLogger::WARNING );
    }

    /**
     * Dispatch the message to the right log file.
     *
     * @param string $message The message to write in the log file.
     * @param string $name The name of the logger where dispatch the message.
     * @param integer $priority The number of the log priority
     * @return void
     */

    protected function doLogM( $message, $name, $priority )
    {
        $logger = $this->getLogger( $name ) ;
        if( $logger !== null )
        {
            $logger->log( $message . $this->getUserAgent(), $priority ) ;
        }
        else
        {
            $this->log( '[' . $name . ']' . $message . $this->getUserAgent(), $priority );
        }
    }

    /**
     * Return the user agent server info.
     *
     * @return string
     */

    protected function getUserAgent()
    {
        return ' [ USER AGENT: ' . $_SERVER['HTTP_USER_AGENT'] . '; IP: ' . $_SERVER['REMOTE_ADDR'] . ' ] ';
    } }

?>

Chose étrange, je n'ai pas pu surcharger les méthodes de la classe mère pour les adapter à mon model. Symfony me remonte une erreur PHP dans la signature des méthodes.
J'ai donc réécrit les méthodes en leur mettant le suffixe 'M' pour 'MultiLogger'.

Explication de la méthode principale: MultiLogger::doLogM( $message, $name, $priority )
Le paramètre $name permet de récupérer le logger avec la méthode MultiLogger::getLogger( $name ).
Si cette méthode renvoie le logger demandé, alors on peut dispatcher le message vers le bon fichier de log sinon on dispatche vers le fichier principal avec le flag [name] en plus.

La méthode MultiLogger::getLogger( $name ) permet de parcourir la collection de logger et de renvoyé celui recherché s'il existe.
Pour ce faire j'ai étendu la class sfFileLogger comme ceci:

<?php
/**
 * Customize the loggers of the application
 *
 * @package lib.core
 * @subpackage logging
 *
 * @author nsurian
 *
 */

class MultiLogger extends sfFileLogger
{
    /**
     * Defines the name of the logger.
     * @var String
     */
    public $name ;

    /**
     * Initializes this logger.
     *
     * Available options:
     *
     * - name: The name of the logger.
     *
     * @param sfEventDispatcher $dispatcher A sfEventDispatcher instance
     * @param array $options An array of options.
     *
     * @return Boolean true, if initialization completes successfully, otherwise false.
     */

    public function initialize( sfEventDispatcher $dispatcher, $options = array() )
    {
        parent::initialize( $dispatcher, $options ) ;

        if( isset( $options['name'] ) )
        {
            $this->name = $options['name'];
        }
    }
} ?>

Ensuite j'ai personnalisé le fichier factories.yml du répertoire apps/frontend/config:

prod:
  logger:
    class: MultiLoggerCollection
    param:
      level: emerg
      loggers:
        login_notice:
          class: MultiLogger
          param:
           name: login
            level: notice
            file: %SF_LOG_DIR%/%SF_APP%_%SF_ENVIRONMENT%_login.log
        recover_passwd_notice:
          class: MultiLogger
          param:
            name: recover_passwd
            level: notice
            file: %SF_LOG_DIR%/%SF_APP%_%SF_ENVIRONMENT%_recover_passwd.log
        signin_notice:
          class: MultiLogger
          param:
            name: signin
            level: notice
            file: %SF_LOG_DIR%/%SF_APP%_%SF_ENVIRONMENT%_signin.log

Puis j'appelle les loggers qui m'intéressent dans les actions comme ceci:

public class mainActions extends sfActions
{
    public function executeLogin( sfWebRequest $request )
    {
        $login = $request->getParameter( 'login' ) ;
        $pass = $request->getParameter( 'pass' ) ;

        // Check to login in the database.
        if( User::login( $login, $pass ) === false )
        {
            // Write errors in the form.
            $this->message = <<<EOF
Login failed with the login '$login' and the pass '$pass'
EOF;
            // Write the error in log file if logging enabled.
            if( sfConfig::get( 'sf_logging_enabled' ) )
            {
                 $logger = $this->getLogger() ;
                $logger->noticeM( $this->message, MultiLoggerList::LOGIN ) ;
            }
        }
    }
}

Pour plus de souplesse et de sécurité, j'ai ajouté une classe d'énumération des loggers dans la package logging:

<?php
/**
 * Customize the loggers of the application
 *
 * @package lib.core
 * @subpackage logging
 *
 * @author nsurian
 *
 */

class MultiLoggerList
{
    /**
     * Defines the name of the logger for the login.
     * @var String
     */

    const LOGIN = "login" ;

    /**
     * Defines the name of the logger for the recover password.
     * @var String
     */

    const RECOVER_PASSWD = "recover_passwd" ;

    /**
     * Defines the name of the logger for the signin.
     * @var String
     */

    const SIGNIN = "signin" ;
}
?>

Il est très facile de rajouter un fichier de log par la suite.


Enfin il faut s'assurer que les logs sont activés dans le fichiers apps/frontend/config/settings.yml:

prod:
  .settings:
    no_script_name: on
    logging_enabled: on
    error_reporting: <?php echo (E_PARSE | E_COMPILE_ERROR | E_ERROR | E_CORE_ERROR | E_USER_ERROR)."\n" ?>

Et voilà, il me reste plus qu'a configurer la rotation des logs en ligne de commande et le tour et joué.

php symfony log:rotate frontend prod --period=7 --history=10

Pour plus de détail la documentation symfony est très complète: http://www.symfony-project.org/book/1_2/16-Application-Management-Tools

Enjoy ;)