php Monolog-Handler-RotatingFileHandler类(方法)实例源码

public function __construct($name = 'PHPUnit', $level = 'debug')
 {
     /**
      * Filter growl notifications and send only
      * - test failures ($handerLevel = Logger::NOTICE; see GrowlHandler constructor)
      * - summary of test suites (message "Results OK ...", or "Results KO ..."
      */
     $filters = array(function ($record, $handlerLevel) {
         if ($record['level'] > $handlerLevel) {
             return true;
         }
         return preg_match('/^Results/', $record['message']) === 1;
     });
     $stream = new RotatingFileHandler(__DIR__ . DIRECTORY_SEPARATOR . 'monologTestListener.log', 0, Logger::toMonologLevel($level));
     $stream->setFilenameFormat('{filename}-{date}', 'Ymd');
     $handlers = array($stream);
     try {
         // be notified only for test suites and test failures
         $growl = new GrowlHandler(array(), Logger::NOTICE);
         $handlers[] = new CallbackFilterHandler($growl, $filters);
     } catch (\Exception $e) {
         // Growl server is probably not started
         echo $e->getMessage(), PHP_EOL, PHP_EOL;
     }
     parent::__construct($name, $handlers);
 }

public function terminate($request, $response)
 {
     $log = new Logger('HTTP');
     $handler = new RotatingFileHandler(config('laravelmiddlewarelogger.options.file'), Logger::INFO);
     $handler->setFormatter(new LineFormatter("[%datetime%] %channel%.%level_name%: %message% %context%\n\n"));
     $log->pushHandler($handler);
     if (config('laravelmiddlewarelogger.options.enabled')) {
         $inputs = $request->input();
         if (!empty($inputs)) {
             $inputSafe = config('laravelmiddlewarelogger.options.input_safe');
             foreach ($inputSafe as $safe) {
                 if (!empty($inputs[$safe])) {
                     $inputs[$safe] = '[*** SENSOR ***]';
                 }
             }
         }
         $request_array = ['method' => $request->method(), 'full-url' => $request->fullUrl(), 'client-ip' => $request->ip(), 'user-agent' => $request->header('user-agent'), 'query-string' => $request->query(), 'inputs' => $inputs];
         $response_array = [];
         if (config('laravelmiddlewarelogger.options.log_response')) {
             $response_array = ['status' => $response->status(), 'content' => ''];
             json_decode($response->content());
             if (json_last_error() == JSON_ERROR_NONE) {
                 $response_array['content'] = $response->content();
             }
         }
         $log->addInfo('REQUEST', $request_array);
         $log->addInfo('RESPONSE', $response_array);
     }
 }

public function testReuseCurrentFile()
 {
     $log = __DIR__ . '/Fixtures/foo-' . date('Y-m-d') . '.rot';
     file_put_contents($log, "foo");
     $handler = new RotatingFileHandler(__DIR__ . '/Fixtures/foo.rot');
     $handler->write(array('message' => 'test'));
     $this->assertEquals('footest', file_get_contents($log));
 }

private function setHande()
 {
     date_default_timezone_set("PRC");
     self::$log = new Logger('name');
     $rotating = new RotatingFileHandler($this->filepath, $this->log_keepDays, $this->log_level);
     $rotating->setFormatter($this->formatter);
     self::$log->pushHandler($rotating);
 }

public static function configureFileLogs(Monolog $monolog, $filePath)
 {
     $files = new RotatingFileHandler($filePath, 365, Logger::DEBUG, true, 0666);
     $files->setFormatter(new HtmlFormatter());
     $files->pushProcessor(new WebProcessor());
     $files->pushProcessor(new IntrospectionProcessor(Logger::DEBUG));
     $monolog->pushHandler($files);
 }

public static function init($channel, $filename)
 {
     $logger = new MongoLog($channel);
     $stream = new RotatingFileHandler($filename, 0, MongoLog::DEBUG);
     $stream->setFormatter(new LineFormatter("%datetime% [%channel%] %level_name% %message% %context%\n", "Y-m-d H:i:s"));
     $logger->pushHandler($stream);
     static::$object = $logger;
 }

/**
  * Class constructor
  *
  * @param string $loggerName Logger name (the logging channel)
  * @param int $logLevel The minimum logging level at logging handler will be triggered
  * @param string $fileName Log file name
  */
 private function __construct($loggerName = DEFAULT_LOGGER_NAME, $logLevel = MIN_LOG_LEVEL, $fileName = DEFAULT_LOG_PATH . DEFAULT_LOG_FILE)
 {
     $fullLogFilePath = $fileName;
     $formatter = new LineFormatter(null, null, false, true);
     $this->_logger = new Logger($loggerName);
     $handler = new RotatingFileHandler($fullLogFilePath, MAX_LOG_FILES_TO_KEEP, $logLevel);
     $handler->setFormatter($formatter);
     $this->_logger->pushHandler($handler);
 }

private function logger()
 {
     $log = new Logger("slim");
     $formatter = new LineFormatter("[%datetime%] [%level_name%]: %message%\n");
     $rotating = new RotatingFileHandler(__DIR__ . "/../../logs/slim.log", 0, Logger::DEBUG);
     $rotating->setFormatter($formatter);
     $log->pushHandler($rotating);
     return new MonologSQLLogger($log);
 }

public function testReuseCurrentFile()
 {
     $log = __DIR__ . '/Fixtures/foo-' . date('Y-m-d') . '.rot';
     file_put_contents($log, "foo");
     $handler = new RotatingFileHandler(__DIR__ . '/Fixtures/foo.rot');
     $handler->setFormatter($this->getIdentityFormatter());
     $handler->handle($this->getRecord());
     $this->assertEquals('footest', file_get_contents($log));
 }

/**
  * @return array
  */
 public function addDefaultLoggerDataProvider()
 {
     $logHandler1 = new RotatingFileHandler(Http::DEFAULT_LOG_FILE_NAME);
     $logHandler1->setFormatter(new LineFormatter(Http::DEFAULT_LOG_LINE_FORMAT, null, true));
     $logHandler2 = new RotatingFileHandler('fileName');
     $logHandler2->setFormatter(new LineFormatter('%message%', null, true));
     return ['Default params' => ['fileName' => null, 'lineFormat' => null, 'messageFormat' => null, 'logLevel' => LogLevel::INFO, 'logger' => new Logger('Logger', [$logHandler1]), 'messageFormatter' => new MessageFormatter(Http::DEFAULT_LOG_MESSAGE_FORMAT), 'middlewareCallback' => function () {
     }], 'Custom params' => ['fileName' => 'fileName', 'lineFormat' => '%message%', 'messageFormat' => '{code}', 'logLevel' => LogLevel::NOTICE, 'logger' => new Logger('Logger', [$logHandler2]), 'messageFormatter' => new MessageFormatter('{code}'), 'middlewareCallback' => function () {
     }]];
 }

private function configureLogger()
 {
     $dateFormat = 'Y-m-d H:i:s';
     $logFormat = "%datetime% %level_name% |[%codeInfo%] %message%\n";
     $formatter = new LineFormatter($logFormat, $dateFormat);
     $rotatingLogger = new RotatingFileHandler($this->logPath, 30);
     $rotatingLogger->setFormatter($formatter);
     $this->pushHandler($rotatingLogger);
     $this->pushProcessor(new IntrospectionProcessor());
 }

/**
  * Here it's using Monolog for writing logs
  *
  * @param int  $level  Log level
  *
  * @return \Monolog\Logger
  */
 public static function getLogger($level = Logger::DEBUG)
 {
     $config = self::getConfig();
     $logger = new Logger($config['log']['channelName']);
     if (!is_dir($config['log']['baseDirectory'])) {
         mkdir($config['log']['baseDirectory'], 0777);
     }
     $handler = new RotatingFileHandler($config['log']['baseDirectory'] . 'messages.log', $config['log']['maxFilesRotation'], $level);
     $handler->setFormatter(new LineFormatter($config['log']['format']));
     $logger->pushHandler($handler);
     return $logger;
 }

/**
  * @param string $stream
  * @param string $path
  * @param mixed $level
  * @param string $format
  * @param $errorPath
  * @return LoggerInterface
  */
 protected function createLogger($stream, $path, $level, $format, $errorPath)
 {
     $defaultHandler = new RotatingFileHandler($path, 0, $level);
     $defaultHandler->setFormatter(new LineFormatter($format));
     $logger = new MonologWrapper($stream, array($defaultHandler));
     if ($path !== $errorPath) {
         $errorHandler = new RotatingFileHandler($errorPath, 0, Logger::ERROR);
         $errorHandler->setFormatter(new LineFormatter($format));
         $logger->pushHandler($errorHandler);
     }
     return $logger;
 }

/**
  * @return Logger
  */
 protected function getJobLogger()
 {
     $jobLogger = new Logger('Jobs');
     $lineFormatter = new LineFormatter("[%datetime%] %message% %context% %extra%\n", null, true, true);
     $streamHandler = new StreamHandler("php://output");
     $streamHandler->setFormatter($lineFormatter);
     $jobLogger->pushHandler($streamHandler);
     $fileHandler = new RotatingFileHandler(storage_path() . '/logs/jobs.log');
     $fileHandler->setFormatter($lineFormatter);
     $jobLogger->pushHandler($fileHandler);
     $jobLogger->debug(static::class);
     return $jobLogger;
 }

public function __construct()
 {
     $this->path = MAIN_DIRECTORY . DIRECTORY_SEPARATOR . 'log';
     if (!is_dir($this->path)) {
         File::createDirectory($this->path, $this->dirMode, true);
     }
     $this->logFile = $this->path . DIRECTORY_SEPARATOR . 'app.log';
     $this->log = new Logger('app');
     $webProcessor = new WebProcessor();
     $format = "[%datetime%] %channel%.%level_name%: %message% %extra.ip% %extra.http_method% %context% %extra%\n";
     $formatter = new LineFormatter($format, null, true);
     $logRotate = new RotatingFileHandler($this->logFile, 45, Logger::INFO, true, 0777);
     $logRotate->setFormatter($formatter);
     $this->log->pushHandler($logRotate);
     $this->log->pushProcessor($webProcessor);
 }

/**
  * @return \Monolog\Logger
  */
 private function getPhealLogger()
 {
     // If its already setup, just return it.
     if (!is_null($this->logger)) {
         return $this->logger;
     }
     // Configure the logger by setting the logfile
     // path and the format logs should be.
     $log_file = storage_path('logs/pheal.log');
     $format = new LineFormatter(null, null, false, true);
     $stream = new RotatingFileHandler($log_file, 30, Logger::INFO);
     $stream->setFormatter($format);
     $this->logger = new Logger('pheal');
     $this->logger->pushHandler($stream);
     return $this->logger;
 }

public function addLogger($name, $logToSystemFile = true)
 {
     if (!empty($this->loggers[$name])) {
         return;
     }
     $this->setFormatter();
     $this->loggers[$name] = new Logger($name);
     if ($logToSystemFile === true) {
         $filename = ROOT_PATH . "/log/" . LogService::$system_logger . ".log";
     } else {
         $filename = ROOT_PATH . "/log/{$name}.log";
     }
     $handler = new RotatingFileHandler($filename);
     $handler->setFormatter($this->formatter);
     // $handler->setFormatter(new JsonFormatter());
     $this->loggers[$name]->pushHandler($handler);
 }

public function register(Application $app)
 {
     $app->register(new \Silex\Provider\MonologServiceProvider());
     $app['monolog.handler'] = function () use($app) {
         $levels = Logger::getLevels();
         if ($app['debug']) {
             $level = Logger::DEBUG;
         } else {
             $level = $app['config']['log']['log_level'];
         }
         $RotateHandler = new RotatingFileHandler($app['monolog.logfile'], $app['config']['log']['max_files'], $level);
         $RotateHandler->setFilenameFormat($app['config']['log']['prefix'] . '{date}' . $app['config']['log']['suffix'], $app['config']['log']['format']);
         $RotateHandler->setFormatter(new LineFormatter(null, null, true));
         $FingerCrossedHandler = new FingersCrossedHandler($RotateHandler, new ErrorLevelActivationStrategy($levels[$app['config']['log']['action_level']]));
         return $FingerCrossedHandler;
     };
     $app['listener.requestdump'] = $app->share(function ($app) {
         return new \Eccube\EventListener\RequestDumpListener($app);
     });
 }

public function register(Container $app)
 {
     $app['logger'] = function () use($app) {
         return $app['monolog'];
     };
     $app['monolog'] = function ($app) {
         $logger = new Logger($app['monolog.name']);
         $rotate = $app['config']->get('app.log.rotate', 'single');
         $logger->pushHandler($app['monolog.handler.' . $rotate]);
         return $logger;
     };
     $app['monolog.formatter'] = function () {
         return new LineFormatter();
     };
     $app['monolog.handler.single'] = function ($app) {
         $handler = new StreamHandler($app['monolog.logfile'], $app['monolog.level']);
         $handler->setFormatter($app['monolog.formatter']);
         return $handler;
     };
     $app['monolog.handler.daily'] = function ($app) {
         $maxFiles = $app['config']->get('app.log.max_files', 5);
         $handler = new RotatingFileHandler($app['monolog.logfile'], $maxFiles, $app['monolog.level']);
         $handler->setFormatter($app['monolog.formatter']);
         return $handler;
     };
     $app['monolog.handler.error'] = function ($app) {
         $handler = new ErrorLogHandler(ErrorLogHandler::OPERATING_SYSTEM, $app['monolog.level']);
         $handler->setFormatter($app['monolog.formatter']);
         return $handler;
     };
     $app['monolog.handler.syslog'] = function ($app) {
         $handler = new SyslogHandler($app['monolog.name'], LOG_USER, $app['monolog.level']);
         $handler->setFormatter($app['monolog.formatter']);
         return $handler;
     };
     $level = $app['config']->get('app.log.level', 'debug');
     $app['monolog.level'] = $this->parseLevel($level);
     $app['monolog.logfile'] = $app['path.logs'] . $this->getSettings('app.log.logfile');
     $app['monolog.name'] = $this->getSettings('monolog.name', 'app.name');
 }

/**
  * @param string             $name       The logging channel
  * @param HandlerInterface[] $handlers   Optional stack of handlers, the first one in the array is called first, etc.
  * @param callable[]         $processors Optional array of processors
  */
 public function __construct($name, array $handlers = array(), array $processors = array())
 {
     parent::__construct($name, $handlers, $processors);
     // set handler
     $elgg_log_level = _elgg_services()->logger->getLevel();
     if ($elgg_log_level == \Elgg\Logger::OFF) {
         // always log errors
         $elgg_log_level = \Elgg\Logger::ERROR;
     }
     $handler = new RotatingFileHandler(elgg_get_data_path() . 'elasticsearch/client.log', 0, $elgg_log_level);
     // create correct folder structure
     $date = date('Y/m/');
     $path = elgg_get_data_path() . "elasticsearch/{$date}";
     if (!is_dir($path)) {
         mkdir($path, 0755, true);
     }
     $handler->setFilenameFormat('{date}_{filename}', 'Y/m/d');
     $this->pushHandler($handler);
     // set logging processor
     $processor = new IntrospectionProcessor();
     $this->pushProcessor($processor);
 }