Krenor\Prometheus\CollectorRegistry

Complexity

Total Complexity

19

Size/Duplication

Total Lines	172
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	3
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	collect()	0	6	1
A	counters()	0	3	1
A	histogram()	0	3	1
A	register()	0	10	2
A	gauge()	0	3	1
A	counter()	0	3	1
A	histograms()	0	3	1
A	summaries()	0	3	1
A	collector()	0	13	5
A	summary()	0	3	1
A	collectible()	0	7	1
A	unregister()	0	6	1
A	gauges()	0	3	1

<?php

namespace Krenor\Prometheus;

use InvalidArgumentException;
use Krenor\Prometheus\Metrics\Gauge;
use Krenor\Prometheus\Metrics\Counter;
use Krenor\Prometheus\Metrics\Summary;
use Krenor\Prometheus\Contracts\Metric;
use Krenor\Prometheus\Metrics\Histogram;
use Tightenco\Collect\Support\Collection;

class CollectorRegistry
{
    protected Collection $counters;

    protected Collection $gauges;

    protected Collection $histograms;

    protected Collection $summaries;

    /**
     * CollectorRegistry constructor.
     */
    public function __construct()
    {
        $this->counters = new Collection;
        $this->gauges = new Collection;
        $this->histograms = new Collection;
        $this->summaries = new Collection;
    }

    /**
     * @return Collection|MetricFamilySamples[]
     */
    public function collect(): Collection
    {
        return $this
            ->collectible()
            ->collapse()
            ->map(fn(Metric $metric) => new MetricFamilySamples($metric, $metric::storage()->collect($metric)));
    }

    /**
     * @param Metric $metric
     *
     * @return Metric
     */

    /**
     * @template T
     * @psalm-param T $metric
     *
     * @return T
     */
    public function register(Metric $metric): Metric
    {
        $collector = $this->collector($metric);
        $namespace = $metric::class;

        if (!$collector->contains($namespace)) {
            $collector->put($namespace, $metric);
        }

        return $collector->get($namespace);
    }

    /**
     * @param Metric $metric
     *
     * @return self
     */
    public function unregister(Metric $metric): self
    {
        $this->collector($metric)
             ->forget($metric::class);

        return $this;
    }

    /**
     * @return Collection
     */
    public function counters(): Collection
    {
        return $this->counters;
    }

    /**
     * @return Collection
     */
    public function gauges(): Collection
    {
        return $this->gauges;
    }

    /**
     * @return Collection
     */
    public function histograms(): Collection
    {
        return $this->histograms;
    }

    /**
     * @return Collection
     */
    public function summaries(): Collection
    {
        return $this->summaries;
    }

    /**
     * @param string $namespace
     *
     * @return Counter|null
     */
    public function counter(string $namespace): ?Counter
    {
        return $this->counters->get($namespace);
    }

    /**
     * @param string $namespace
     *
     * @return Gauge|null
     */
    public function gauge(string $namespace): ?Gauge
    {
        return $this->gauges->get($namespace);
    }

    /**
     * @param string $namespace
     *
     * @return Histogram|null
     */
    public function histogram(string $namespace): ?Histogram
    {
        return $this->histograms->get($namespace);
    }

    /**
     * @param string $namespace
     *
     * @return Summary|null
     */
    public function summary(string $namespace): ?Summary
    {
        return $this->summaries->get($namespace);
    }

    /**
     * @param Metric $metric
     *
     * @return Collection
     */
    protected function collector(Metric $metric): Collection
    {
        switch ($metric) {
            case $metric instanceof Counter:
                return $this->counters;
            case $metric instanceof Gauge:
                return $this->gauges;
            case $metric instanceof Histogram:
                return $this->histograms;
            case $metric instanceof Summary:
                return $this->summaries;
            default:
                throw new InvalidArgumentException("Could not determine collector of unknown metric type.");
        }
    }

    /**
     * @return Collection|Collection[]
     */
    protected function collectible(): Collection
    {
        return new Collection([
            $this->counters,
            $this->gauges,
            $this->histograms,
            $this->summaries,
        ]);
    }
}