Static Public Member Functions
static	commitSilentBuffer ()
static	debug ($data, $file=null)
static	error ($data, $file=null)
static	flush ()
static	flushAsyncQueue ()
static	getAsyncQueueDir ()
static	getAsyncQueueSize ()
static	getBufferSize ()
static	getStats ()
static	info ($data, $file=null)
static	init ()
static	initClass ($classInstance)
static	isAsyncEnabled ()
static	isSilent ()
static	processAsyncQueue ()
static	reloadClass ($classInstance)
static	reset ()
static	rollbackSilentBuffer ()
static	separator ()
static	setAsyncEnabled ($enabled)
static	setBufferSize ($size)
static	startSilentBuffer ()
static	trace ($data, $file=null)
static	warning ($data, $file=null)

Data Fields
const	DEBUG = 'DEBUG'
const	ERROR = 'ERROR'
const	INFO = 'INFO'
const	MAX_QUEUE_BATCH = 200
const	MAX_QUEUE_CONTENT_LENGTH = 1048576
const	MAX_QUEUE_TARGETS = 50
const	TRACE = 'TRACE'
const	WARNING = 'WARNING'

Static Private Member Functions
static	checkVerbosityAndAdjustAsync ()
static	cleanupStaleAsyncQueue ($maxAge)
static	initializeAsyncQueue ()
static	queueAsyncWrite ($file, $content)
static	sanitizeQueueTarget ($file)
static	write ($data, $type, $file=null)

Static Private Attributes
static	$asyncEnabled = true
static	$asyncQueueDir = null
static	$initClassCounts = array()
static	$logBuffer = []
static	$logBufferSize = 50
static	$logStats
static	$maxAsyncQueueBatch = 5
static	$reloadClassCounts = array()
static	$shutdownRegistered = false
static	$silentMode = false

Detailed Description

Log class providing static logging methods with buffered and asynchronous I/O.

Supports five log levels (TRACE, DEBUG, INFO, WARNING, ERROR), a separator utility, class-lifecycle helpers, and a configurable write buffer to reduce file-system pressure. Also supports asynchronous logging to decouple I/O operations from the main process.

Call Log\init() once during bootstrap (after globals are available) to register the shutdown flush handler and initialize async logging.

Usage:

Log::init();
Log::info('Application started');
Log::error('Something went wrong');

Definition at line 29 of file class.log.php.

Member Function Documentation

◆ checkVerbosityAndAdjustAsync()

checkVerbosityAndAdjustAsync ( )

staticprivate

Check logging verbosity and adjust async settings accordingly. Disables async when TRACE level is enabled for real-time log visibility. Also optimizes buffer size for better responsiveness during debugging.

Returns: void

Definition at line 106 of file class.log.php.

    {
        global $bearsamppConfig;
 
        try {
            if (!isset($bearsamppConfig)) {
                return;
            }
 
            $verbosity = $bearsamppConfig->getLogsVerbose();
 
            // Disable async and reduce buffer size for DEBUG/TRACE logging
            // This ensures live log monitoring shows logs immediately
            if ($verbosity === Config::VERBOSE_TRACE) {
                self::$asyncEnabled = false;
                // Use smaller buffer for TRACE to flush more frequently (every 10 entries)
                self::$logBufferSize = 10;
            } elseif ($verbosity === Config::VERBOSE_DEBUG) {
                self::$asyncEnabled = false;
                // For DEBUG level, use moderate buffer size (25 entries)
                self::$logBufferSize = 25;
            }
            // For INFO and REPORT levels, use default buffer size (50) with async enabled
        } catch (Exception $e) {
            // Silently fail - this is just an optimization
        }
    }

References $bearsamppConfig, Config\VERBOSE_DEBUG, and Config\VERBOSE_TRACE.

Referenced by init().

Here is the caller graph for this function:

◆ cleanupStaleAsyncQueue()

cleanupStaleAsyncQueue ( $maxAge )

staticprivate

Clean up stale queue files that weren't processed. Prevents queue directory from filling up with old entries.

Parameters

int $maxAge Maximum age in seconds

Returns: int Number of files removed

Definition at line 539 of file class.log.php.

    {
        if (!is_dir(self::$asyncQueueDir)) {
            return 0;
        }
 
        $removed = 0;
        $now     = time();
 
        try {
            $queueFiles = @glob(self::$asyncQueueDir . '/*.queue');
 
            if (!is_array($queueFiles)) {
                return 0;
            }
 
            foreach ($queueFiles as $queueFile) {
                try {
                    // Remove files older than maxAge
                    if ($now - @filemtime($queueFile) > $maxAge) {
                        @unlink($queueFile);
                        $removed++;
                    }
                } catch (Exception $e) {
                    // Skip
                }
            }
        } catch (Exception $e) {
            // Ignore cleanup errors
        }
 
        return $removed;
    }

Referenced by processAsyncQueue().

Here is the caller graph for this function:

◆ commitSilentBuffer()

commitSilentBuffer ( )

static

Exits silent mode and flushes all buffered entries to disk.

Returns: void

Definition at line 841 of file class.log.php.

    {
        self::$silentMode = false;
        self::flush();
    }

References flush().

Here is the call graph for this function:

◆ debug()

debug	(		$data,
			$file = null )

static

Logs a DEBUG-level message.

Parameters

mixed	$data
string \| null	$file

Definition at line 726 of file class.log.php.

    {
        self::write($data, self::DEBUG, $file);
    }

References write().

Referenced by ActionCheckVersion\__construct(), ActionQuit\__construct(), Action\call(), Path\changePath(), BinApache\changePort(), BinMailpit\changePort(), BinMariadb\changePort(), BinMemcached\changePort(), BinMysql\changePort(), BinPostgresql\changePort(), BinXlight\changePort(), QuickPick\checkDownloadId(), ActionQuit\checkForOrphanedProcesses(), BinApache\checkPort(), BinMailpit\checkPort(), BinMariadb\checkPort(), BinMemcached\checkPort(), BinMysql\checkPort(), BinPostgresql\checkPort(), BinXlight\checkPort(), Csrf\cleanupExpiredTokens(), ActionQuit\cleanupTemporaryFiles(), Win32Native\countFilesFolders(), Win32Native\countFilesFoldersCOM(), Win32Native\createShortcut(), QuickPick\fetchAndUnzipModule(), Csrf\generateToken(), Registry\getAppBinsRegKey(), Win32Native\getDefaultBrowser(), Util\getFilesToScan(), Win32Native\getInstalledBrowsers(), QuickPick\getModuleUrl(), Win32Native\getProcessList(), Win32Native\getServiceInfo(), Win32Native\getSpecialFolderPath(), QuickPick\getVersions(), BinPostgresql\handleNonPostgresUsage(), Win32Service\infos(), QuickPick\installModule(), Win32Native\killProcess(), Win32Native\listServices(), ModuleLoader\loadAsync(), ModuleLoader\loadSync(), QuickPick\logHeaders(), ActionQuit\performQuickCleanupVerification(), Action\process(), ActionQuit\processWindow(), QuickPick\rebuildQuickpickJson(), BinApache\refreshAlias(), BinApache\refreshConf(), BinApache\refreshVhosts(), QuickPick\regenerateMenuSafe(), Win32Native\registryDeleteKey(), Win32Native\registryDeleteValue(), Win32Native\registryExists(), Win32Native\registryGetValue(), Win32Native\registrySetValue(), Symlinks\safeRemoveSymlink(), ActionStartup\scanFolders(), Cache\set(), Cache\setDuration(), BinApache\setEnable(), BinMailpit\setEnable(), BinMariadb\setEnable(), BinMemcached\setEnable(), BinMysql\setEnable(), BinNodejs\setEnable(), BinPhp\setEnable(), BinPostgresql\setEnable(), BinXlight\setEnable(), ActionCheckVersion\showVersionOkMessageBox(), Win32Service\start(), BinApache\switchVersion(), BinMailpit\switchVersion(), BinMariadb\switchVersion(), BinMemcached\switchVersion(), BinMysql\switchVersion(), BinNodejs\switchVersion(), BinPhp\switchVersion(), BinPostgresql\switchVersion(), BinXlight\switchVersion(), Core\unzipFile(), AppPhpmyadmin\updateConfig(), AppPhppgadmin\updateConfig(), BinApache\updateConfig(), BinMailpit\updateConfig(), BinMariadb\updateConfig(), BinMemcached\updateConfig(), BinMysql\updateConfig(), BinNodejs\updateConfig(), BinPhp\updateConfig(), BinPostgresql\updateConfig(), BinXlight\updateConfig(), Module\updateConfig(), ToolGit\updateConfig(), QuickPick\updateModuleConfig(), Csrf\validateToken(), QuickPick\verifyModuleChecksum(), ActionQuit\verifyServicesStoppedAndCleanup(), ActionStartup\writeLog(), Batch\writeLog(), CommandRunner\writeLog(), Nssm\writeLog(), Registry\writeLog(), Win32Service\writeLog(), and WinBinder\writeLog().

Here is the call graph for this function:

◆ error()

error	(		$data,
			$file = null )

static

Logs an ERROR-level message. Errors bypass the buffer and are written immediately.

Parameters

mixed	$data
string \| null	$file

Definition at line 760 of file class.log.php.

    {
        self::write($data, self::ERROR, $file);
    }

References write().

Referenced by ActionCheckVersion\__construct(), ActionLoading\__construct(), ActionReload\__construct(), FiberModule\__construct(), Path\changePath(), BinApache\changePort(), BinMailpit\changePort(), BinMariadb\changePort(), BinMemcached\changePort(), BinMysql\changePort(), BinPostgresql\changePort(), BinXlight\changePort(), QuickPick\checkDownloadId(), ActionQuit\checkForOrphanedProcesses(), BinApache\checkPort(), BinMailpit\checkPort(), BinMariadb\checkPort(), BinMemcached\checkPort(), BinMysql\checkPort(), BinPostgresql\checkPort(), BinXlight\checkPort(), ActionQuit\cleanupTemporaryFiles(), Win32Native\countFilesFolders(), Win32Native\countFilesFoldersCOM(), OpenSsl\createCrt(), Symlinks\createModuleSymlink(), Win32Native\createShortcut(), ActionStartup\createSslCrts(), Symlinks\deleteCurrentSymlinks(), Util\deleteFolder(), HttpClient\downloadFile(), OpenSsl\ensureMkcertExeExists(), OpenSsl\ensureRootCaExists(), OpenSsl\ensureSslDirExists(), QuickPick\fetchAndUnzipModule(), QuickPick\fetchChecksumFromSidecar(), HttpClient\fetchGet(), Win32Native\findProcessesByName(), UtilString\generateSecureBytes(), UtilString\generateSecureToken(), HttpClient\getApiJson(), Core\getAppVersion(), Cache\getCacheIntegrityKey(), Util\getLatestVersion(), QuickPick\getModuleUrl(), Win32Native\getProcessInfo(), Win32Native\getProcessList(), QuickPick\getQuickpickJson(), Win32Native\getServiceInfo(), Win32Native\getSpecialFolderPath(), QuickPick\getVersions(), Splash\init(), BinMariadb\initData(), QuickPick\installModule(), ServiceHelper\installService(), OpenSsl\isExpired(), Symlinks\isPathWithinAllowedBase(), Core\isSafeDestinationFileList(), Win32Native\killProcess(), Win32Native\listServices(), OpenSsl\makeRootCa(), ActionCheckVersion\processWindow(), HttpClient\proxyDownload(), HttpClient\proxyFetch(), UtilString\random(), OpenSsl\rebuildAllCerts(), Win32Native\registryDeleteKey(), Win32Native\registryDeleteValue(), Win32Native\registryExists(), Win32Native\registrySetValue(), AppPhpmyadmin\reload(), AppPhppgadmin\reload(), BinApache\reload(), BinMailpit\reload(), BinMariadb\reload(), BinMemcached\reload(), BinMysql\reload(), BinNodejs\reload(), BinPhp\reload(), BinPostgresql\reload(), BinXlight\reload(), ToolBruno\reload(), ToolComposer\reload(), ToolGhostscript\reload(), ToolGit\reload(), ToolNgrok\reload(), ToolPerl\reload(), ToolPowerShell\reload(), ToolPython\reload(), ToolRuby\reload(), OpenSsl\removeCrt(), ServiceHelper\removeService(), Symlinks\safeRemoveSymlink(), Win32Service\start(), ServiceHelper\startService(), Win32Service\stop(), TplAppReload\triggerReload(), OpenSsl\trustRootCaInFirefox(), Core\unzipFile(), AppPhpmyadmin\updateConfig(), AppPhppgadmin\updateConfig(), BinApache\updateConfig(), BinMailpit\updateConfig(), BinMariadb\updateConfig(), BinMemcached\updateConfig(), BinMysql\updateConfig(), BinNodejs\updateConfig(), BinPhp\updateConfig(), BinPostgresql\updateConfig(), BinXlight\updateConfig(), QuickPick\updateModuleConfig(), QuickPick\verifyModuleChecksum(), ActionQuit\verifyServicesStoppedAndCleanup(), ActionQuit\verifySymlinksRemoved(), FiberModule\wait(), ModuleLoader\waitForModule(), and Nssm\writeLogError().

Here is the call graph for this function:

◆ flush()

flush ( )

static

Flushes the log buffer to disk using async writes when available. Groups entries by file to minimise file operations. Uses async logging to avoid blocking the main process on I/O. Falls back to synchronous writes or error_log() if needed.

Returns: void

Definition at line 249 of file class.log.php.

    {
        if (empty(self::$logBuffer)) {
            return;
        }
 
        global $bearsamppCore, $bearsamppConfig;
 
        // 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;
        }
 
        // Check if DEBUG or TRACE logging is active and force sync writes
        $forceSync = false;
        try {
            if (isset($bearsamppConfig)) {
                $verbosity = $bearsamppConfig->getLogsVerbose();
                if ($verbosity === Config::VERBOSE_TRACE || $verbosity === Config::VERBOSE_DEBUG) {
                    $forceSync = true;
                }
            }
        } catch (Exception $e) {
            // Ignore errors checking config
        }
 
        // 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;
            }
 
            // Use sync writes if TRACE is enabled or async is disabled
            if (!$forceSync && self::$asyncEnabled) {
                // Queue for async processing (non-blocking)
                $queued = self::queueAsyncWrite($file, $content);
 
                if ($queued) {
                    // Successfully queued, content will be written in background
                    self::$logStats['async']++;
                    self::$logStats['writes']++;
                    continue;
                }
                // If async queueing failed, fall through to sync write
            }
 
            // Synchronous write (immediate for TRACE, fallback for others)
            $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           = [];
    }

References $bearsamppConfig, $bearsamppCore, APP_TITLE, queueAsyncWrite(), Config\VERBOSE_DEBUG, and Config\VERBOSE_TRACE.

Referenced by commitSilentBuffer(), and write().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flushAsyncQueue()

flushAsyncQueue ( )

static

Process all queued log entries immediately (public method for manual flushing). Useful for live log monitoring or ensuring logs are written before critical operations.

Can be called at any time to flush pending async log writes.

Returns: int Number of queue files processed

Definition at line 410 of file class.log.php.

    {
        $totalProcessed = 0;
 
        // processAsyncQueue() processes one bounded batch; loop until nothing is left so the
        // manual flush and the shutdown path drain the queue completely.
        $iterationCap = 1000;
        for ($i = 0; $i < $iterationCap; $i++) {
            $processed = self::processAsyncQueue();
            if ($processed <= 0) {
                break;
            }
            $totalProcessed += $processed;
        }
 
        return $totalProcessed;
    }

References processAsyncQueue().

Here is the call graph for this function:

◆ getAsyncQueueDir()

getAsyncQueueDir ( )

static

Get the async queue directory path.

Returns: string|null

Definition at line 618 of file class.log.php.

    {
        return self::$asyncQueueDir;
    }

◆ getAsyncQueueSize()

getAsyncQueueSize ( )

static

Get current async queue size.

Returns: int

Definition at line 628 of file class.log.php.

    {
        if (!is_dir(self::$asyncQueueDir)) {
            return 0;
        }
 
        $files = @glob(self::$asyncQueueDir . '/*.queue');
 
        return is_array($files) ? count($files) : 0;
    }

◆ getBufferSize()

getBufferSize ( )

static

Returns the current log buffer size.

Returns: int

Definition at line 668 of file class.log.php.

    {
        return self::$logBufferSize;
    }

◆ getStats()

getStats ( )

static

Returns the current log buffer statistics.

Returns: array Array with keys 'buffered', 'flushed', and 'writes'.

Definition at line 644 of file class.log.php.

    {
        return self::$logStats;
    }

◆ info()

info	(		$data,
			$file = null )

static

Logs an INFO-level message.

Parameters

mixed	$data
string \| null	$file

Definition at line 737 of file class.log.php.

    {
        self::write($data, self::INFO, $file);
    }

References write().

Referenced by ActionQuit\__construct(), ActionReload\__construct(), ActionStartup\__construct(), ActionQuit\checkForOrphanedProcesses(), ActionQuit\cleanupTemporaryFiles(), Cache\clear(), ActionStartup\createSslCrts(), OpenSsl\ensureRootCaExists(), OpenSsl\ensureSslDirExists(), Batch\exitApp(), Util\getFilesToScan(), ServiceHelper\installService(), ActionStartup\installServicesSequential(), OpenSsl\makeRootCa(), OpenSsl\maybePromptTrustRootCa(), ActionQuit\performQuickCleanupVerification(), ActionQuit\processWindow(), OpenSsl\rebuildAllCerts(), AppPhpmyadmin\reload(), AppPhppgadmin\reload(), Apps\reload(), BinApache\reload(), BinMailpit\reload(), BinMariadb\reload(), BinMemcached\reload(), BinMysql\reload(), BinNodejs\reload(), BinPhp\reload(), BinPostgresql\reload(), Bins\reload(), BinXlight\reload(), ToolBruno\reload(), ToolComposer\reload(), ToolGhostscript\reload(), ToolGit\reload(), ToolNgrok\reload(), ToolPerl\reload(), ToolPowerShell\reload(), ToolPython\reload(), ToolRuby\reload(), OpenSsl\removeCrt(), ServiceHelper\removeService(), BinApache\setEnable(), BinMailpit\setEnable(), BinMariadb\setEnable(), BinMemcached\setEnable(), BinMysql\setEnable(), BinNodejs\setEnable(), BinPhp\setEnable(), BinPostgresql\setEnable(), BinXlight\setEnable(), Win32Service\start(), ServiceHelper\startAllServicesParallel(), ServiceHelper\stopAllServicesParallel(), OpenSsl\trustRootCaInFirefox(), Apps\update(), Bins\update(), Tools\update(), QuickPick\updateModuleConfig(), ActionQuit\verifyServicesStoppedAndCleanup(), ActionQuit\verifySymlinksRemoved(), and Nssm\writeLogInfo().

Here is the call graph for this function:

◆ init()

init ( )

static

Registers the shutdown flush handler and initializes async logging. Call once during bootstrap after globals are initialised.

Automatically disables async logging when TRACE verbosity is enabled, to ensure live log monitoring shows logs immediately.

Returns: void

Definition at line 84 of file class.log.php.

    {
        if (!self::$shutdownRegistered) {
            register_shutdown_function([__CLASS__, 'flush']);
            register_shutdown_function([__CLASS__, 'flushAsyncQueue']);
            self::$shutdownRegistered = true;
 
            // Initialize async queue directory
            self::initializeAsyncQueue();
 
            // Auto-disable async when TRACE logging is enabled (for live log monitoring)
            self::checkVerbosityAndAdjustAsync();
        }
    }

References checkVerbosityAndAdjustAsync(), and initializeAsyncQueue().

Referenced by Root\register(), and write().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initClass()

initClass ( $classInstance )

static

Logs the initialisation of a class instance at TRACE level. First occurrence of each class is logged at INFO level; subsequent occurrences are silently counted and a summary is emitted when the process terminates or on next unique init.

Parameters

object $classInstance

Definition at line 784 of file class.log.php.

    {
        $className = get_class($classInstance);
 
        if (isset(self::$initClassCounts[$className])) {
            self::$initClassCounts[$className]++;
 
            return;
        }
 
        self::$initClassCounts[$className] = 1;
        self::trace('Init ' . $className);
    }

References trace().

Referenced by AppPhpmyadmin\__construct(), AppPhppgadmin\__construct(), BinApache\__construct(), BinMailpit\__construct(), BinMariadb\__construct(), BinMemcached\__construct(), BinMysql\__construct(), BinNodejs\__construct(), BinPhp\__construct(), BinPostgresql\__construct(), Bins\__construct(), BinXlight\__construct(), Homepage\__construct(), Nssm\__construct(), Registry\__construct(), Splash\__construct(), ToolBruno\__construct(), ToolComposer\__construct(), ToolGhostscript\__construct(), ToolGit\__construct(), ToolNgrok\__construct(), ToolPerl\__construct(), ToolPowerShell\__construct(), ToolPython\__construct(), ToolRuby\__construct(), Win32Service\__construct(), and WinBinder\__construct().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initializeAsyncQueue()

initializeAsyncQueue ( )

staticprivate

Initialize async queue directory.

Returns: void

Definition at line 139 of file class.log.php.

    {
        try {
            // Set up queue directory in tmp
            self::$asyncQueueDir = Path::getTmpPath() . '/log-queue';
 
            // Create queue directory if it doesn't exist
            if (!is_dir(self::$asyncQueueDir)) {
                @mkdir(self::$asyncQueueDir, 0755, true);
            }
        } catch (Exception $e) {
            self::$asyncEnabled = false;
        }
    }

References Path\getTmpPath().

Referenced by init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isAsyncEnabled()

isAsyncEnabled ( )

static

Check if async logging is enabled.

Returns: bool

Definition at line 608 of file class.log.php.

    {
        return self::$asyncEnabled;
    }

◆ isSilent()

isSilent ( )

static

Returns whether the logger is currently in silent buffer mode.

Returns: bool

Definition at line 863 of file class.log.php.

    {
        return self::$silentMode;
    }

◆ processAsyncQueue()

processAsyncQueue ( )

static

Process all queued log entries at shutdown. Ensures any remaining queued logs are written before exit.

Returns: int Number of queue files processed

Definition at line 434 of file class.log.php.

    {
        if (!is_dir(self::$asyncQueueDir)) {
            return 0;
        }
 
        $processed = 0;
 
        try {
            $queueFiles = glob(self::$asyncQueueDir . '/*.queue');
            if (!is_array($queueFiles) || empty($queueFiles)) {
                return 0;
            }
 
            // Bound the work performed in one pass: read at most MAX_QUEUE_BATCH files so
            // a flood of queue entries cannot exhaust memory. Anything beyond the batch,
            // or deferred by the target cap below, is left on disk for a later pass.
            $batchFiles = array_slice($queueFiles, 0, self::MAX_QUEUE_BATCH);
 
            // Group entries by target file
            $entriesByFile = [];
 
            foreach ($batchFiles as $queueFile) {
                try {
                    // Read and deserialize queue entry
                    $serialized = @file_get_contents($queueFile);
                    if ($serialized === false) {
                        continue;
                    }
 
                    $entry = @unserialize($serialized, ['allowed_classes' => false]);
                    if ($entry === false || !isset($entry['file']) || !isset($entry['content'])) {
                        // Invalid queue entry, remove it
                        @unlink($queueFile);
                        continue;
                    }
 
                    // Validate the destination is inside the logs directory and not a path traversal.
                    // Queue files live in a shared tmp dir, so a local attacker could plant a rogue
                    // entry and redirect appends to arbitrary files if we trusted $entry['file'] blindly.
                    $targetFile = self::sanitizeQueueTarget($entry['file']);
                    if ($targetFile === null) {
                        // Invalid/unsafe target - discard the rogue entry
                        @unlink($queueFile);
                        continue;
                    }
 
                    // Cap the distinct target files processed in this pass. Once reached, stop
                    // accumulating and leave this entry (and those after it) untouched so they
                    // are preserved for a later pass rather than being dropped.
                    if (!isset($entriesByFile[$targetFile]) &&
                        count($entriesByFile) >= self::MAX_QUEUE_TARGETS) {
                        break;
                    }
 
                    // Cap the content size to prevent log bloat / disk exhaustion from rogue entries.
                    $content = (string)$entry['content'];
                    if (strlen($content) > self::MAX_QUEUE_CONTENT_LENGTH) {
                        @unlink($queueFile);
                        continue;
                    }
 
                    if (!isset($entriesByFile[$targetFile])) {
                        $entriesByFile[$targetFile] = [];
                    }
 
                    $entriesByFile[$targetFile][] = $content;
                    $processed++;
 
                    // Remove the processed queue file
                    @unlink($queueFile);
                } catch (Exception $e) {
                    // Skip bad entries
                    @unlink($queueFile);
                }
            }
 
            // Write all accumulated entries to their target files
            foreach ($entriesByFile as $targetFile => $contents) {
                try {
                    $combined = implode('', $contents);
                    @file_put_contents($targetFile, $combined, FILE_APPEND | LOCK_EX);
                } catch (Exception $e) {
                    // Log write failed - use error_log as fallback
                    error_log('Failed to write to ' . $targetFile);
                }
            }
 
            // Clean up any stale queue files
            self::cleanupStaleAsyncQueue(3600);
        } catch (Exception $e) {
            // Silently fail
        }
 
        return $processed;
    }

References cleanupStaleAsyncQueue(), and sanitizeQueueTarget().

Referenced by flushAsyncQueue().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ queueAsyncWrite()

queueAsyncWrite	(		$file,
			$content )

staticprivate

Queue a log entry for asynchronous writing. Returns immediately without blocking on I/O.

Parameters

string	$file	Target log file path
string	$content	Log content to write

Returns: bool True if queued successfully

Definition at line 334 of file class.log.php.

    {
        if (!self::$asyncEnabled || !is_dir(self::$asyncQueueDir)) {
            return false;
        }
 
        // Defense-in-depth: reject oversized content at the source.
        if (strlen((string)$content) > self::MAX_QUEUE_CONTENT_LENGTH) {
            return false;
        }
 
        try {
            // Create a unique queue file for this write
            $queueFile = self::$asyncQueueDir . '/' . uniqid('log_', true) . '.queue';
 
            // Queue entry contains the target file and content
            $queueEntry = [
                'file'      => $file,
                'content'   => $content,
                'timestamp' => time(),
            ];
 
            // Write queue entry (this is a small, fast operation)
            $serialized = serialize($queueEntry);
            $written    = @file_put_contents($queueFile, $serialized, LOCK_EX);
 
            return ($written !== false);
        } catch (Exception $e) {
            // Silently fail - this is async so we don't want to interrupt main process
            return false;
        }
    }

Referenced by flush().

Here is the caller graph for this function:

◆ reloadClass()

reloadClass ( $classInstance )

static

Logs the reloading of a class instance at TRACE level. Only the first occurrence per class name is logged; subsequent duplicates are silently skipped.

Parameters

object $classInstance

Definition at line 805 of file class.log.php.

    {
        $className = get_class($classInstance);
 
        if (isset(self::$reloadClassCounts[$className])) {
            self::$reloadClassCounts[$className]++;
 
            return;
        }
 
        self::$reloadClassCounts[$className] = 1;
        self::trace('Reload ' . $className);
    }

References trace().

Referenced by AppPhpmyadmin\reload(), AppPhppgadmin\reload(), BinApache\reload(), BinMailpit\reload(), BinMariadb\reload(), BinMemcached\reload(), BinMysql\reload(), BinNodejs\reload(), BinPhp\reload(), BinPostgresql\reload(), BinXlight\reload(), ToolBruno\reload(), ToolComposer\reload(), ToolGhostscript\reload(), ToolGit\reload(), ToolNgrok\reload(), ToolPerl\reload(), ToolPowerShell\reload(), ToolPython\reload(), and ToolRuby\reload().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset()

reset ( )

static

Clears the buffer and resets statistics. Useful in tests or when re-initialising the application.

Returns: void

Definition at line 579 of file class.log.php.

    {
        self::$logBuffer          = [];
        self::$shutdownRegistered = false;
        self::$logStats           = [
            'buffered' => 0,
            'flushed'  => 0,
            'writes'   => 0,
            'async'    => 0,
        ];
    }

◆ rollbackSilentBuffer()

rollbackSilentBuffer ( )

static

Exits silent mode and discards all buffered entries without writing.

Returns: void

Definition at line 852 of file class.log.php.

    {
        self::$silentMode = false;
        self::$logBuffer  = [];
    }

◆ sanitizeQueueTarget()

sanitizeQueueTarget ( $file )

staticprivate

Validates and normalizes a queue-entry target path.

Queue files live in a shared tmp directory, so a local attacker could plant a rogue entry whose 'file' value points anywhere on disk. To prevent arbitrary file appends, we only accept paths that resolve inside the Bearsampp logs directory and contain no path-traversal ('..') segments.

Parameters

string $file Raw target path from a queue entry.

Returns: string|null Normalized safe path, or null if rejected.

Definition at line 379 of file class.log.php.

    {
        $file = (string)$file;
        if ($file === '') {
            return null;
        }
 
        $normalized = str_replace('\\', '/', $file);
        if (strpos($normalized, '..') !== false) {
            return null;
        }
 
        $logsPath           = Path::getLogsPath();
        $logsPathNormalized = str_replace('\\', '/', rtrim($logsPath, '/\\')) . '/';
 
        // Only allow appends into the application logs directory.
        if (strpos($normalized, $logsPathNormalized) !== 0) {
            return null;
        }
 
        return $file;
    }

References Path\getLogsPath().

Referenced by processAsyncQueue().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ separator()

separator ( )

static

Appends a separator line to each log file that does not already end with one.

@global object $bearsamppRoot

Definition at line 678 of file class.log.php.

    {
        if (self::$silentMode) {
            return;
        }
 
        global $bearsamppRoot;
 
        $logs = [
            Path::getLogFilePath(),
            Path::getErrorLogFilePath(),
            Path::getServicesLogFilePath(),
            Path::getRegistryLogFilePath(),
            Path::getStartupLogFilePath(),
            Path::getBatchLogFilePath(),
            Path::getWinbinderLogFilePath(),
            Path::getHomepageLogFilePath(),
        ];
 
        $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);
            }
        }
    }

References $bearsamppRoot, Path\getBatchLogFilePath(), Path\getErrorLogFilePath(), Path\getHomepageLogFilePath(), Path\getLogFilePath(), Path\getRegistryLogFilePath(), Path\getServicesLogFilePath(), Path\getStartupLogFilePath(), and Path\getWinbinderLogFilePath().

Referenced by Root\register().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setAsyncEnabled()

setAsyncEnabled ( $enabled )

static

Enable or disable async logging.

Parameters

bool $enabled

Returns: void

Definition at line 598 of file class.log.php.

    {
        self::$asyncEnabled = (bool)$enabled;
    }

◆ setBufferSize()

setBufferSize ( $size )

static

Sets the log buffer size.

Parameters

int $size New buffer size (1â€“1000).

Returns: void

Definition at line 656 of file class.log.php.

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

◆ startSilentBuffer()

startSilentBuffer ( )

static

Enters silent buffer mode: all subsequent log entries are held in memory and not flushed to disk. ERROR-level entries always flush even in silent mode so critical failures are never lost.

Use commitSilentBuffer() to flush on success, or rollbackSilentBuffer() to discard the buffer.

Returns: void

Definition at line 829 of file class.log.php.

    {
        self::$silentMode = true;
        // Discard anything already buffered from early bootstrap (e.g. separator)
        self::$logBuffer = [];
    }

◆ trace()

trace	(		$data,
			$file = null )

static

Logs a TRACE-level message.

Parameters

mixed	$data
string \| null	$file

Definition at line 715 of file class.log.php.

    {
        self::write($data, self::TRACE, $file);
    }

References write().

Referenced by ActionCheckVersion\__construct(), ActionExec\__construct(), ActionLoading\__construct(), ActionManualRestart\__construct(), ActionRebuildini\__construct(), Win32Service\callWin32Service(), BinMysql\changeRootPassword(), ActionLoading\checkAllServicesStarted(), ActionStartup\checkApacheServiceWithTimeout(), ActionStartup\checkMySQLServiceWithTimeout(), BinMysql\checkPort(), BinMysql\checkRootPassword(), Win32Service\create(), OpenSsl\createCrt(), ActionStartup\createSslCrts(), Win32Service\delete(), Symlinks\deleteCurrentSymlinks(), HttpClient\downloadFile(), Win32Service\ensureReset(), Win32Service\fastServiceCheck(), QuickPick\fetchChecksumFromSidecar(), ServiceHelper\forceKillService(), HttpClient\getApiJson(), HttpClient\getCurlHttpHeaders(), HttpClient\getHeaders(), HttpClient\getHttpHeaders(), Util\getLatestVersion(), Win32Service\getServices(), Win32Service\infos(), initClass(), BinMariadb\initData(), BinMysql\initData(), ActionStartup\installServices(), ActionStartup\installServicesSequential(), OpenSsl\isExpired(), Win32Service\isInstalled(), Win32Service\isPaused(), Win32Service\isPending(), Win32Service\isRunning(), Win32Service\isStopped(), ActionStartup\prepareService(), ActionLoading\processLoading(), ActionQuit\processWindow(), ActionStartup\processWindow(), ActionSwitchVersion\processWindow(), HttpClient\proxyDownload(), HttpClient\proxyFetch(), BinMailpit\rebuildConf(), BinApache\refreshAlias(), BinApache\refreshConf(), BinApache\refreshVhosts(), reloadClass(), Config\replaceAll(), Util\replaceInFile(), ActionStartup\rotationLogs(), Symlinks\safeRemoveSymlink(), ActionStartup\scanFolders(), BinMailpit\setVersion(), BinPhp\setVersion(), ServiceHelper\shutdownServicesParallel(), ServiceHelper\shutdownServicesSequential(), ServiceHelper\startAllServicesParallel(), Util\startLoading(), ServiceHelper\startServicesParallel(), ServiceHelper\startServicesSequential(), Win32Service\status(), Win32Service\stop(), ServiceHelper\stopAllServicesParallel(), ActionQuit\terminatePhpProcesses(), TplAppReload\triggerReload(), Core\unzipFile(), BinPhp\updateConfig(), ActionSwitchVersion\updateConfigVersion(), and Win32Service\waitForServiceDeletion().

Here is the call graph for this function:

◆ warning()

warning	(		$data,
			$file = null )

static

Logs a WARNING-level message.

Parameters

mixed	$data
string \| null	$file

Definition at line 748 of file class.log.php.

    {
        self::write($data, self::WARNING, $file);
    }

References write().

Referenced by ActionQuit\checkForOrphanedProcesses(), ActionQuit\cleanupTemporaryFiles(), Symlinks\createModuleSymlink(), OpenSsl\ensureSslDirExists(), Cache\get(), Csrf\getAllowedHosts(), CacheManager\init(), FiberModuleLoader\init(), Batch\initializeMariadb(), Batch\initializeMysql(), Batch\initializePostgresql(), ServiceHelper\installService(), ActionStartup\installServicesSequential(), Csrf\isAllowedOrigin(), OpenSsl\isExpired(), OpenSsl\maybePromptTrustRootCa(), ActionQuit\performQuickCleanupVerification(), ActionQuit\processWindow(), QuickPick\regenerateMenuSafe(), ToolGit\reload(), OpenSsl\removeCrt(), ServiceHelper\removeService(), Symlinks\safeRemoveSymlink(), UtilInput\sanitizePath(), UtilInput\sanitizePID(), UtilInput\sanitizePort(), UtilInput\sanitizeServiceName(), Csrf\validateOrigin(), Csrf\validateRequest(), Csrf\validateToken(), ActionQuit\verifyServicesStoppedAndCleanup(), ActionQuit\verifySymlinksRemoved(), FiberModule\wait(), FiberModuleLoader\waitAll(), and CacheManager\writeCache().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ write()

write	(	$data,
		$type,
		$file = null )

staticprivate

Writes a message to a log file, using the buffer to reduce I/O.

The file path is resolved as follows:

If $file is provided by the caller it is used as-is.
Otherwise the default path is chosen based on $type (error log vs. main log), then overridden with the homepage log when not running in root context.

Parameters

mixed	$data	The message to log.
string	$type	One of the Log level constants.
string \| null	$file	Explicit file path, or null to use the default.

Definition at line 166 of file class.log.php.

    {
        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
                ? Path::getErrorLogFilePath()
                : Path::getLogFilePath();
 
            if (!$bearsamppRoot->isRoot()) {
                $file = Path::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) {
            // Sanitize line breaks to prevent log forging (injecting fake log lines).
            self::$logBuffer[] = [
                'file' => $file,
                'data' => str_replace(["\r", "\n"], ' ', (string)$data),
                'type' => $type,
                'time' => time(),
            ];
            self::$logStats['buffered']++;
 
            // In silent mode, suppress auto-flush so the caller can decide
            // whether to commit (flush) or rollback (discard) the buffer.
            // ERROR entries always flush — they must never be silently dropped.
            if (self::$silentMode && $type !== self::ERROR) {
                return;
            }
 
            // Flush immediately for:
            // 1. Errors (always)
            // 2. TRACE/DEBUG level logs (for real-time visibility during debugging)
            // 3. When buffer reaches the configured size limit
            $debugVerbosity = $bearsamppConfig->getLogsVerbose();
            $isDebugMode    = ($debugVerbosity === Config::VERBOSE_TRACE || $debugVerbosity === Config::VERBOSE_DEBUG);
            $shouldFlush    = $type === self::ERROR ||
                $isDebugMode ||
                count(self::$logBuffer) >= self::$logBufferSize;
 
            if ($shouldFlush) {
                self::flush();
            }
        }
    }

References $bearsamppConfig, $bearsamppCore, $bearsamppRoot, $verbose, flush(), Path\getErrorLogFilePath(), Path\getHomepageLogFilePath(), Path\getLogFilePath(), init(), Config\VERBOSE_DEBUG, Config\VERBOSE_REPORT, Config\VERBOSE_SIMPLE, and Config\VERBOSE_TRACE.

Referenced by debug(), error(), info(), trace(), and warning().

Here is the call graph for this function:

Here is the caller graph for this function:

Field Documentation

◆ $asyncEnabled

$asyncEnabled = true

staticprivate

Definition at line 70 of file class.log.php.

◆ $asyncQueueDir

$asyncQueueDir = null

staticprivate

Definition at line 67 of file class.log.php.

◆ $initClassCounts

$initClassCounts = array()

staticprivate

Definition at line 771 of file class.log.php.

◆ $logBuffer

$logBuffer = []

staticprivate

Definition at line 47 of file class.log.php.

◆ $logBufferSize

$logBufferSize = 50

staticprivate

Definition at line 50 of file class.log.php.

◆ $logStats

$logStats

staticprivate

Initial value:

                         = [
    'buffered' => 0,
    'flushed'  => 0,
    'writes'   => 0,
    'async'    => 0,
]

Definition at line 56 of file class.log.php.

◆ $maxAsyncQueueBatch

$maxAsyncQueueBatch = 5

staticprivate

Definition at line 73 of file class.log.php.

◆ $reloadClassCounts

$reloadClassCounts = array()

staticprivate

Definition at line 774 of file class.log.php.

◆ $shutdownRegistered

$shutdownRegistered = false

staticprivate

Definition at line 53 of file class.log.php.

◆ $silentMode

$silentMode = false

staticprivate

Definition at line 64 of file class.log.php.

◆ DEBUG

const DEBUG = 'DEBUG'

Definition at line 34 of file class.log.php.

◆ ERROR

const ERROR = 'ERROR'

Definition at line 31 of file class.log.php.

◆ INFO

const INFO = 'INFO'

Definition at line 33 of file class.log.php.

◆ MAX_QUEUE_BATCH

const MAX_QUEUE_BATCH = 200

Definition at line 41 of file class.log.php.

◆ MAX_QUEUE_CONTENT_LENGTH

const MAX_QUEUE_CONTENT_LENGTH = 1048576

Definition at line 38 of file class.log.php.

◆ MAX_QUEUE_TARGETS

const MAX_QUEUE_TARGETS = 50

Definition at line 44 of file class.log.php.

◆ TRACE

const TRACE = 'TRACE'

Definition at line 35 of file class.log.php.

◆ WARNING

const WARNING = 'WARNING'

Definition at line 32 of file class.log.php.

The documentation for this class was generated from the following file:

E:/Bearsampp-development/sandbox/core/classes/class.log.php

Static Public Member Functions

Data Fields

Static Private Member Functions

Static Private Attributes

Detailed Description

Member Function Documentation

◆ checkVerbosityAndAdjustAsync()

◆ cleanupStaleAsyncQueue()

◆ commitSilentBuffer()

◆ debug()

◆ error()

◆ flush()

◆ flushAsyncQueue()

◆ getAsyncQueueDir()

◆ getAsyncQueueSize()

◆ getBufferSize()

◆ getStats()

◆ info()

◆ init()

◆ initClass()

◆ initializeAsyncQueue()

◆ isAsyncEnabled()

◆ isSilent()

◆ processAsyncQueue()

◆ queueAsyncWrite()

◆ reloadClass()

◆ reset()

◆ rollbackSilentBuffer()

◆ sanitizeQueueTarget()

◆ separator()

◆ setAsyncEnabled()

◆ setBufferSize()

◆ startSilentBuffer()

◆ trace()

◆ warning()

◆ write()

Field Documentation

◆ $asyncEnabled

◆ $asyncQueueDir

◆ $initClassCounts

◆ $logBuffer

◆ $logBufferSize

◆ $logStats

◆ $maxAsyncQueueBatch

◆ $reloadClassCounts

◆ $shutdownRegistered

◆ $silentMode

◆ DEBUG

◆ ERROR

◆ INFO

◆ MAX_QUEUE_BATCH

◆ MAX_QUEUE_CONTENT_LENGTH

◆ MAX_QUEUE_TARGETS

◆ TRACE

◆ WARNING