File "wdev-logger.php"
Full Path: /home/digimqhe/flashdigi.uk/html/wdev-logger/wdev-logger.php
File size: 41.2 KB
MIME-type: text/x-php
Charset: utf-8
<?php
/**
* WPMU DEV Logger - A simple logger module
*
* @version 1.0.2
* @author WPMU DEV (Thobk)
* @package WDEV_Logger
*
* It's created based on Hummingbird\Core\Logger.
* This logger lib will handle the old messages based on the expected size.
* This means, it will try to get rid of the old messages if the file size is larger than the max size of the log file.
*
* Uses:
* $logger = WDEV_Logger::create(array(
* 'max_log_size' => 10,//10MB
* 'expected_log_size_in_percent' => 0.7,//70%
* 'log_dir' => 'uploads/your_plugin_name',
* 'modules' => array(
* 'foo' => array(
* 'is_private' => true,//-log.php,
* 'log_dir' => 'uploads/specific/log_dir',
* ),
* 'baz' => array(
* 'max_log_size' => 5,//5MB
* )
* )
* ));
* $logger->foo()->error('Log an error into foo module');//[...DATE...] Error: Log an error into foo module. (uploads/specific/log_dir/foo-log.php)
* $logger->foo()->warning('...a warning...'); $logger->foo()->notice('...a notice...'); $logger->foo()->info('..info...');
* # Global module: $logger->error('Log an error into the main log file');...(uploads/your_plugin_name/index-debug.log).
*/
if ( ! defined( 'WP_CONTENT_DIR' ) ) {
exit;
}
if ( ! class_exists( 'WDEV_Logger' ) ) {
/**
* WPMU DEV Logger
*/
class WDEV_Logger {
/**
* Logger error.
*
* @access private
* @var WP_Error|bool $error
*/
private $error = false;
/**
* Registered modules.
*
* @access private
* @var array $modules
*/
private $modules = array();
/**
* Current module.
*
* @access private
*
* @var string
*/
private $current_module;
/**
* Un-lock some limit actions.
* Use this to allow some actions which shouldn't call directly.
*
* @access private
*
* @var string
*/
private $un_lock;
/**
* Nonce name.
*/
const NONCE_NAME = '_wdevnonce';
/**
* Register a new debug log level.
* It will have full control.
*/
const WPMUDEV_DEBUG_LEVEL = 10;
/**
* Debug level.
*
* We use constant WP_DEBUG to define the debug level, e.g:
* define('WP_DEBUG', LOG_DEBUG );
*
* Add backtrace for debug levels:
* LOG_ERR or 3 => Only for Error type.
* LOG_WARNING or 4 => Only for Warning type.
* LOG_NOTICE or 5 => Only for Notice type.
* LOG_INFO or 6 => Only for Info type.
* LOG_DEBUG or 7 => For Error, Warning and Notice type.
* self::WPMUDEV_DEBUG_LEVEL or 10 => for all message types.
*
* @access private
*
* @var integer
*/
private $debug_level;
/**
* Log level.
*
* We use constant WP_DEBUG_LOG to define the log level, e.g:
* define('WP_DEBUG_LOG', LOG_DEBUG );
*
* And by default, we will log all message types. But we can limit it by defining WP_DEBUG_LOG_LOG:
* LOG_ERR or 3 => Only log Error type.
* LOG_WARNING or 4 => Only log Warning type.
* LOG_NOTICE or 5 => Only log Notice type.
* LOG_INFO or 6 => Only log Info type.
* LOG_DEBUG or 7 => Log Error, Warning and Notice type.
* self::WPMUDEV_DEBUG_LEVEL or 10 or TRUE => for all message types.
*
* @access private
*
* @var integer
*/
private $log_level;
/**
* Default Options.
*
* @type boolean use_native_filesystem_api
* If we can't connect to the Filesystem API, enable this to try to use default PHP functions (WP_Filesystem_Direct).
*
* @type int max_log_size
* Maximum file size for each log file in MB.
* Note, set it large might make your site run slower while writing a log or clean the log file.
*
* @type float expected_log_size_in_percent
* Set the expected file log size in percent ( base on $max_log_size ).
* E.g. If the log file size is larger than 10MB (15MB) => we will need to reduce (15 - 10 * 70/100 = 8MB).
*
* @type string log_dir
* Log directory, a sub-folder inside WP_CONTENT_DIR
* [WP_CONTENT_DIR]/[log_dir]
*
* @type boolean add_subsite_dir Allow to add sub-site folder in the MU site.
*
*
* Modules:
*
* By default, we will add a standard module (index), add a empty module to overwrite it. And we can use it to log the general case.
* e.g $logger->index()->log('Something for the general case');
*
* Module option inherit option from the parent.
* These are some new option:
* @type boolean is_private
* Set is_private is TRUE to use save the log to php file instead of normal .log type.
*
* Set is_global_module is TRUE to use it as a global/general module.
* By default, we will auto register a new global module "index".
* With global module we can access the method directly, e.g:
* $logger->error('Log an error');
*
* Default settings:
* array(
* 'use_native_filesystem_api' => true,
* 'max_log_size' => 10,
* 'expected_log_size_in_percent' => 0.7,
* 'is_private' => false,
* 'log_dir' => 'wpmudev',
* 'add_subsite_dir' => true,
* 'modules' => array(),
* );
*
* @access private
*
* @var array
*/
private $option;
/**
* Option key name.
* Default is wdev_logger_[plugin_name]
*
* @access private
* @var string
*/
private $option_key;
/**
* Return the plugin instance
*
* @param array $option Logger option.
* @param string|null $option_key Option key name.
* If $option_key is null we will try to use the plugin folder name instead.
* @see self::get_option_key()
* @return WDEV_Logger
*/
public static function create( $option, $option_key = null ) {
return new self( $option, $option_key );
}
/**
* Logger constructor.
*
* @param array $option Logger option.
* @param string $option_key Option key name.
*/
public function __construct( $option, $option_key ) {
$this->option_key = $this->get_option_key( $option_key );
$this->parse_option( $option );
// disable for empty option.
if ( ! empty( $option ) ) {
add_action( 'wp_ajax_wdev_logger_action', array( $this, 'process_actions' ) );
// Add cron schedule to clean out outdated logs.
add_action( 'wdev_logger_clear_logs', array( $this, 'clear_logs' ) );
add_action( 'admin_init', array( $this, 'check_cron_schedule' ) );
}
}
/**
* Set the current module and we can use this to call some actions.
* e.g.
* $logger->your_module_1()->error('An error.');
* $logger->your_module_1()->notice('A notice.');
* $logger->your_module_2()->delete();//delete the log file.
*
* @param string $name Method name.
* @param array $arguments Arguments.
*/
public function __call( $name, $arguments ) {
if ( $this->set_current_module( $name ) ) {
$this->un_lock = true;
} elseif ( $this->enabling_debug_log_mode() ) {
error_log( sprintf( 'Module "%1$s" does not exists, list of registered modules are ["%2$s"]. Continue with global module "%3$s".', $name, join( '", "', array_keys( $this->modules ) ), $this->option['global_module'] ) );//phpcs:ignore
}
return $this;
}
/**
* Check debug log mode.
*
* @return boolean.
*/
public function enabling_debug_log_mode() {
return defined( 'WP_DEBUG' ) && WP_DEBUG && defined( 'WP_DEBUG_LOG' ) && WP_DEBUG_LOG;
}
/**
* Main logging function.
*
* @param mixed $message Data to write to log.
* @param string|null $type Log type (Error, Warning, Notice, etc).
*/
public function log( $message, $type = null ) {
$this->maybe_active_global_module();
if ( ! $this->should_log( $message, $type ) ) {
return;
}
return $this->write_log_file( $this->format_message( $message, $type ) );
}
/**
* Format the message to be logged.
*
* @since 1.0.2
*
* @param string $message Message to be logged.
* @param string $type Message type.
* @return string
*/
private function format_message( $message, $type ) {
if ( ! is_string( $message ) ) {
if ( ! is_scalar( $message ) ) {
$message = PHP_EOL . print_r( $message, true );
} else {
$message = print_r( $message, true );
}
}
if ( ! empty( $type ) && is_string( $type ) ) {
$type = strtolower( $type );
$message = ucfirst( $type ) . ': ' . $message;
}
$message = '[' . date( 'c' ) . '] ' . $message;//phpcs:ignore
// maybe log backtrace.
if ( $this->get_debug_level() && is_int( $this->debug_level ) && $this->level_can_do( $this->debug_level, $type ) ) {
$backtrace = debug_backtrace( DEBUG_BACKTRACE_IGNORE_ARGS, 20 );//phpcs:ignore
$backtrace = array_filter(
$backtrace,
function( $trace ) {
return ! isset( $trace['file'] ) || __FILE__ !== $trace['file'] && false !== strpos( $trace['file'], WP_CONTENT_DIR );
}
);
$message .= PHP_EOL .'['. date('c') .'] Stack trace: '. PHP_EOL . print_r( $backtrace, true );//phpcs:ignore
}
return $message;
}
/**
* Log Error message.
* Error: [an error message].
*
* @param mixed $message Data to write to log.
*/
public function error( $message ) {
return $this->log( $message, 'Error' );
}
/**
* Log a notice.
* Warning: [a notice message].
*
* @param mixed $message Data to write to log.
*/
public function notice( $message ) {
return $this->log( $message, 'Notice' );
}
/**
* Log a warning.
* Warning: [a warning message].
*
* @param mixed $message Data to write to log.
*/
public function warning( $message ) {
return $this->log( $message, 'Warning' );
}
/**
* Log a info.
* Info: [a info message].
*
* @param mixed $message Data to write to log.
*/
public function info( $message ) {
return $this->log( $message, 'Info' );
}
/**
* Retrieve download link for a log module.
*
* @param string $module Module slug.
* @return string A nonce url to download the module log.
*/
public function get_download_link( $module = null ) {
// set current module.
$this->switch_module( $module );
return wp_nonce_url(
add_query_arg(
array(
'action' => 'wdev_logger_action',
'log_action' => 'download',
'log_module' => $this->current_module,
),
admin_url( 'admin-ajax.php' )
),
$this->get_log_action_name(),
self::NONCE_NAME
);
}
/**
* Process logger actions.
*
* Accepts module name (slug) and action. So far only 'download' and 'delete' actions is supported.
*/
public function process_actions() {
// phpcs:disable WordPress.Security.ValidatedSanitizedInput.InputNotSanitized
if (
! isset( $_REQUEST['log_action'], $_REQUEST['log_module'], $_REQUEST[ self::NONCE_NAME ] ) ||
! wp_verify_nonce( wp_unslash( $_REQUEST[ self::NONCE_NAME ] ), $this->get_log_action_name() )
) {
// Invalid action, return.
return;
}
// phpcs:enable
$action = sanitize_text_field( wp_unslash( $_REQUEST['log_action'] ) ); // Input var ok.
$module = sanitize_text_field( wp_unslash( $_REQUEST['log_module'] ) ); // Input var ok.
// Not called by a registered module.
if ( ! isset( $this->modules[ $module ] ) ) {
/* translators: %s Method name */
wp_send_json_error( sprintf( __( 'Module %s does not exist.', 'wpmudev' ), $module ) );
}
// Only allow these actions.
if ( in_array( $action, array( 'download', 'delete' ), true ) && method_exists( $this, $action ) ) {
$should_return = isset( $_SERVER['REQUEST_METHOD'] ) && 'POST' === $_SERVER['REQUEST_METHOD'];
$result = call_user_func( array( $this, $action ), $module, $should_return );
if ( $should_return ) {
wp_send_json_success( $result );
}
exit;
}
/* translators: %s Method name */
wp_send_json_error( sprintf( __( 'Method %s does not exist.', 'wpmudev' ), $action ) );
}
/**
* Delete current log file.
*
* @param string $module Module slug.
*
* @return bool True on success or false on failure.
*/
public function delete( $module = null ) {
if ( ! $this->connect_fs() ) {
return false;
}
global $wp_filesystem;
// Set current module.
$this->switch_module( $module );
if ( ! $wp_filesystem->exists( $this->get_file() ) ) {
return true;
}
return $wp_filesystem->delete( $this->get_file(), false, 'f' );
}
/**
* Retrieve option by key.
*
* @param string $name Key name.
*
* @return mixed Returns option value.
*/
public function get_option( $name ) {
$this->maybe_active_global_module();
return $this->get_module_option( $name );
}
/**
* Retrieve current module option by key.
*
* @access private
*
* @param string $name Key name.
* @param mixed $value Default value.
*
* @return mixed Returns option value.
*/
private function get_module_option( $name, $value = null ) {
if ( $this->current_module && isset( $this->modules[ $this->current_module ][ $name ] ) ) {
$value = $this->modules[ $this->current_module ][ $name ];
} elseif ( isset( $this->option[ $name ] ) ) {
$value = $this->option[ $name ];
}
return apply_filters( "wdev_logger_get_option_{$name}", $value, $this->current_module, $this->option );
}
/**
* Clean up the log dir and delete the option.
* That's useful to use it while uninstalling plugin.
*/
public function cleanup() {
if ( empty( $this->modules ) || ! $this->connect_fs() ) {
return;
}
foreach ( $this->modules as $module => $module_option ) {
$this->delete( $module );
}
}
/**
* Set debug level.
*
* @param int $debug_level Debug level to set.
*/
public function set_debug_level( $debug_level = LOG_DEBUG ) {
$is_global_settings = ! $this->un_lock;
$this->maybe_active_global_module();
return $this->set_level( $debug_level, 'debug_level', $is_global_settings );
}
/**
* Set log level.
*
* @param int $log_level Log level to set.
*/
public function set_log_level( $log_level = LOG_DEBUG ) {
$is_global_settings = ! $this->un_lock;
$this->maybe_active_global_module();
return $this->set_level( $log_level, 'log_level', $is_global_settings );
}
/**
* Retrieve log level.
*
* @access private
*
* @return int Log level.
*/
private function get_log_level() {
if ( null === $this->log_level ) {
$this->log_level = $this->get_module_option( 'log_level', WP_DEBUG_LOG );
}
return $this->log_level;
}
/**
* Retrieve debug level.
*
* @access private
*
* @return int Debug level.
*/
private function get_debug_level() {
if ( null === $this->debug_level ) {
$this->debug_level = $this->get_module_option( 'debug_level', WP_DEBUG );
}
return $this->debug_level;
}
/**
* Set level for DEBUG or DEBUG Log.
*
* @access private
*
* @param int $level Level to set.
* @param string $level_type log_level | debug_level.
* @param bool $is_global_settings Set log level for all modules or only specific module.
* @return int Current level.
*/
private function set_level( $level, $level_type, $is_global_settings = false ) {
$level = (int) $level;
if ( $level > 2 && $level < 8 ) {
$level = intval( $level );
} elseif ( $level < 1 ) {
$level = 0;
} else {
$level = self::WPMUDEV_DEBUG_LEVEL;
}
// If setting level for global module, we will set it in the option, so the module can inherit it.
if ( $is_global_settings && $this->current_module === $this->option['global_module'] ) {
$this->option[ $level_type ] = $level;
$this->{$level_type} = $level;
} else {
$this->modules[ $this->current_module ][ $level_type ] = $level;
$this->{$level_type} = $level;
}
return $level;
}
/**
* Download logs.
*
* @access private
*
* @param string $module Module slug.
* @param bool $return Download file or return the content.
*/
private function download( $module = null, $return = false ) {
if ( ! $this->connect_fs() ) {
return;
}
global $wp_filesystem;
// Set current module.
$this->switch_module( $module );
$content = $wp_filesystem->get_contents( $this->get_file() );
if ( $content && $this->get_module_option( 'is_private' ) ) {
$content = ltrim( $content, '<?php die(); ?>' );
}
if ( $return ) {
return $content;
}
header( 'Content-Description: WPMUDEV log download' );
header( 'Content-Type: text/plain' );
header( "Content-Disposition: attachment; filename={$this->current_module}.log" );
header( 'Content-Transfer-Encoding: binary' );
header( 'Content-Length: ' . strlen( $content ) );
header( 'Cache-Control: must-revalidate, post-check=0, pre-check=0' );
header( 'Expires: 0' );
header( 'Pragma: public' );
echo $content;//phpcs:ignore
exit;
}
/**
* Retrieve the action name for form/request.
*
* @access private
*
* @return string Action name.
*/
private function get_log_action_name() {
return 'action_' . str_replace( 'wdev_logger_', '', $this->option_key );
}
/**
* Retrieve option key.
* We use this as an option key name to save the parsed option.
*
* @access private
*
* @param string $option_key option key name.
* @return string Option key name.
*/
private function get_option_key( $option_key ) {
if ( ! $this->option_key ) {
if ( empty( $option_key ) ) {
list( $option_key ) = explode( '/', ltrim( str_replace( WP_PLUGIN_DIR, '', __FILE__ ), '/' ) );
}
$this->option_key = 'wdev_logger_' . $option_key;
}
return $this->option_key;
}
/**
* Sanitize module slug.
*
* @since 1.0.2
*
* @param string $module_slug Module name/slug.
* @return string
*/
private function sanitize_module_slug( $module_slug ) {
return str_replace( '-', '_', sanitize_key( $module_slug ) );
}
/**
* Parse module option.
*
* @since 1.0.2
*
* @param string $module_slug Sanitized module slug.
* @param array $module_option Module option.
* @return array Sanitized module option.
*/
private function parse_module_option( $module_slug, $module_option ) {
// If the module_option is empty, we will set it as a general module.
if ( ! empty( $module_option['is_global_module'] ) ) {
$this->option['global_module'] = $module_slug;
}
if ( ! empty( $module_option ) ) {
// Only keep the allowed keys.
$module_option = array_intersect_key( $module_option, $this->option );
array_walk( $module_option, array( $this, 'sanitize_option' ) );
}
if ( empty( $module_option['name'] ) ) {
$module_option['name'] = str_replace( '_', '-', $module_slug );
}
$module_option['name'] = sanitize_title( $module_option['name'] );
return $module_option;
}
/**
* Parse option.
*
* @access private
*
* @param array $option Logger option.
*/
private function parse_option( $option ) {
// Default settings.
$this->option = array(
'use_native_filesystem_api' => true,
'max_log_size' => 10,
'expected_log_size_in_percent' => 0.7,
'is_private' => false,
'log_dir' => 'wpmudev',
'add_subsite_dir' => true,
'modules' => array(),
);
// Parse option, don't parse if the option is empty.
if ( empty( $option ) ) {
return;
}
$option = wp_parse_args( $option, $this->option );
if ( empty( $option['modules'] ) ) {
// Default module.
$option['modules']['index'] = array(
'is_global_module' => 1,
);
}
$modules = $option['modules'];
unset( $option['modules'] );
// Sanitize option.
array_walk( $option, array( $this, 'sanitize_option' ) );
$this->option = $option;
// Parse modules.
$this->parse_modules( $modules );
// Maybe activate the general module.
if ( empty( $this->option['global_module'] ) ) {
$this->modules['index'] = $this->option;
$this->option['global_module'] = 'index';
}
// Set current module.
$this->current_module = $this->option['global_module'];
}
/**
* Parse option for modules.
*
* @since 1.0.2
*
* @param array $modules List modules to parse.
*/
private function parse_modules( $modules ) {
foreach ( $modules as $module_slug => $module_option ) {
if ( empty( $module_slug ) ) {
continue;
}
// Parse module.
$this->add_module( $module_slug, $module_option );
}
}
/**
* Sanitize option.
*
* @access private
*
* @param mixed $option option value.
* @param string $key option key.
* @return void
*/
private function sanitize_option( &$option, $key ) {
switch ( $key ) {
case 'max_log_size':
$option = abs( (int) $option );
return;
case 'expected_log_size_in_percent':
$option = abs( (float) $option );
if ( $option > 1 ) {
$option = 0.9;
}
return;
case 'log_dir':
if ( empty( $option ) ) {
$option = 'wpmudev';
} else {
$option = preg_replace( '#[^a-z0-9_\/\-]#', '', $option );
}
return;
// We ignore this property to avoid conflict with the cached file name.
case 'file_name':
// Don't allow to set this option directly, please try to use is_global_module instead.
case 'global_module':
$option = null;
return;
}
if ( is_bool( $option ) ) {
return $option;
} elseif ( empty( $option ) ) {
if ( isset( $this->option[ $key ] ) ) {
$option = $this->option[ $key ];
} else {
$option = null;
}
} elseif ( is_scalar( $option ) ) {
$option = sanitize_text_field( $option );
} else {
$option = null;
}
}
/**
* Retrieve filesystem credentials.
* By default, if the access method is not "direct" type, function "request_filesystem_credentials" will return a form
* if there is any missing from credentials configs. So we use this custom function to avoid this case.
*
* @see request_filesystem_credentials()
* @link https://developer.wordpress.org/reference/functions/request_filesystem_credentials/
*
* @param string $type Access method type: direct | ftpext | ssh2 | ftpsockets.
*
* @access private
*
* @return mixed
*/
private function get_filesystem_credentials( $type ) {
if ( 'direct' === $type ) {
return true;
}
$credentials = get_option(
'ftp_credentials',
array(
'hostname' => '',
'username' => '',
)
);
$ftp_constants = array(
'hostname' => 'FTP_HOST',
'username' => 'FTP_USER',
'password' => 'FTP_PASS',
'public_key' => 'FTP_PUBKEY',
'private_key' => 'FTP_PRIKEY',
);
// If defined, set it to that. Else, if POST'd, set it to that. If not, set it to an empty string.
// Otherwise, keep it as it previously was (saved details in option).
foreach ( $ftp_constants as $key => $constant ) {
if ( defined( $constant ) ) {
$credentials[ $key ] = constant( $constant );
} elseif ( ! isset( $credentials[ $key ] ) ) {
$credentials[ $key ] = '';
}
}
// Sanitize the hostname, some people might pass in odd data.
$credentials['hostname'] = preg_replace( '|\w+://|', '', $credentials['hostname'] ); // Strip any schemes off.
if ( strpos( $credentials['hostname'], ':' ) ) {
list( $credentials['hostname'], $credentials['port'] ) = explode( ':', $credentials['hostname'], 2 );
if ( ! is_numeric( $credentials['port'] ) ) {
unset( $credentials['port'] );
}
} else {
unset( $credentials['port'] );
}
if ( ( defined( 'FTP_SSH' ) && FTP_SSH ) || ( defined( 'FS_METHOD' ) && 'ssh2' === FS_METHOD ) ) {
$credentials['connection_type'] = 'ssh';
} elseif ( ( defined( 'FTP_SSL' ) && FTP_SSL ) && 'ftpext' === $type ) { // Only the FTP Extension understands SSL.
$credentials['connection_type'] = 'ftps';
} elseif ( ! isset( $credentials['connection_type'] ) ) { // All else fails (and it's not defaulted to something else saved), default to FTP.
$credentials['connection_type'] = 'ftp';
}
return $credentials;
}
/**
* Connect Filesystem API.
*
* @access private
*
* @return int connect status: 0 for failure, 1 for success and -1 for try to use native Filesystem API.
*/
private function connect_fs() {
static $connect_st;
if ( null !== $connect_st ) {
return $connect_st;
}
$connect_st = 0;
// Need to include file.php for frontend.
if ( ! function_exists( 'request_filesystem_credentials' ) ) {
require_once ABSPATH . 'wp-admin/includes/file.php';
}
// Check if the user has write permissions.
$access_type = get_filesystem_method();
if ( empty( $access_type ) ) {
$access_type = 'direct';
}
// Initialize the Filesystem API.
if ( WP_Filesystem( $this->get_filesystem_credentials( $access_type ) ) ) {
// Filesystem API is connected, cache result.
$connect_st = 1;
} else {
// Try to use native Filesystem API and log errors.
$connect_st = $this->maybe_try_native_fsapi_and_log_error( $access_type );
}
return $connect_st;
}
/**
* Maybe try to use native filesystem API for non-direct type,
* and log error.
*
* @since 1.0.2
*
* @param string $access_type Access type.
* @return int connect status: 0 for failure, and -1 for try to use native Filesystem API.
*/
private function maybe_try_native_fsapi_and_log_error( $access_type ) {
global $wp_filesystem;
$connect_st = -1;// Set -1 to allow to use native PHP File.
// Try to connect Filesystem API again by using method direct to use the native Filesystem API.
if ( 'direct' !== $access_type && $this->get_module_option( 'use_native_filesystem_api' ) ) {
if ( $this->enabling_debug_log_mode() && is_wp_error( $wp_filesystem->errors ) && $wp_filesystem->errors->has_errors() ) {
$error_msg = sprintf( 'Cannot connect to Filesystem API via %1$s: %2$s, trying to use the direct method!', strtoupper( $access_type ), $wp_filesystem->errors->get_error_message() );
}
add_filter( 'filesystem_method', array( $this, 'force_access_direct_method' ), 9999 );
if ( ! WP_Filesystem( true ) ) {
// This case should be never catch unless file wp-admin/includes/class-wp-filesystem-ftpext.php doesn't exist.
$connect_st = 0;
$this->error = true;
}
remove_filter( 'filesystem_method', array( $this, 'force_access_direct_method' ), 9999 );
} else {
$connect_st = 0;
$this->error = true;
}
if ( ! $this->enabling_debug_log_mode() ) {
// Debug log is disabled, return.
return $connect_st;
}
// Log the error and return.
// This is for the case we try to use native PHP File handling.
if ( $this->error && empty( $error_msg ) ) {
if ( is_wp_error( $wp_filesystem->errors ) && $wp_filesystem->errors->has_errors() ) {
$error_msg = $wp_filesystem->errors->get_error_message();
} else {
/* translators: %s Filesystem method */
$error_msg = sprintf( 'Connect to the Filesystem API via method %s failure!', strtoupper( $access_type ) );
}
}
if ( ! empty( $error_msg ) ) {
error_log( $error_msg );// phpcs:ignore.
}
return $connect_st;
}
/**
* Force set the filesystem method to direct.
*
* @usedby hook filesystem_method
* @see self::connect_fs()
*
* @return string Direct method.
*/
public function force_access_direct_method() {
return 'direct';
}
/**
* Get file name.
*
* @since 1.0.2
*/
private function get_file_name() {
// Try to get from cache.
$file_name = $this->get_module_option( 'file_name' );
if ( $file_name ) {
return $file_name;
}
// Use PHP for private file.
if ( $this->get_module_option( 'is_private' ) ) {
$suffix = 'log.php';
} else {
$suffix = 'debug.log';
}
$file_name = $this->get_module_option( 'name' );
if ( empty( $file_name ) ) {
$file_name = $this->current_module;
}
$file_name = $file_name . '-' . $suffix;
// Save to module.
$this->modules[ $this->current_module ]['file_name'] = $file_name;
return $file_name;
}
/**
* Prepare filename.
*
* @access private
*/
private function get_file() {
// Try to get from cache.
$file = $this->get_log_directory() . $this->get_file_name();
return apply_filters( 'wdev_logger_get_file', $file, $this->current_module, $this->modules[ $this->current_module ] );
}
/**
* Get log directory.
*
* @access private
*
* @return string
*/
private function get_log_directory() {
$log_dir = WP_CONTENT_DIR . '/' . trailingslashit( $this->get_module_option( 'log_dir' ) );
if ( ! is_multisite() ) {
return $log_dir;
}
if ( $this->get_module_option( 'add_subsite_dir' ) ) {
$log_dir .= trailingslashit( preg_replace( '#http(s)?://(www.)?#', '', home_url() ) );
}
return $log_dir;
}
/**
* Check if module should log or not.
*
* @param mixed $message Message.
* @param string $type Message type: error | warning | notice | info.
*
* @access private
*
* @return bool
*/
private function should_log( $message, $type ) {
// We don't log empty message.
if ( 0 !== $message && empty( $message ) ) {
return false;
}
// Stop if there is any errors occur.
if ( $this->error ) {
// Log error.
if ( $this->enabling_debug_log_mode() && is_wp_error( $this->error ) ) {
error_log( $this->error->get_error_message() );// phpcs:ignore.
}
return false;
}
// Make sure we connected to Filesystem API.
if ( ! $this->connect_fs() || ! $this->is_writable_log_dir() ) {
if ( $this->enabling_debug_log_mode() ) {
$error = error_get_last();
if ( ! empty( $error['message'] ) ) {
error_log( $error['message'] );// phpcs:ignore.
}
}
return false;
}
$do_log = $this->get_log_level();
if ( $do_log && is_int( $do_log ) ) {
$do_log = $this->level_can_do( $this->log_level, $type, $do_log );
}
return apply_filters( 'wdev_logger_should_log', $do_log, $this->current_module, $message );
}
/**
* Detect if the current log level can do something.
*
* @access private
*
* @param int $level Level number, it can be: LOG_ERR | LOG_WARNING | LOG_NOTICE | LOG_INFO | LOG_DEBUG OR self::WPMUDEV_DEBUG_LEVEL.
* @param string $type Message type.
* @param bool $can_do Default value.
* @return bool
*/
private function level_can_do( $level, $type, $can_do = false ) {
$checking_debug_log_level = $can_do;
if ( $type && is_string( $type ) ) {
$type = strtolower( $type );
switch ( $level ) {
case LOG_DEBUG:
$can_do = 'error' === $type || 'warning' === $type || 'notice' === $type;
break;
case LOG_ERR:
$can_do = 'error' === $type;
break;
case LOG_WARNING:
$can_do = 'warning' === $type;
break;
case LOG_NOTICE:
$can_do = 'notice' === $type;
break;
case LOG_INFO:
$can_do = 'info' === $type;
break;
case self::WPMUDEV_DEBUG_LEVEL:
$can_do = true;
break;
}
}
return apply_filters( 'wdev_logger_level_can_do', $can_do, $level, $type, $checking_debug_log_level );
}
/**
* Check if log directory is already create, if not - create it.
*
* @access private
*
* @return bool
*/
private function is_writable_log_dir() {
global $wp_filesystem;
$log_dir = dirname( $this->get_file() );
if ( $wp_filesystem->is_dir( $log_dir ) ) {
// The directory exists, check writeable permissions.
if ( $wp_filesystem->is_writable( $log_dir ) || $wp_filesystem->chmod( $log_dir, FS_CHMOD_DIR ) ) {
return true;
}
return false;
}
return $this->create_log_dir( $log_dir );
}
/**
* Create the log directory.
*
* @param string $log_dir Log dir.
* @return bool True on success, false on failure.
*/
public function create_log_dir( $log_dir ) {
// If we can create nested directories via mkdir, let's do it and return.
if ( mkdir( $log_dir, FS_CHMOD_DIR, true ) ) {
// Create an index.php file to avoid access log folder directly.
global $wp_filesystem;
$wp_filesystem->put_contents( $log_dir . '/index.php', '<?php' . PHP_EOL . '// Silence is golden.', FS_CHMOD_FILE );
return true;
}
return $this->create_nested_directory( $log_dir );
}
/**
* Try to separate nested log directory and create one by one
* if it can be done via mkdir with recursive is TRUE.
*
* @since 1.0.2
*
* @param string $log_dir Log directory.
* @return bool
*/
private function create_nested_directory( $log_dir ) {
global $wp_filesystem;
$log_dir = str_replace( '\\', '/', $log_dir );
$log_dir = trailingslashit( $log_dir );
$offset = strlen( WP_CONTENT_DIR );
// Detect next slash position from WP_CONTENT_DIR.
$next_slash_pos = strpos( $log_dir, '/', $offset );
if ( ! $next_slash_pos ) {
// If there is only once depth, create it and return.
return $wp_filesystem->mkdir( $log_dir );
}
// Try to create nested directories.
while ( $next_slash_pos ) {
$n_log_dir = substr( $log_dir, 0, $next_slash_pos );
if ( ! $wp_filesystem->is_dir( $n_log_dir ) ) {
if ( $wp_filesystem->mkdir( $n_log_dir ) ) {
$wp_filesystem->put_contents( $n_log_dir . '/index.php', '<?php' . PHP_EOL . '// Silence is golden.', FS_CHMOD_FILE );
} else {
return false;
}
}
$offset = $next_slash_pos + 1;
$next_slash_pos = strpos( $log_dir, '/', $offset );
}
return true;
}
/**
* Attempt to write file.
*
* @access private
*
* @param string $message String to write to file.
*/
private function write_log_file( $message = '' ) {
global $wp_filesystem;
// Append a new blank line.
$message = trim( $message ) . PHP_EOL;
$file = $this->get_file();
// Disable access the private file directly.
if ( $this->get_module_option( 'is_private' ) && ! $wp_filesystem->exists( $file ) ) {
$message = '<?php die(); ?>' . PHP_EOL . $message;
}
/**
* By default, we will try to append the message to the log file.
* Add a filter to allow third-party doing it by their self.
*/
$check = apply_filters( 'wdev_logger_update_file', null, $file, $message, $this->current_module );
if ( null !== $check ) {
return (bool) $check;
}
// Try to use append method before using put_contents.
switch ( $wp_filesystem->method ) {
case 'ssh2':
$file = $wp_filesystem->sftp_path( $file );
// continue to use direct method.
case 'direct':
// Append message to the log file.
$ret = file_put_contents( $file, $message, FILE_APPEND | LOCK_EX );
if ( strlen( $message ) !== $ret ) {
return false;
}
break;
case 'ftpext':
if ( function_exists( 'ftp_append' ) ) {
$tempfile = wp_tempnam( $file );
$temphandle = fopen( $tempfile, 'wb+' );
if ( ! $temphandle ) {
unlink( $tempfile );
return false;
}
mbstring_binary_safe_encoding();
$data_length = strlen( $message );
$bytes_written = fwrite( $temphandle, $message );
reset_mbstring_encoding();
if ( $data_length !== $bytes_written ) {
fclose( $temphandle );
unlink( $tempfile );
return false;
}
fseek( $temphandle, 0 ); // Skip back to the start of the file being written to.
$ret = ftp_append( $wp_filesystem->link, $file, $tempfile, FTP_BINARY );
fclose( $temphandle );
unlink( $tempfile );
break;
}
// continue to use default option.
default:
$contents = '';
if ( $wp_filesystem->exists( $file ) ) {
$contents = $wp_filesystem->get_contents( $file );
}
$contents .= $message;
return $wp_filesystem->put_contents( $file, $contents, FS_CHMOD_FILE );
}
// chmod file.
$wp_filesystem->chmod( $file, FS_CHMOD_FILE );
return $ret;
}
/**
* Set current module.
*
* @access private
*
* @param string $module Module name.
*/
private function set_current_module( $module ) {
if ( empty( $module ) || ! isset( $this->modules[ $module ] ) ) {
// Module is not exist, return.
return 0;
}
if ( $module === $this->current_module ) {
// Is already on this module, return.
return -1;
}
// Set current module.
$this->current_module = $module;
// Reset debug/log level.
$this->log_level = null;
$this->debug_level = null;
return 1;
}
/**
* Switch module.
*
* @param string $module Module name.
*
* @return int 1 if switch is successful, otherwise try to use global module.
*/
private function switch_module( $module ) {
if ( $module ) {
$module = str_replace( '-', '_', sanitize_key( $module ) );
}
if ( $this->set_current_module( $module ) ) {
// Switched to the new module, return.
return 1;
}
// Try to use global module.
$this->maybe_active_global_module();
return -1;
}
/**
* Allow call the log actions directly from the original instance.
* $logger->error('Something here');
* $logger->log('Something here');
*
* @param bool $return Return a instance of WP_Error
* or exit if we can't detect the global module.
*/
public function maybe_active_global_module( $return = false ) {
// If is already on existed module, lock it and return.
if ( $this->un_lock ) {
// re-lock.
$this->un_lock = false;
return;
}
// Global module exist, switch to this module, and return.
if ( ! empty( $this->option['global_module'] ) && $this->set_current_module( $this->option['global_module'] ) ) {
return;
}
// Return an error.
if ( $return ) {
return new WP_Error( 'non-registered', 'Cheating, huh?' );
} else {
wp_die( 'Cheating, huh?' );
}
}
/**
* Set a schedule to clean the logs.
*/
public function check_cron_schedule() {
if ( ! wp_next_scheduled( 'wdev_logger_clear_logs' ) ) {
wp_schedule_event( strtotime( 'midnight' ), 'daily', 'wdev_logger_clear_logs' );
}
}
/**
* Get rid of the old messages that take the file size over the maximum log file size.
* We will reduce the file size to the expected size.
* Expected size = max_log_size * expected_log_size_in_percent
*/
public function clear_logs() {
if ( empty( $this->modules ) || ! $this->connect_fs() ) {
return;
}
global $wp_filesystem;
foreach ( $this->modules as $module => $module_option ) {
$this->set_current_module( $module );
$file = $this->get_file();
if ( $wp_filesystem->exists( $file ) ) {
// Delete the log file if deactivated debug log.
if ( ! $this->get_log_level() ) {
$wp_filesystem->delete( $file, false, 'f' );
continue;
}
$file_size = $wp_filesystem->size( $file );
$max_file_size = $this->get_module_option( 'max_log_size' ) * MB_IN_BYTES;
if ( $file_size < $max_file_size ) {
continue;
}
$expected_file_size = $this->get_module_option( 'expected_log_size_in_percent' ) * $max_file_size;
if ( $expected_file_size < 1 ) {
$wp_filesystem->delete( $file, false, 'f' );
continue;
}
$contents = $wp_filesystem->get_contents( $file );
$offset = intval( $file_size - $expected_file_size );
$pos = strpos( $contents, PHP_EOL . '[', $offset );
if ( ! $pos ) {
$pos = strpos( $contents, PHP_EOL, $offset );
}
if ( $pos ) {
$contents = substr( $contents, $pos );
if ( $this->get_module_option( 'is_private' ) ) {
$contents = '<?php die(); ?>' . $contents;
}
$wp_filesystem->put_contents( $file, $contents, FS_CHMOD_FILE );
} else {
$wp_filesystem->delete( $file, false, 'f' );
}
}
}
}
/**
* Create nonce for Ajax action 'wdev_logger_action'
*
* @return string The token
*/
public function create_nonce() {
return wp_create_nonce( $this->get_log_action_name() );
}
/**
* Update module option for the existed module.
* Note: the new option will inherit from old option.
*
* @param string $module Module slug.
* @param array $module_option Module options.
* @return bool
*/
public function update_module( $module, $module_option = array() ) {
if ( empty( $module ) ) {
return false;
}
$module_slug = $this->sanitize_module_slug( $module );
// If the module doesn't exist, return.
if ( ! isset( $this->modules[ $module_slug ] ) ) {
if ( $this->enabling_debug_log_mode() ) {
error_log( sprintf( 'Module %s does not exist, use add_module to add a new module.', $module ) );//phpcs:ignore
}
return false;
}
$module_option = wp_parse_args( $module_option, $this->modules[ $module_slug ] );
$this->modules[ $module_slug ] = $this->parse_module_option( $module_slug, $module_option );
return true;
}
/**
* Add a new module.
*
* @uses self::update_module() instead to update module option if it's already exist.
*
* @param string $module Module slug.
* @param array $module_option Module options.
* @return bool
*/
public function add_module( $module, $module_option = array() ) {
if ( empty( $module ) ) {
return false;
}
$module_slug = $this->sanitize_module_slug( $module );
// If the module exist, return.
if ( isset( $this->modules[ $module_slug ] ) ) {
if ( $this->enabling_debug_log_mode() ) {
error_log( sprintf( 'Module %s is already exist, use update_module to update new module option.', $module ) );//phpcs:ignore
}
return false;
}
$this->modules[ $module_slug ] = $this->parse_module_option( $module_slug, $module_option );
return true;
}
}
}