UserEditTracker.php

Go to the documentation of this file.

<?php
 
namespace MediaWiki\User;
 
use InvalidArgumentException;
use LogicException;
use MediaWiki\DAO\WikiAwareEntity;
use MediaWiki\Deferred\DeferredUpdates;
use MediaWiki\Deferred\UserEditCountUpdate;
use MediaWiki\JobQueue\JobQueueGroup;
use MediaWiki\WikiMap\WikiMap;
use Wikimedia\ObjectCache\WANObjectCache;
use Wikimedia\Rdbms\IConnectionProvider;
use Wikimedia\Rdbms\IDBAccessObject;
use Wikimedia\Rdbms\SelectQueryBuilder;
use Wikimedia\Timestamp\ConvertibleTimestamp;
use Wikimedia\Timestamp\TimestampFormat as TS;
 
class UserEditTracker {
 
    private const FIRST_EDIT = 1;
    private const LATEST_EDIT = 2;
 
    private const CACHE_FIRST_EDIT = 'firsteditts';
    private const CACHE_EDIT_COUNT = 'editcount';
 
    private array $userEditCountCache = [];
 
    public function __construct(
        private readonly ActorStoreFactory $actorStoreFactory,
        private readonly IConnectionProvider $dbProvider,
        private readonly JobQueueGroup $jobQueueGroup,
        private readonly WANObjectCache $wanObjectCache,
    ) {
    }
 
    public function getUserEditCount( UserIdentity $user ): ?int {
        if ( !$user->isRegistered() ) {
            return null;
        }
 
        $cacheKey = $this->getCacheKey( self::CACHE_EDIT_COUNT, $user );
        if ( isset( $this->userEditCountCache[ $cacheKey ] ) ) {
            return $this->userEditCountCache[ $cacheKey ];
        }
 
        $wikiId = $user->getWikiId();
        $userId = $user->getId( $wikiId );
        $count = $this->dbProvider->getReplicaDatabase( $wikiId )->newSelectQueryBuilder()
            ->select( 'user_editcount' )
            ->from( 'user' )
            ->where( [ 'user_id' => $userId ] )
            ->caller( __METHOD__ )->fetchField();
 
        if ( $count === null ) {
            // it has not been initialized. do so.
            $count = $this->initializeUserEditCount( $user );
        }
 
        $this->userEditCountCache[ $cacheKey ] = $count;
        return $count;
    }
 
    public function preloadUserEditCountCache( array $users ): void {
        $userIds = [];
 
        foreach ( $users as $user ) {
            if (
                $user->isRegistered() &&
                $user->getWikiId() === UserIdentity::LOCAL
            ) {
                $userIds[] = $user->getId();
            }
        }
 
        $userIds = array_unique( $userIds );
 
        $dbr = $this->dbProvider->getReplicaDatabase();
 
        foreach ( array_chunk( $userIds, 500 ) as $batch ) {
            $rows = $dbr->newSelectQueryBuilder()
                ->select( [ 'user_id', 'user_editcount' ] )
                ->from( 'user' )
                ->where( [ 'user_id' => $batch ] )
                ->caller( __METHOD__ )
                ->fetchResultSet();
 
            foreach ( $rows as $row ) {
                if ( $row->user_editcount !== null ) {
                    $key = $this->getCacheKeyByUserId( self::CACHE_EDIT_COUNT, (int)$row->user_id );
 
                    $this->userEditCountCache[$key] = (int)$row->user_editcount;
                }
            }
        }
    }
 
    public function initializeUserEditCount( UserIdentity $user ): int {
        if ( $user->getWikiId() !== UserIdentity::LOCAL ) {
            // Don't record edits on remote wikis
            throw new LogicException( __METHOD__ . ' only supports local users' );
        }
 
        $actorStore = $this->actorStoreFactory->getActorStore( $user->getWikiId() );
        $dbr = $this->dbProvider->getReplicaDatabase();
        $count = (int)$dbr->newSelectQueryBuilder()
            ->select( 'COUNT(*)' )
            ->from( 'revision' )
            ->where( [ 'rev_actor' => $actorStore->findActorId( $user, $dbr ) ] )
            ->caller( __METHOD__ )
            ->fetchField();
 
        // Defer updating the edit count via a job (T259719)
        $this->jobQueueGroup->push( new UserEditCountInitJob( [
            'userId' => $user->getId(),
            'editCount' => $count,
        ] ) );
 
        return $count;
    }
 
    public function incrementUserEditCount( UserIdentity $user ) {
        if ( !$user->isRegistered() ) {
            // Can't store editcount without user row (i.e. unregistered)
            return;
        }
 
        DeferredUpdates::addUpdate(
            new UserEditCountUpdate( $user, 1 ),
            DeferredUpdates::POSTSEND
        );
    }
 
    public function getFirstEditTimestamp(
        UserIdentity $user,
        int $flags = IDBAccessObject::READ_NORMAL
    ): string|false {
        if ( !$user->isRegistered() ) {
            // User is unregistered, quick to determine, no need to cache
            return false;
        }
        if ( $flags !== IDBAccessObject::READ_NORMAL ) {
            return $this->getUserEditTimestamp( $user, self::FIRST_EDIT, $flags );
        }
 
        // For users with edits, the first edit timestamp is fairly stable, only deleting their first edit can
        // alter it, so we can cache it for a long time.
        $timestamp = $this->wanObjectCache->getWithSetCallback(
            $this->getCacheKey( self::CACHE_FIRST_EDIT, $user ),
            WANObjectCache::TTL_MONTH,
            function () use ( $user ) {
                $timestamp = $this->getUserEditTimestamp( $user, self::FIRST_EDIT );
                if ( $timestamp === false ) {
                    $timestamp = 0;
                }
                return $timestamp;
            },
            [
                'lockTSE' => 30,
                'staleTTL' => WANObjectCache::TTL_DAY,
                // First edit timestamp is very stable; reduce popularity-based preemptive refresh rate
                // After the initial hour passes (newAge), the timestamp will be refreshed on average every
                // 10k requests (i.e. once every 6 hours if requests come at 1 req/sec)
                'newAge' => 3600,
                'hotTTR' => 21600,
            ]
        );
        if ( $timestamp === 0 ) {
            return false;
        }
        return $timestamp;
    }
 
    public function getLatestEditTimestamp( UserIdentity $user, int $flags = IDBAccessObject::READ_NORMAL ) {
        return $this->getUserEditTimestamp( $user, self::LATEST_EDIT, $flags );
    }
 
    private function getUserEditTimestamp( UserIdentity $user, int $type, int $flags = IDBAccessObject::READ_NORMAL ) {
        if ( !$user->isRegistered() ) {
            return false;
        }
        if ( $flags & IDBAccessObject::READ_LATEST ) {
            $db = $this->dbProvider->getPrimaryDatabase( $user->getWikiId() );
        } else {
            $db = $this->dbProvider->getReplicaDatabase( $user->getWikiId() );
        }
 
        $actorStore = $this->actorStoreFactory->getActorStore( $user->getWikiId() );
        $sortOrder = ( $type === self::FIRST_EDIT ) ? SelectQueryBuilder::SORT_ASC : SelectQueryBuilder::SORT_DESC;
        $time = $db->newSelectQueryBuilder()
            ->select( 'rev_timestamp' )
            ->from( 'revision' )
            ->where( [ 'rev_actor' => $actorStore->findActorId( $user, $db ) ] )
            ->orderBy( 'rev_timestamp', $sortOrder )
            ->caller( __METHOD__ )
            ->fetchField();
 
        if ( !$time ) {
            return false; // no edits
        }
 
        return ConvertibleTimestamp::convert( TS::MW, $time );
    }
 
    public function clearUserEditCache( UserIdentity $user ) {
        if ( !$user->isRegistered() ) {
            return;
        }
 
        $cacheKey = $this->getCacheKey( self::CACHE_EDIT_COUNT, $user );
        unset( $this->userEditCountCache[ $cacheKey ] );
    }
 
    public function setCachedUserEditCount( UserIdentity $user, int $editCount ) {
        if ( !$user->isRegistered() ) {
            throw new InvalidArgumentException( __METHOD__ . ' with an anonymous user' );
        }
 
        $cacheKey = $this->getCacheKey( self::CACHE_EDIT_COUNT, $user );
        $this->userEditCountCache[ $cacheKey ] = $editCount;
    }
 
    public function invalidateCachedFirstEditTimestamps( array $users ): void {
        foreach ( $users as [ $user, $timestamp ] ) {
            if ( !$user->isRegistered() ) {
                continue;
            }
 
            if ( $timestamp === false ) {
                // We cache "no first edit" as 0, because false means "don't cache"
                $timestamp = 0;
            }
 
            $key = $this->getCacheKey( self::CACHE_FIRST_EDIT, $user );
            $cachedTimestamp = $this->wanObjectCache->get( $key );
 
            if ( $timestamp === $cachedTimestamp ) {
                $this->wanObjectCache->delete( $key );
            }
        }
    }
 
    private function getCacheKey( string $keygroup, UserIdentity $user ): string {
        if ( !$user->isRegistered() ) {
            throw new InvalidArgumentException( 'Cannot prepare cache key for an anonymous user' );
        }
 
        $wikiId = $user->getWikiId();
 
        return $this->getCacheKeyByUserId( $keygroup, $user->getId( $wikiId ), $wikiId );
    }
 
    private function getCacheKeyByUserId(
        string $keygroup,
        int $userId,
        string|bool $wikiId = WikiAwareEntity::LOCAL
    ): string {
        if ( $wikiId === WikiAwareEntity::LOCAL ) {
            $wikiId = WikiMap::getCurrentWikiId();
        }
        return $this->wanObjectCache->makeKey( $keygroup, $userId, $wikiId );
    }
}