BufferingStatsdDataFactory.php

Go to the documentation of this file.

<?php
namespace Wikimedia\Stats;
 
use Liuggio\StatsdClient\Entity\StatsdData;
use Liuggio\StatsdClient\Entity\StatsdDataInterface;
use Liuggio\StatsdClient\Factory\StatsdDataFactory;
 
class BufferingStatsdDataFactory extends StatsdDataFactory implements IBufferingStatsdDataFactory {
    protected $buffer = [];
    protected $enabled = true;
    private $prefix;
 
    public function __construct( $prefix ) {
        parent::__construct();
        $this->prefix = $prefix;
    }
 
    //
    // Methods for StatsdDataFactoryInterface
    //
 
    public function timing( $key, $time ) {
        if ( !$this->enabled ) {
            return;
        }
        $this->buffer[] = [ $key, $time, StatsdDataInterface::STATSD_METRIC_TIMING ];
    }
 
    public function gauge( $key, $value ) {
        if ( !$this->enabled ) {
            return;
        }
        $this->buffer[] = [ $key, $value, StatsdDataInterface::STATSD_METRIC_GAUGE ];
    }
 
    public function set( $key, $value ) {
        if ( !$this->enabled ) {
            return [];
        }
        $this->buffer[] = [ $key, $value, StatsdDataInterface::STATSD_METRIC_SET ];
        return [];
    }
 
    public function increment( $key ) {
        if ( !$this->enabled ) {
            return [];
        }
        $this->buffer[] = [ $key, 1, StatsdDataInterface::STATSD_METRIC_COUNT ];
        return [];
    }
 
    public function decrement( $key ) {
        if ( !$this->enabled ) {
            return;
        }
        $this->buffer[] = [ $key, -1, StatsdDataInterface::STATSD_METRIC_COUNT ];
    }
 
    public function updateCount( $key, $delta ) {
        if ( !$this->enabled ) {
            return;
        }
        $this->buffer[] = [ $key, $delta, StatsdDataInterface::STATSD_METRIC_COUNT ];
    }
 
    private static function normalizeMetricKey( $key ) {
        $key = strtr( $key, [ '::' => '.' ] );
        $key = preg_replace( '/[^a-zA-Z0-9.]+/', '_', $key );
        $key = trim( $key, '_.' );
        return strtr( $key, [ '..' => '.' ] );
    }
 
    public function produceStatsdData(
        $key, $value = 1, $metric = StatsdDataInterface::STATSD_METRIC_COUNT
    ) {
        $entity = $this->produceStatsdDataEntity();
        if ( $key !== null ) {
            $key = self::normalizeMetricKey( "{$this->prefix}.{$key}" );
            $entity->setKey( $key );
        }
        if ( $value !== null ) {
            $entity->setValue( $value );
        }
        if ( $metric !== null ) {
            $entity->setMetric( $metric );
        }
        return $entity;
    }
 
    //
    // Methods for IBufferingStatsdDataFactory
    //
 
    public function hasData() {
        return (bool)$this->buffer;
    }
 
    public function getData() {
        $data = [];
        foreach ( $this->buffer as [ $key, $val, $metric ] ) {
            // Optimization: Don't bother transmitting a counter update with a delta of zero
            if ( $metric === StatsdDataInterface::STATSD_METRIC_COUNT && !$val ) {
                continue;
            }
 
            // Optimisation: Avoid produceStatsdData cost during web requests (T288702).
            // Instead, we do it here in getData() right before the data is transmitted.
            $data[] = $this->produceStatsdData( $key, $val, $metric );
        }
 
        return $data;
    }
 
    public function clearData() {
        $this->buffer = [];
    }
 
    public function getDataCount() {
        return count( $this->buffer );
    }
 
    public function setEnabled( $enabled ) {
        $this->enabled = $enabled;
    }
}
 
class_alias( BufferingStatsdDataFactory::class, 'BufferingStatsdDataFactory' );