WRStatsReader.php

Go to the documentation of this file.

<?php
 
namespace Wikimedia\WRStats;
 
class WRStatsReader {
    private $store;
    private $metricSpecs;
    private $prefixComponents;
    private $now;
    private $queuedKeys = [];
    private $cachedValues = [];
 
    public function __construct( StatsStore $store, $specs, $prefix ) {
        $this->store = $store;
        $this->metricSpecs = [];
        foreach ( $specs as $name => $spec ) {
            $this->metricSpecs[$name] = new MetricSpec( $spec );
        }
        $this->prefixComponents = is_array( $prefix ) ? $prefix : [ $prefix ];
        if ( !count( $this->prefixComponents ) ) {
            throw new WRStatsError( __METHOD__ .
                ': there must be at least one prefix component' );
        }
    }
 
    public function latest( $numSeconds ) {
        $now = $this->now();
        return new TimeRange( $now - $numSeconds, $now );
    }
 
    public function timeRange( $start, $end ) {
        return new TimeRange( $start, $end );
    }
 
    public function getRate( $metricName, ?EntityKey $entity, TimeRange $range ) {
        $metricSpec = $this->metricSpecs[$metricName] ?? null;
        if ( $metricSpec === null ) {
            throw new WRStatsError( "Unrecognised metric \"$metricName\"" );
        }
        $entity ??= new LocalEntityKey;
        $now = $this->now();
        $seqSpec = null;
        foreach ( $metricSpec->sequences as $seqSpec ) {
            $seqStart = $now - $seqSpec->softExpiry;
            if ( $seqStart <= $range->start ) {
                break;
            }
        }
 
        if ( !$seqSpec ) {
            // This check exists to make Phan happy.
            // It should never fail since we apply normalization in MetricSpec::__construct()
            throw new WRStatsError( 'There should have been at least one sequence' );
        }
 
        $timeStep = $seqSpec->timeStep;
        $firstBucket = (int)( $range->start / $timeStep );
        $lastBucket = (int)ceil( $range->end / $timeStep );
        for ( $bucket = $firstBucket; $bucket <= $lastBucket; $bucket++ ) {
            $key = $this->store->makeKey(
                $this->prefixComponents,
                [ $metricName, $seqSpec->name, $bucket ],
                $entity
            );
            if ( !isset( $this->cachedValues[$key] ) ) {
                $this->queuedKeys[$key] = true;
            }
        }
        return new RatePromise( $this, $metricName, $entity, $metricSpec, $seqSpec, $range );
    }
 
    public function getRates( $metricNames, ?EntityKey $entity, TimeRange $range ) {
        $rates = [];
        foreach ( $metricNames as $name ) {
            $rates[$name] = $this->getRate( $name, $entity, $range );
        }
        return $rates;
    }
 
    public function fetch() {
        if ( !$this->queuedKeys ) {
            return;
        }
        $this->cachedValues += $this->store->query( array_keys( $this->queuedKeys ) );
        $this->queuedKeys = [];
    }
 
    public function setCurrentTime( $now ) {
        $this->now = $now;
    }
 
    public function resetCurrentTime() {
        $this->now = null;
    }
 
    private function now() {
        $this->now ??= microtime( true );
        return $this->now;
    }
 
    public function internalGetCount(
        $metricName,
        EntityKey $entity,
        MetricSpec $metricSpec,
        SequenceSpec $seqSpec,
        TimeRange $range
    ) {
        $this->fetch();
        $timeStep = $seqSpec->timeStep;
        $firstBucket = (int)( $range->start / $timeStep );
        $lastBucket = (int)( $range->end / $timeStep );
        $now = $this->now();
        $total = 0;
        for ( $bucket = $firstBucket; $bucket <= $lastBucket; $bucket++ ) {
            $key = $this->store->makeKey(
                $this->prefixComponents,
                [ $metricName, $seqSpec->name, $bucket ],
                $entity
            );
            $value = $this->cachedValues[$key] ?? 0;
            if ( !$value ) {
                continue;
            } elseif ( $bucket === $firstBucket ) {
                if ( $bucket === $lastBucket ) {
                    // It can be assumed that there are zero events in the future
                    $bucketStartTime = $bucket * $timeStep;
                    $rateInterpolationEndTime = min( $bucketStartTime + $timeStep, $now );
                    $interpolationDuration = $rateInterpolationEndTime - $bucketStartTime;
                    if ( $interpolationDuration > 0 ) {
                        $total += $value * $range->getDuration() / $interpolationDuration;
                    }
                } else {
                    $overlapDuration = max( ( $bucket + 1 ) * $timeStep - $range->start, 0 );
                    $total += $value * $overlapDuration / $timeStep;
                }
            } elseif ( $bucket === $lastBucket ) {
                // It can be assumed that there are zero events in the future
                $bucketStartTime = $bucket * $timeStep;
                $rateInterpolationEndTime = min( $bucketStartTime + $timeStep, $now );
                $overlapDuration = max( $range->end - $bucketStartTime, 0 );
                $interpolationDuration = $rateInterpolationEndTime - $bucketStartTime;
                if ( $overlapDuration === $interpolationDuration ) {
                    // Special case for 0/0 -- current time exactly on boundary.
                    $total += $value;
                } elseif ( $interpolationDuration > 0 ) {
                    $total += $value * $overlapDuration / $interpolationDuration;
                }
            } else {
                $total += $value;
            }
        }
        // Round to nearest resolution step for nicer display
        $rounded = round( $total ) * $metricSpec->resolution;
        // Convert to integer if integer is expected
        if ( is_int( $metricSpec->resolution ) ) {
            $rounded = (int)$rounded;
        }
        return $rounded;
    }
 
    public function total( $rates ) {
        $result = [];
        foreach ( $rates as $key => $rate ) {
            $result[$key] = $rate->total();
        }
        return $result;
    }
 
    public function perSecond( $rates ) {
        $result = [];
        foreach ( $rates as $key => $rate ) {
            $result[$key] = $rate->perSecond();
        }
        return $result;
    }
 
    public function perMinute( $rates ) {
        $result = [];
        foreach ( $rates as $key => $rate ) {
            $result[$key] = $rate->perMinute();
        }
        return $result;
    }
 
    public function perHour( $rates ) {
        $result = [];
        foreach ( $rates as $key => $rate ) {
            $result[$key] = $rate->perHour();
        }
        return $result;
    }
 
    public function perDay( $rates ) {
        $result = [];
        foreach ( $rates as $key => $rate ) {
            $result[$key] = $rate->perDay();
        }
        return $result;
    }
}