Pingback.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Installer;
 
use MediaWiki\Config\Config;
use MediaWiki\Http\HttpRequestFactory;
use MediaWiki\Json\FormatJson;
use MediaWiki\MainConfigNames;
use MediaWiki\Utils\MWCryptRand;
use Psr\Log\LoggerInterface;
use Wikimedia\LockManager\ILockManager;
use Wikimedia\ObjectCache\BagOStuff;
use Wikimedia\Rdbms\DBError;
use Wikimedia\Rdbms\IConnectionProvider;
use Wikimedia\Timestamp\ConvertibleTimestamp;
use Wikimedia\Timestamp\TimestampFormat as TS;
 
class Pingback {
 
    private const LEGACY_EVENTLOGGING_SCHEMA = 'MediaWikiPingback';
 
    private const EVENT_PLATFORM_SCHEMA_ID = '/analytics/legacy/mediawikipingback/1.0.0';
 
    private const EVENT_PLATFORM_STREAM = 'eventlogging_MediaWikiPingback';
 
    private const EVENT_PLATFORM_EVENT_INTAKE_SERVICE_URI =
        'https://intake-analytics.wikimedia.org/v1/events?hasty=true';
 
    protected $logger;
    protected $config;
    protected $dbProvider;
    protected $cache;
    protected $http;
    protected $key;
    protected $eventIntakeUri;
    private ILockManager $lockManager;
 
    public function __construct(
        Config $config,
        IConnectionProvider $dbProvider,
        BagOStuff $cache,
        HttpRequestFactory $http,
        LoggerInterface $logger,
        ILockManager $lockManager,
        string $eventIntakeUrl = self::EVENT_PLATFORM_EVENT_INTAKE_SERVICE_URI
    ) {
        $this->config = $config;
        $this->dbProvider = $dbProvider;
        $this->cache = $cache;
        $this->http = $http;
        $this->logger = $logger;
        $this->key = 'Pingback-' . MW_VERSION;
        $this->eventIntakeUri = $eventIntakeUrl;
        $this->lockManager = $lockManager;
    }
 
    public function run(): void {
        if ( !$this->config->get( MainConfigNames::Pingback ) ) {
            // disabled
            return;
        }
        if ( $this->wasRecentlySent() ) {
            // already sent recently
            return;
        }
        if ( !$this->acquireLock() ) {
            $this->logger->debug( __METHOD__ . ": couldn't acquire lock" );
            return;
        }
 
        $data = $this->getData();
        if ( !$this->postPingback( $data ) ) {
            $this->logger->warning( __METHOD__ . ": failed to send; check 'http' log channel" );
            return;
        }
 
        // Record the fact that we have sent a pingback for this MediaWiki version,
        // so we don't submit data multiple times.
        $dbw = $this->dbProvider->getPrimaryDatabase();
        $timestamp = ConvertibleTimestamp::time();
        $dbw->newInsertQueryBuilder()
            ->insertInto( 'updatelog' )
            ->row( [ 'ul_key' => $this->key, 'ul_value' => $timestamp ] )
            ->onDuplicateKeyUpdate()
            ->uniqueIndexFields( [ 'ul_key' ] )
            ->set( [ 'ul_value' => $timestamp ] )
            ->caller( __METHOD__ )->execute();
        $this->logger->debug( __METHOD__ . ": pingback sent OK ({$this->key})" );
    }
 
    private function wasRecentlySent(): bool {
        $timestamp = $this->dbProvider->getReplicaDatabase()->newSelectQueryBuilder()
            ->select( 'ul_value' )
            ->from( 'updatelog' )
            ->where( [ 'ul_key' => $this->key ] )
            ->caller( __METHOD__ )->fetchField();
        if ( $timestamp === false ) {
            return false;
        }
        // send heartbeat ping if the last ping was over a month ago
        if ( ConvertibleTimestamp::time() - (int)$timestamp > 60 * 60 * 24 * 30 ) {
            return false;
        }
        return true;
    }
 
    private function acquireLock(): bool {
        $cacheKey = $this->cache->makeKey( 'pingback', $this->key );
        if ( !$this->cache->add( $cacheKey, 1, $this->cache::TTL_HOUR ) ) {
            // throttled
            return false;
        }
 
        if ( !$this->lockManager->lockKey( $this->key ) ) {
            // already in progress
            return false;
        }
 
        return true;
    }
 
    protected function getData(): array {
        $wiki = $this->fetchOrInsertId();
 
        return [
            'event' => self::getSystemInfo( $this->config ),
            'schema' => self::LEGACY_EVENTLOGGING_SCHEMA,
            'wiki' => $wiki,
 
            // This would be added by
            // https://gerrit.wikimedia.org/g/mediawiki/extensions/EventLogging/+/d47dbc10455bcb6dbc98a49fa169f75d6131c3da/includes/EventLogging.php#274
            // onwards.
            '$schema' => self::EVENT_PLATFORM_SCHEMA_ID,
            'client_dt' => ConvertibleTimestamp::now( TS::ISO_8601 ),
 
            // This would be added by
            // https://gerrit.wikimedia.org/r/plugins/gitiles/mediawiki/extensions/EventLogging/+/d47dbc10455bcb6dbc98a49fa169f75d6131c3da/includes/EventSubmitter/EventBusEventSubmitter.php#81
            // onwards.
            'meta' => [
                'stream' => self::EVENT_PLATFORM_STREAM,
            ],
        ];
    }
 
    public static function getSystemInfo( Config $config ): array {
        $event = [
            'database' => $config->get( MainConfigNames::DBtype ),
            'MediaWiki' => MW_VERSION,
            'PHP' => PHP_VERSION,
            'OS' => PHP_OS . ' ' . php_uname( 'r' ),
            'arch' => PHP_INT_SIZE === 8 ? 64 : 32,
            'machine' => php_uname( 'm' ),
        ];
 
        if ( isset( $_SERVER['SERVER_SOFTWARE'] ) ) {
            $event['serverSoftware'] = $_SERVER['SERVER_SOFTWARE'];
        }
 
        $limit = ini_get( 'memory_limit' );
        if ( $limit && $limit !== "-1" ) {
            $event['memoryLimit'] = $limit;
        }
 
        return $event;
    }
 
    private function fetchOrInsertId(): string {
        // We've already obtained a primary connection for the lock, and plan to do a write.
        // But, still prefer reading this immutable value from a replica to reduce load.
        $id = $this->dbProvider->getReplicaDatabase()->newSelectQueryBuilder()
            ->select( 'ul_value' )
            ->from( 'updatelog' )
            ->where( [ 'ul_key' => 'PingBack' ] )
            ->caller( __METHOD__ )->fetchField();
        if ( $id !== false ) {
            return $id;
        }
 
        $dbw = $this->dbProvider->getPrimaryDatabase();
        $id = $dbw->newSelectQueryBuilder()
            ->select( 'ul_value' )
            ->from( 'updatelog' )
            ->where( [ 'ul_key' => 'PingBack' ] )
            ->caller( __METHOD__ )->fetchField();
        if ( $id !== false ) {
            return $id;
        }
 
        $id = MWCryptRand::generateHex( 32 );
        $dbw->newInsertQueryBuilder()
            ->insertInto( 'updatelog' )
            ->row( [ 'ul_key' => 'PingBack', 'ul_value' => $id ] )
            ->caller( __METHOD__ )->execute();
        return $id;
    }
 
    private function postPingback( array $data ): bool {
        $request = $this->http->create( $this->eventIntakeUri, [
            'method' => 'POST',
            'postData' => FormatJson::encode( $data ),
        ], __METHOD__ );
        $request->setHeader( 'Content-Type', 'application/json' );
 
        $result = $request->execute();
 
        return $result->isGood();
    }
}
 
class_alias( Pingback::class, 'Pingback' );