Passed
Push — develop ( 500084...288399 )
by Stan
09:28
created

SummarySamplesBuilder::parse()   A

Complexity

Conditions 2
Paths 1

Size

Total Lines 32
Code Lines 24

Duplication

Lines 0
Ratio 0 %

Code Coverage

Tests 15
CRAP Score 2

Importance

Changes 0
Metric Value
cc 2
eloc 24
c 0
b 0
f 0
nc 1
nop 0
dl 0
loc 32
ccs 15
cts 15
cp 1
crap 2
rs 9.536
1
<?php
2
3
namespace Krenor\Prometheus\Storage\Builders;
4
5
use Closure;
6
use Krenor\Prometheus\Metrics\Summary;
7
use Tightenco\Collect\Support\Collection;
8
use Krenor\Prometheus\Contracts\SamplesBuilder;
9
10
class SummarySamplesBuilder extends SamplesBuilder
11
{
12
    /**
13
     * @var Summary
14
     */
15
    protected $metric;
16
17
    /**
18
     * SummarySamplesBuilder constructor.
19
     *
20
     * @param Summary $summary
21
     * @param Collection $items
22
     */
23
    public function __construct(Summary $summary, Collection $items)
24 8
    {
25
        parent::__construct($summary, $items);
26 8
    }
27 8
28
    /**
29
     * {@inheritdoc}
30
     */
31
    protected function parse(): Collection
32 1
    {
33
        $quantiles = $this->metric->quantiles();
34 1
35
        return parent
36
            ::parse()
37
            ->flatMap(function (array $item) use ($quantiles) {
38
                ['name'   => $name,
39
                 'labels' => $labels] = $item;
40 8
41
                $values = !$item['value'] instanceof Collection
42
                    ? new Collection
43
                    : $item['value'];
44 8
45 8
                $count = $values->count();
46 8
47
                return $quantiles
48 8
                    ->map($this->calculate($values->sort()->values(), $count))
49 8
                    ->map(function (array $item) use ($name, $labels) {
50 8
                        $item['labels'] = $labels + [
51 8
                            'quantile' => $item['quantile']
52 8
                        ];
53
54 8
                        return $item + compact('name');
55
                    })->push([
56 8
                        'name'   => "{$name}_count",
57 8
                        'value'  => $count,
58 8
                        'labels' => $labels,
59
                    ])->push([
60
                        'name'   => "{$name}_sum",
61
                        'value'  => $values->sum(),
62
                        'labels' => $labels,
63
                    ]);
64 8
            });
65
    }
66
67 8
    /**
68
     * @param Collection $values
69 8
     * @param int $count
70 8
     *
71
     * @return Closure
72
     */
73 8
    private function calculate(Collection $values, int $count): Closure
74 8
    {
75
        return function (float $quantile) use ($count, $values) {
76
            $position = $count * $quantile;
77 8
            $index = (int) $position;
78 8
79
            $value = floor($position) === $position
80
                ? ($values->get($index - 1) + $values->get($index)) / 2
81
                : $values->get($index);
82
83
            return compact('quantile', 'value');
84
        };
85
    }
86
}
87