StorageManager::collect() - Code Metrics - Inspection of "Teach the TextRenderer to handle empty labels" - krenor/prometheus-client - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( 28a887...d46380 )

by Stan

created 2018-06-01 15:07 UTC

StorageManager::collect() B

↳ Parent: StorageManager

Complexity

Conditions	4
Paths	7

Size

Total Lines	23
Code Lines	17

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	14
CRAP Score	4

Importance

Changes

Metric	Value
cc	4
eloc	17
nc	7
nop	1
dl	0
loc	23
ccs	14
cts	14
cp	1
crap	4
rs	8.7972
c	0
b	0
f	0

<?php

namespace Krenor\Prometheus\Storage;

use Exception;
use Krenor\Prometheus\Metrics\Summary;
use Krenor\Prometheus\Contracts\Metric;
use Krenor\Prometheus\Contracts\Storage;
use Krenor\Prometheus\Metrics\Histogram;
use Tightenco\Collect\Support\Collection;
use Krenor\Prometheus\Contracts\Repository;
use Krenor\Prometheus\Contracts\Types\Settable;
use Krenor\Prometheus\Exceptions\LabelException;
use Krenor\Prometheus\Contracts\Types\Observable;
use Krenor\Prometheus\Exceptions\StorageException;
use Krenor\Prometheus\Contracts\Types\Decrementable;
use Krenor\Prometheus\Contracts\Types\Incrementable;
use Krenor\Prometheus\Storage\Concerns\StoresMetrics;

class StorageManager implements Storage
{
    use StoresMetrics;

    /**
     * @var Repository
     */
    protected $repository;

    /**
     * @var string
     */
    protected $prefix;

    /**
     * StorageManager constructor.
     *
     * @param Repository $repository
     * @param string|null $prefix
     */
    public function __construct(Repository $repository, ?string $prefix = 'PROMETHEUS')
    {
        $this->repository = $repository;
        $this->prefix = $prefix;
    }

    /**
     * {@inheritdoc}
     */
    public function collect(Metric $metric): Collection
    {
        $key = "{$this->prefix}:{$metric->key()}";

        try {
            $items = $this->repository->get($key);

            switch (true) {
                case $metric instanceof Histogram:
                    return $metric->builder($items->merge($this->repository->get("{$key}:SUM")))
                                  ->samples();
                case $metric instanceof Summary:
                    return $metric->builder($items->map(function (string $key) {
                        return $this->repository->get($key);
                    }))->samples();
                default:
                    return $metric->builder($items)
                                  ->samples();
            }
        } catch (Exception $e) {
            $class = get_class($metric);

            throw new StorageException("Failed to collect the samples of [{$class}]: {$e->getMessage()}", 0, $e);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function increment(Incrementable $metric, float $value, array $labels): void
    {
        try {
            $this->repository->increment(
                "{$this->prefix}:{$metric->key()}",
                "{$this->prefix}:{$metric->/** @scrutinizer ignore-call */ key()}",
                $this->labeled($metric, $labels)->toJson(),
                $value
            );
        } catch (LabelException $e) {
            throw $e;
        } catch (Exception $e) {
            $class = get_class($metric);

            throw new StorageException("Failed to increment [{$class}] by `{$value}`: {$e->getMessage()}", 0, $e);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function decrement(Decrementable $metric, float $value, array $labels): void
    {
        try {
            $this->repository->decrement(
                "{$this->prefix}:{$metric->key()}",
                "{$this->prefix}:{$metric->/** @scrutinizer ignore-call */ key()}",
                $this->labeled($metric, $labels)->toJson(),
                $value
            );
        } catch (LabelException $e) {
            throw $e;
        } catch (Exception $e) {
            $class = get_class($metric);

            throw new StorageException("Failed to decrement [{$class}] by `{$value}`: {$e->getMessage()}", 0, $e);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function observe(Observable $metric, float $value, array $labels): void
    {
        $key = "{$this->prefix}:{$metric->key()}";
        $key = "{$this->prefix}:{$metric->/** @scrutinizer ignore-call */ key()}";
        $labeled = $this->labeled($metric, $labels);
        $field = $labeled->toJson();

        try {
            if ($metric instanceof Histogram) {
                $this->repository->increment($key, $labeled->merge($this->bucket($metric, $value))->toJson(), 1);
                $this->repository->increment("{$key}:SUM", $field, $value);
            }

            if ($metric instanceof Summary) {
                $identifier = "{$key}:" . crc32($field) . ':VALUES';

                $this->repository->set($key, $field, $identifier, false);
                $this->repository->push($identifier, $value);
            }
        } catch (Exception $e) {
            $class = get_class($metric);

            throw new StorageException("Failed to observe [{$class}] with `{$value}`: {$e->getMessage()}", 0, $e);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function set(Settable $metric, float $value, array $labels): void
    {
        try {
            $this->repository->set(
                "{$this->prefix}:{$metric->key()}",
                "{$this->prefix}:{$metric->/** @scrutinizer ignore-call */ key()}",
                $this->labeled($metric, $labels)->toJson(),
                $value
            );
        } catch (LabelException $e) {
            throw $e;
        } catch (Exception $e) {
            $class = get_class($metric);

            throw new StorageException("Failed to set [{$class}] to `{$value}`: {$e->getMessage()}", 0, $e);
        }
    }

    /**
     * @return bool
     */
    public function flush(): bool
    {
        return $this->repository->flush();
    }
}


krenor / prometheus-client

Push — develop ( 28a887...d46380 )

StorageManager::collect() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like