Profiler.php

Go to the documentation of this file.

<?php
use MediaWiki\Logger\LoggerFactory;
use Psr\Log\LoggerInterface;
use Wikimedia\Rdbms\TransactionProfiler;
use Wikimedia\ScopedCallback;
 
abstract class Profiler {
    protected $profileID = false;
    protected $params = [];
    protected $context = null;
    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 instance() {
        if ( self::$instance === null ) {
            global $wgProfiler;
 
            $params = $wgProfiler + [
                'class'     => ProfilerStub::class,
                'sampling'  => 1,
                'threshold' => 0.0,
                'output'    => [],
            ];
 
            $inSample = mt_rand( 0, $params['sampling'] - 1 ) === 0;
            // wfIsCLI() is not available yet
            if ( PHP_SAPI === 'cli' || PHP_SAPI === 'phpdbg' || !$inSample ) {
                $params['class'] = ProfilerStub::class;
            }
 
            if ( !is_array( $params['output'] ) ) {
                $params['output'] = [ $params['output'] ];
            }
 
            self::$instance = new $params['class']( $params );
        }
        return self::$instance;
    }
 
    final public static function replaceStubInstance( Profiler $profiler ) {
        if ( self::$instance && !( self::$instance instanceof ProfilerStub ) ) {
            throw new MWException( 'Could not replace non-stub profiler instance.' );
        } else {
            self::$instance = $profiler;
        }
    }
 
    public function setProfileID( $id ) {
        $this->profileID = $id;
    }
 
    public function getProfileID() {
        if ( $this->profileID === false ) {
            return WikiMap::getCurrentWikiDbDomain()->getId();
        } else {
            return $this->profileID;
        }
    }
 
    public function setContext( $context ) {
        $this->context = $context;
    }
 
    public function getContext() {
        if ( $this->context ) {
            return $this->context;
        } else {
            $this->logger->warning( __METHOD__ . " called before setContext, " .
                "fallback to RequestContext::getMain()." );
            return RequestContext::getMain();
        }
    }
 
    public function profileIn( $functionname ) {
        wfDeprecated( __METHOD__, '1.33' );
    }
 
    public function profileOut( $functionname ) {
        wfDeprecated( __METHOD__, '1.33' );
    }
 
    abstract public function scopedProfileIn( $section );
 
    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 = strpos( $outputType, 'ProfilerOutput' ) === false
                ? 'ProfilerOutput' . ucfirst( $outputType )
                : $outputType;
            if ( !class_exists( $outputClass ) ) {
                throw new MWException( "'$outputType' is an invalid output type" );
            }
            $outputInstance = new $outputClass( $this, $this->params );
            if ( $outputInstance->canUse() ) {
                $outputs[] = $outputInstance;
            }
        }
        return $outputs;
    }
 
    public function logData() {
        $request = $this->getContext()->getRequest();
 
        $timeElapsed = $request->getElapsedTime();
        $timeElapsedThreshold = $this->params['threshold'];
        if ( $timeElapsed <= $timeElapsedThreshold ) {
            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 setTemplated( $t ) {
        wfDeprecated( __METHOD__, '1.34' );
        $this->allowOutput = ( $t === true );
    }
 
    public function getTemplated() {
        wfDeprecated( __METHOD__, '1.34' );
        return $this->getAllowOutput();
    }
 
    public function setAllowOutput() {
        $this->allowOutput = true;
    }
 
    public function getAllowOutput() {
        return $this->allowOutput;
    }
 
    abstract public function getFunctionStats();
 
    abstract public function getOutput();
}