Profiler.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Profiler;
 
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\WikiMap\WikiMap;
use Psr\Log\LoggerInterface;
use UnexpectedValueException;
use Wikimedia\Rdbms\TransactionProfiler;
 
abstract class Profiler {
    protected $profileID = false;
    protected $params = [];
    protected $trxProfiler;
    protected $logger;
    private $allowOutput = false;
 
    private static $instance = null;
 
    public function __construct( array $params ) {
        if ( isset( $params['profileID'] ) ) {
            $this->profileID = $params['profileID'];
        }
        $this->params = $params;
        $this->trxProfiler = new TransactionProfiler();
        $this->logger = LoggerFactory::getInstance( 'profiler' );
    }
 
    final public static function init( array $profilerConf ): void {
        $params = $profilerConf + [
            'class'     => ProfilerStub::class,
            'sampling'  => 1,
            'threshold' => 0.0,
            'output'    => [],
            'cliEnable' => false,
        ];
 
        // Avoid global func wfIsCLI() during setup
        $isCLI = ( PHP_SAPI === 'cli' || PHP_SAPI === 'phpdbg' );
        $inSample = $params['sampling'] === 1 || mt_rand( 1, $params['sampling'] ) === 1;
        if (
            !$inSample ||
            // On CLI, profiling is disabled by default, and can be explicitly enabled
            // via the `--profiler` option, which MediaWiki\Maintenance\MaintenanceRunner::setup
            // translates into 'cliEnable'.
            // See also $wgProfiler docs.
            //
            // For this to work, Setup.php must call Profiler::init() after handling of
            // MW_FINAL_SETUP_CALLBACK, which is what doMaintenance.php uses to call
            // MaintenanceRunner::setup.
            ( $isCLI && !$params['cliEnable'] )
        ) {
            $params['class'] = ProfilerStub::class;
        }
 
        if ( !is_array( $params['output'] ) ) {
            $params['output'] = [ $params['output'] ];
        }
 
        self::$instance = new $params['class']( $params );
    }
 
    final public static function instance() {
        if ( !self::$instance ) {
            trigger_error( 'Called Profiler::instance before settings are loaded', E_USER_WARNING );
            self::init( [] );
        }
 
        return self::$instance;
    }
 
    public function setProfileID( $id ) {
        wfDeprecated( __METHOD__, '1.41' );
        $this->profileID = $id;
    }
 
    public function getProfileID() {
        if ( $this->profileID === false ) {
            return WikiMap::getCurrentWikiDbDomain()->getId();
        } else {
            return $this->profileID;
        }
    }
 
    #[\NoDiscard]
    abstract public function scopedProfileIn( $section ): ?SectionProfileCallback;
 
    public function scopedProfileOut( ?SectionProfileCallback &$section = null ) {
        $section = null;
    }
 
    public function getTransactionProfiler() {
        return $this->trxProfiler;
    }
 
    abstract public function close();
 
    private function getOutputs() {
        $outputs = [];
        foreach ( $this->params['output'] as $outputType ) {
            // The class may be specified as either the full class name (for
            // example, 'ProfilerOutputStats') or (for backward compatibility)
            // the trailing portion of the class name (for example, 'stats').
            $outputClass = !str_contains( $outputType, 'ProfilerOutput' )
                ? 'ProfilerOutput' . ucfirst( $outputType )
                : $outputType;
            if ( !class_exists( $outputClass ) ) {
                throw new UnexpectedValueException( "'$outputType' is an invalid output type" );
            }
            $outputInstance = new $outputClass( $this, $this->params );
            if ( $outputInstance->canUse() ) {
                $outputs[] = $outputInstance;
            }
        }
        return $outputs;
    }
 
    public function logData() {
        if ( $this->params['threshold'] > 0.0 ) {
            // Note, this is also valid for CLI processes.
            $timeElapsed = microtime( true ) - $_SERVER['REQUEST_TIME_FLOAT'];
            if ( $timeElapsed <= $this->params['threshold'] ) {
                return;
            }
        }
 
        $outputs = [];
        foreach ( $this->getOutputs() as $output ) {
            if ( !$output->logsToOutput() ) {
                $outputs[] = $output;
            }
        }
 
        if ( $outputs ) {
            $stats = $this->getFunctionStats();
            foreach ( $outputs as $output ) {
                $output->log( $stats );
            }
        }
    }
 
    public function logDataPageOutputOnly() {
        if ( !$this->allowOutput ) {
            return;
        }
 
        $outputs = [];
        foreach ( $this->getOutputs() as $output ) {
            if ( $output->logsToOutput() ) {
                $outputs[] = $output;
            }
        }
 
        if ( $outputs ) {
            $stats = $this->getFunctionStats();
            foreach ( $outputs as $output ) {
                $output->log( $stats );
            }
        }
    }
 
    public function getContentType() {
        if ( $this->allowOutput ) {
            foreach ( headers_list() as $header ) {
                if ( preg_match( '#^content-type: (\w+/\w+);?#i', $header, $m ) ) {
                    return $m[1];
                }
            }
        }
        return null;
    }
 
    public function setAllowOutput() {
        $this->allowOutput = true;
    }
 
    public function getAllowOutput() {
        wfDeprecated( __METHOD__, '1.41' );
        return $this->allowOutput;
    }
 
    abstract public function getFunctionStats();
 
    abstract public function getOutput();
}
 
class_alias( Profiler::class, 'Profiler' );