StatsFactory.php

Go to the documentation of this file.

<?php
declare( strict_types=1 );
 
namespace Wikimedia\Stats;
 
use IBufferingStatsdDataFactory;
use InvalidArgumentException;
use Psr\Log\LoggerInterface;
use TypeError;
use Wikimedia\Stats\Emitters\EmitterInterface;
use Wikimedia\Stats\Exceptions\IllegalOperationException;
use Wikimedia\Stats\Exceptions\InvalidConfigurationException;
use Wikimedia\Stats\Metrics\BaseMetric;
use Wikimedia\Stats\Metrics\CounterMetric;
use Wikimedia\Stats\Metrics\GaugeMetric;
use Wikimedia\Stats\Metrics\NullMetric;
use Wikimedia\Stats\Metrics\TimingMetric;
 
class StatsFactory {
 
    private string $component;
 
    private array $staticLabelKeys = [];
 
    private array $staticLabelValues = [];
 
    private StatsCache $cache;
 
    private EmitterInterface $emitter;
 
    private LoggerInterface $logger;
 
    private ?IBufferingStatsdDataFactory $statsdDataFactory = null;
 
    public function __construct(
        string $component,
        StatsCache $cache,
        EmitterInterface $emitter,
        LoggerInterface $logger
    ) {
        $this->component = StatsUtils::normalizeString( $component );
        $this->cache = $cache;
        $this->emitter = $emitter;
        $this->logger = $logger;
        $this->validateInstanceConfig();
    }
 
    private function validateInstanceConfig(): void {
        if ( $this->component == '' ) {
            throw new InvalidArgumentException( 'Stats: component cannot be empty.' );
        }
    }
 
    public function withStaticLabel( string $key, string $value ): StatsFactory {
        if ( count( $this->cache->getAllMetrics() ) > 0 ) {
            throw new IllegalOperationException( 'Stats: cannot set static labels when metrics are in the cache.' );
        }
        $key = StatsUtils::normalizeString( $key );
        StatsUtils::validateLabelKey( $key );
        $this->staticLabelKeys[] = $key;
        $this->staticLabelValues[] = StatsUtils::normalizeString( $value );
        return $this;
    }
 
    public function withStatsdDataFactory( IBufferingStatsdDataFactory $statsdDataFactory ): StatsFactory {
        $this->statsdDataFactory = $statsdDataFactory;
        return $this;
    }
 
    public function getCounter( string $name ) {
        return $this->getMetric( $name, CounterMetric::class );
    }
 
    public function getGauge( string $name ) {
        return $this->getMetric( $name, GaugeMetric::class );
    }
 
    public function getTiming( string $name ) {
        return $this->getMetric( $name, TimingMetric::class );
    }
 
    public function flush(): void {
        $this->emitter->send();
        $this->cache->clear();
    }
 
    private function getMetric( string $name, string $className ) {
        $name = StatsUtils::normalizeString( $name );
        StatsUtils::validateMetricName( $name );
        try {
            $metric = $this->cache->get( $this->component, $name, $className );
        } catch ( TypeError | InvalidArgumentException | InvalidConfigurationException $ex ) {
            // Log the condition and give the caller something that will absorb calls.
            trigger_error( $ex->getMessage(), E_USER_WARNING );
            return new NullMetric;
        }
        if ( $metric === null ) {
            $baseMetric = new BaseMetric( $this->component, $name );
            $metric = new $className(
                $baseMetric
                    ->withStatsdDataFactory( $this->statsdDataFactory )
                    ->withStaticLabels( $this->staticLabelKeys, $this->staticLabelValues ),
                $this->logger
            );
            $this->cache->set( $this->component, $name, $metric );
        }
        return $metric->fresh();
    }
}