Your IP : 192.168.165.1
<?php
// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
/**
* Task log manager.
*
* @package core
* @category task
* @copyright 2018 Andrew Nicols <andrew@nicols.co.uk>
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
namespace core\task;
defined('MOODLE_INTERNAL') || die();
/**
* Task log manager.
*
* @copyright 2018 Andrew Nicols <andrew@nicols.co.uk>
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
class logmanager {
/** @var int Do not log anything */
const MODE_NONE = 0;
/** @var int Log all tasks */
const MODE_ALL = 1;
/** @var int Only log fails */
const MODE_FAILONLY = 2;
/** @var int The default chunksize to use in ob_start */
const CHUNKSIZE = 1;
/**
* @var \core\task\task_base The task being logged.
*/
protected static $task = null;
/**
* @var \stdClass Metadata about the current log
*/
protected static $taskloginfo = null;
/**
* @var \resource The current filehandle used for logging
*/
protected static $fh = null;
/**
* @var string The path to the log file
*/
protected static $logpath = null;
/**
* @var bool Whether the task logger has been registered with the shutdown handler
*/
protected static $tasklogregistered = false;
/**
* @var int The level of output buffering in place before starting.
*/
protected static $oblevel = null;
/**
* @var bool Output logged content to screen.
*/
protected static $outputloggedcontent = true;
/**
* Create a new task logger for the specified task, and prepare for logging.
*
* @param \core\task\task_base $task The task being run
*/
public static function start_logging(task_base $task) {
global $CFG, $DB;
if (!self::should_log()) {
return;
}
// We register a shutdown handler to ensure that logs causing any failures are correctly disposed of.
// Note: This must happen before the per-request directory is requested because the shutdown handler deletes the logfile.
if (!self::$tasklogregistered) {
\core_shutdown_manager::register_function(function() {
// These will only actually do anything if capturing is current active when the thread ended, which
// constitutes a failure.
\core\task\logmanager::finalise_log(true);
});
// Create a brand new per-request directory basedir.
get_request_storage_directory(true, true);
self::$tasklogregistered = true;
}
if (self::is_current_output_buffer()) {
// We cannot capture when we are already capturing.
throw new \coding_exception('Logging is already in progress for task "' . get_class(self::$task) . '". ' .
'Nested logging is not supported.');
}
// Store the initial data about the task and current state.
self::$task = $task;
self::$taskloginfo = (object) [
'dbread' => $DB->perf_get_reads(),
'dbwrite' => $DB->perf_get_writes(),
'timestart' => microtime(true),
];
// For simplicity's sake we always store logs on disk and flush at the end.
self::$logpath = make_request_directory() . DIRECTORY_SEPARATOR . "task.log";
self::$fh = fopen(self::$logpath, 'w+');
// Note the level of the current output buffer.
// Note: You cannot use ob_get_level() as it will return `1` when the default output buffer is enabled.
if ($obstatus = ob_get_status()) {
self::$oblevel = $obstatus['level'];
} else {
self::$oblevel = null;
}
self::$outputloggedcontent = !empty($CFG->task_logtostdout);
// Start capturing output.
ob_start([\core\task\logmanager::class, 'add_line'], self::CHUNKSIZE);
}
/**
* Whether logging is possible and should be happening.
*
* @return bool
*/
protected static function should_log() : bool {
global $CFG;
// Respect the config setting.
if (isset($CFG->task_logmode) && empty($CFG->task_logmode)) {
return false;
}
$loggerclass = self::get_logger_classname();
if (empty($loggerclass)) {
return false;
}
return $loggerclass::is_configured();
}
/**
* Return the name of the logging class to use.
*
* @return string
*/
public static function get_logger_classname() : string {
global $CFG;
if (!empty($CFG->task_log_class)) {
// Configuration is present to use an alternative task logging class.
return $CFG->task_log_class;
}
// Fall back on the default database logger.
return database_logger::class;
}
/**
* Whether this task logger has a report available.
*
* @return bool
*/
public static function has_log_report() : bool {
$loggerclass = self::get_logger_classname();
return $loggerclass::has_log_report();
}
/**
* Whether to use the standard settings form.
*/
public static function uses_standard_settings() : bool {
$classname = self::get_logger_classname();
if (!class_exists($classname)) {
return false;
}
if (is_a($classname, database_logger::class, true)) {
return true;
}
return false;
}
/**
* Get any URL available for viewing relevant task log reports.
*
* @param string $classname The task class to fetch for
* @return \moodle_url
*/
public static function get_url_for_task_class(string $classname) : \moodle_url {
$loggerclass = self::get_logger_classname();
return $loggerclass::get_url_for_task_class($classname);
}
/**
* Whether we are the current log collector.
*
* @return bool
*/
protected static function is_current_output_buffer() : bool {
if (empty(self::$taskloginfo)) {
return false;
}
if ($ob = ob_get_status()) {
return 'core\\task\\logmanager::add_line' == $ob['name'];
}
return false;
}
/**
* Whether we are capturing at all.
*
* @return bool
*/
protected static function is_capturing() : bool {
$buffers = ob_get_status(true);
foreach ($buffers as $ob) {
if ('core\\task\\logmanager::add_line' == $ob['name']) {
return true;
}
}
return false;
}
/**
* Finish writing for the current task.
*
* @param bool $failed
*/
public static function finalise_log(bool $failed = false) {
global $CFG, $DB, $PERF;
if (!self::should_log()) {
return;
}
if (!self::is_capturing()) {
// Not capturing anything.
return;
}
// Ensure that all logs are closed.
$buffers = ob_get_status(true);
foreach (array_reverse($buffers) as $ob) {
if (null !== self::$oblevel) {
if ($ob['level'] <= self::$oblevel) {
// Only close as far as the initial output buffer level.
break;
}
}
// End and flush this buffer.
ob_end_flush();
if ('core\\task\\logmanager::add_line' == $ob['name']) {
break;
}
}
self::$oblevel = null;
// Flush any remaining buffer.
self::flush();
// Close and unset the FH.
fclose(self::$fh);
self::$fh = null;
if ($failed || empty($CFG->task_logmode) || self::MODE_ALL == $CFG->task_logmode) {
// Finalise the log.
$loggerclass = self::get_logger_classname();
$loggerclass::store_log_for_task(
self::$task,
self::$logpath,
$failed,
$DB->perf_get_reads() - self::$taskloginfo->dbread,
$DB->perf_get_writes() - self::$taskloginfo->dbwrite - $PERF->logwrites,
self::$taskloginfo->timestart,
microtime(true)
);
}
// Tidy up.
self::$logpath = null;
self::$taskloginfo = null;
}
/**
* Flush the current output buffer.
*
* This function will ensure that we are the current output buffer handler.
*/
public static function flush() {
// We only call ob_flush if the current output buffer belongs to us.
if (self::is_current_output_buffer()) {
ob_flush();
}
}
/**
* Add a log record to the task log.
*
* @param string $log
* @return string
*/
public static function add_line(string $log) : string {
if (empty(self::$taskloginfo)) {
return $log;
}
if (empty(self::$fh)) {
return $log;
}
if (self::is_current_output_buffer()) {
fwrite(self::$fh, $log);
}
if (self::$outputloggedcontent) {
return $log;
} else {
return '';
}
}
}