MetricsFactory.php

Go to the documentation of this file.

<?php
declare( strict_types=1 );
 
namespace Wikimedia\Metrics;
 
use Psr\Log\LoggerInterface;
use TypeError;
use UDPTransport;
use Wikimedia\Metrics\Exceptions\InvalidConfigurationException;
use Wikimedia\Metrics\Exceptions\UndefinedPrefixException;
use Wikimedia\Metrics\Exceptions\UnsupportedFormatException;
 
class MetricsFactory {
 
    private const SUPPORTED_OUTPUT_FORMATS = [ 'statsd', 'dogstatsd', 'null' ];
 
    private const NAME_DELIMITER = '.';
 
    private const DEFAULT_METRIC_CONFIG = [
        // 'name' => required,
        // 'extension' => required,
        'labels' => [],
        'sampleRate' => 1.0,
        'service' => '',
        'format' => 'statsd',
    ];
 
    private $cache = [];
 
    private $target;
 
    private $format;
 
    private $prefix;
 
    private $logger;
 
    public function __construct( array $config, LoggerInterface $logger ) {
        $this->logger = $logger;
        $this->target = $config['target'] ?? null;
        $this->format = $config['format'] ?? 'null';
        $this->prefix = $config['prefix'] ?? '';
        if ( $this->prefix === '' ) {
            throw new UndefinedPrefixException( '\'prefix\' option is required and cannot be empty.' );
        }
        $this->prefix = self::normalizeString( $config['prefix'] );
        if ( !in_array( $this->format, self::SUPPORTED_OUTPUT_FORMATS ) ) {
            throw new UnsupportedFormatException(
                'Format "' . $this->format . '" not supported. Expected one of '
                . json_encode( self::SUPPORTED_OUTPUT_FORMATS )
            );
        }
    }
 
    public function getCounter( array $config = [] ) {
        $config = $this->getValidConfig( $config );
        $name = self::getFormattedName( $config['name'], $config['extension'] );
        try {
            $metric = $this->getCachedMetric( $name, CounterMetric::class );
        } catch ( TypeError $ex ) {
            return new NullMetric();
        }
 
        if ( $metric ) {
            $metric->validateLabels( $config['labels'] );
            return $metric;
        }
        $this->cache[$name] = new CounterMetric( $config, new MetricUtils() );
        return $this->cache[$name];
    }
 
    public function getGauge( array $config = [] ) {
        $config = $this->getValidConfig( $config );
        $name = self::getFormattedName( $config['name'], $config['extension'] );
        try {
            $metric = $this->getCachedMetric( $name, GaugeMetric::class );
        } catch ( TypeError $ex ) {
            return new NullMetric();
        }
 
        if ( $metric ) {
            $metric->validateLabels( $config['labels'] );
            return $metric;
        }
        $this->cache[$name] = new GaugeMetric( $config, new MetricUtils() );
        return $this->cache[$name];
    }
 
    public function getTiming( array $config = [] ) {
        $config = $this->getValidConfig( $config );
        $name = self::getFormattedName( $config['name'], $config['extension'] );
        try {
            $metric = $this->getCachedMetric( $name, TimingMetric::class );
        } catch ( TypeError $ex ) {
            return new NullMetric();
        }
        if ( $metric ) {
            $metric->validateLabels( $config['labels'] );
            return $metric;
        }
        $this->cache[$name] = new TimingMetric( $config, new MetricUtils() );
        return $this->cache[$name];
    }
 
    public function flush(): void {
        if ( $this->format !== 'null' && $this->target ) {
            $this->send( UDPTransport::newFromString( $this->target ) );
        }
        $this->cache = [];
    }
 
    private function getRenderedSamples( array $cache ): array {
        $renderedSamples = [];
        foreach ( $cache as $metric ) {
            foreach ( $metric->render() as $rendered ) {
                $renderedSamples[] = $rendered;
            }
        }
        return $renderedSamples;
    }
 
    private function getCachedMetric( string $name, string $requested_type ) {
        if ( !array_key_exists( $name, $this->cache ) ) {
            return null;
        }
 
        $metric = $this->cache[$name];
        if ( get_class( $metric ) !== $requested_type ) {
            $msg = 'Metric name collision detected: \'' . $name . '\' defined as type \'' . get_class( $metric )
                . '\' but a \'' . $requested_type . '\' was requested.';
            $this->logger->error( $msg );
            throw new TypeError( $msg );
        }
 
        return $metric;
    }
 
    protected function send( UDPTransport $transport ): void {
        $payload = '';
        $renderedSamples = $this->getRenderedSamples( $this->cache );
        foreach ( $renderedSamples as $sample ) {
            if ( strlen( $payload ) + strlen( $sample ) + 1 < UDPTransport::MAX_PAYLOAD_SIZE ) {
                $payload .= $sample . "\n";
            } else {
                // Send this payload and make a new one
                $transport->emit( $payload );
                $payload = '';
            }
        }
        // Send what is left in the payload
        if ( strlen( $payload ) > 0 ) {
            $transport->emit( $payload );
        }
    }
 
    private function getFormattedName( string $name, string $extension ): string {
        return implode(
            self::NAME_DELIMITER,
            [ $this->prefix, $extension, self::normalizeString( $name ) ]
        );
    }
 
    private function getValidConfig( array $config = [] ): array {
        if ( !isset( $config['name'] ) ) {
            throw new InvalidConfigurationException(
                '\'name\' configuration option is required and cannot be empty.'
            );
        }
        if ( !isset( $config['extension'] ) ) {
            throw new InvalidConfigurationException(
                '\'extension\' configuration option is required and cannot be empty.'
            );
        }
 
        $config['prefix'] = $this->prefix;
        $config['format'] = $this->format;
        $config['name'] = self::normalizeString( $config['name'] );
        $config['extension'] = self::normalizeString( $config['extension'] );
        $config['labels'] = self::normalizeArray( $config['labels'] ?? [] );
 
        return $config + self::DEFAULT_METRIC_CONFIG;
    }
 
    public static function normalizeString( string $entity ): string {
        $entity = preg_replace( '/[^a-z0-9]/i', '_', $entity );
        $entity = preg_replace( '/_+/', '_', $entity );
        return trim( $entity, '_' );
    }
 
    public static function normalizeArray( array $entities ): array {
        $normalizedEntities = [];
        foreach ( $entities as $entity ) {
            $normalizedEntities[] = self::normalizeString( $entity );
        }
        return $normalizedEntities;
    }
}