class.log.php

Go to the documentation of this file.

<?php
/*
 *
 *  * Copyright (c) 2022-2025 Bearsampp
 *  * License: GNU General Public License version 3 or later; see LICENSE.txt
 *  * Website: https://bearsampp.com
 *  * Github: https://github.com/Bearsampp
 *
 */

class Log
{
    const ERROR   = 'ERROR';
    const WARNING = 'WARNING';
    const INFO    = 'INFO';
    const DEBUG   = 'DEBUG';
    const TRACE   = 'TRACE';

    private static $logBuffer = [];

    private static $logBufferSize = 50;

    private static $shutdownRegistered = false;

    private static $logStats = [
        'buffered' => 0,
        'flushed'  => 0,
        'writes'   => 0,
    ];

    public static function init()
    {
        if (!self::$shutdownRegistered) {
            register_shutdown_function([__CLASS__, 'flush']);
            self::$shutdownRegistered = true;
        }
    }

    private static function write($data, $type, $file = null)
    {
        global $bearsamppRoot, $bearsamppCore, $bearsamppConfig;
 
        // Safety check: if globals aren't initialised, fall back to error_log
        if (!isset($bearsamppRoot) || !isset($bearsamppCore) || !isset($bearsamppConfig)) {
            error_log('[' . $type . '] ' . $data);
            return;
        }
 
        // Lazily register the shutdown handler if init() was not called explicitly
        self::init();
 
        // Resolve default file path only when the caller did not supply one
        if ($file === null) {
            $file = $type === self::ERROR
                ? $bearsamppRoot->getErrorLogFilePath()
                : $bearsamppRoot->getLogFilePath();
 
            if (!$bearsamppRoot->isRoot()) {
                $file = $bearsamppRoot->getHomepageLogFilePath();
            }
        }
 
        $verbose                         = [];
        $verbose[Config::VERBOSE_SIMPLE] = $type === self::ERROR || $type === self::WARNING;
        $verbose[Config::VERBOSE_REPORT] = $verbose[Config::VERBOSE_SIMPLE] || $type === self::INFO;
        $verbose[Config::VERBOSE_DEBUG]  = $verbose[Config::VERBOSE_REPORT] || $type === self::DEBUG;
        $verbose[Config::VERBOSE_TRACE]  = $verbose[Config::VERBOSE_DEBUG] || $type === self::TRACE;
 
        $writeLog = false;
        if ($bearsamppConfig->getLogsVerbose() === Config::VERBOSE_SIMPLE && $verbose[Config::VERBOSE_SIMPLE]) {
            $writeLog = true;
        } elseif ($bearsamppConfig->getLogsVerbose() === Config::VERBOSE_REPORT && $verbose[Config::VERBOSE_REPORT]) {
            $writeLog = true;
        } elseif ($bearsamppConfig->getLogsVerbose() === Config::VERBOSE_DEBUG && $verbose[Config::VERBOSE_DEBUG]) {
            $writeLog = true;
        } elseif ($bearsamppConfig->getLogsVerbose() === Config::VERBOSE_TRACE && $verbose[Config::VERBOSE_TRACE]) {
            $writeLog = true;
        }
 
        if ($writeLog) {
            self::$logBuffer[] = [
                'file' => $file,
                'data' => $data,
                'type' => $type,
                'time' => time(),
            ];
            self::$logStats['buffered']++;
 
            // Flush immediately for errors, or when the buffer is full
            if ($type === self::ERROR || count(self::$logBuffer) >= self::$logBufferSize) {
                self::flush();
            }
        }
    }

    public static function flush()
    {
        if (empty(self::$logBuffer)) {
            return;
        }
 
        global $bearsamppCore;
 
        // If the core global is gone (e.g. during an abnormal shutdown), fall back to error_log
        if (!isset($bearsamppCore)) {
            foreach (self::$logBuffer as $log) {
                error_log('[' . date('Y-m-d H:i:s', $log['time']) . '] [' . $log['type'] . '] ' . $log['data']);
            }
            self::$logStats['flushed'] += count(self::$logBuffer);
            self::$logBuffer = [];
            return;
        }
 
        // Group logs by destination file
        $logsByFile = [];
        foreach (self::$logBuffer as $log) {
            $logsByFile[$log['file']][] = $log;
        }
 
        foreach ($logsByFile as $file => $logs) {
            $content = '';
            foreach ($logs as $log) {
                $content .= '[' . date('Y-m-d H:i:s', $log['time']) . '] # ' .
                            APP_TITLE . ' ' . $bearsamppCore->getAppVersion() . ' # ' .
                            $log['type'] . ': ' . $log['data'] . PHP_EOL;
            }
 
            $written = @file_put_contents($file, $content, FILE_APPEND | LOCK_EX);
            if ($written === false) {
                // File write failed — ensure entries are not silently lost
                foreach ($logs as $log) {
                    error_log('[' . $log['type'] . '] ' . $log['data'] . ' (target: ' . $file . ')');
                }
            }
 
            self::$logStats['writes']++;
        }
 
        self::$logStats['flushed'] += count(self::$logBuffer);
        self::$logBuffer = [];
    }

    public static function reset()
    {
        self::$logBuffer         = [];
        self::$shutdownRegistered = false;
        self::$logStats          = [
            'buffered' => 0,
            'flushed'  => 0,
            'writes'   => 0,
        ];
    }

    public static function getStats()
    {
        return self::$logStats;
    }

    public static function setBufferSize($size)
    {
        if ($size > 0 && $size <= 1000) {
            self::$logBufferSize = $size;
        }
    }

    public static function getBufferSize()
    {
        return self::$logBufferSize;
    }

    public static function separator()
    {
        global $bearsamppRoot;
 
        $logs = [
            $bearsamppRoot->getLogFilePath(),
            $bearsamppRoot->getErrorLogFilePath(),
            $bearsamppRoot->getServicesLogFilePath(),
            $bearsamppRoot->getRegistryLogFilePath(),
            $bearsamppRoot->getStartupLogFilePath(),
            $bearsamppRoot->getBatchLogFilePath(),
            $bearsamppRoot->getWinbinderLogFilePath(),
        ];
 
        $separator = '========================================================================================' . PHP_EOL;
        foreach ($logs as $log) {
            if (!file_exists($log)) {
                continue;
            }
            $logContent = @file_get_contents($log);
            if ($logContent !== false && !str_ends_with($logContent, $separator)) {
                file_put_contents($log, $separator, FILE_APPEND);
            }
        }
    }

    public static function trace($data, $file = null)
    {
        self::write($data, self::TRACE, $file);
    }

    public static function debug($data, $file = null)
    {
        self::write($data, self::DEBUG, $file);
    }

    public static function info($data, $file = null)
    {
        self::write($data, self::INFO, $file);
    }

    public static function warning($data, $file = null)
    {
        self::write($data, self::WARNING, $file);
    }

    public static function error($data, $file = null)
    {
        self::write($data, self::ERROR, $file);
    }

    public static function initClass($classInstance)
    {
        self::trace('Init ' . get_class($classInstance));
    }

    public static function reloadClass($classInstance)
    {
        self::trace('Reload ' . get_class($classInstance));
    }
}