Petrica\StatsdSystem\Gauge\ProcessesGauge

Complexity

Total Complexity

14

Size/Duplication

Total Lines	141
Duplicated Lines	21.28 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

91.84%

Importance

Changes	1
Bugs	0	Features	1

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	getSamplingPeriod()	0	4	1
A	getCollection()	0	22	3
A	getProcesses()	0	9	1
A	filterAbove()	0	6	1
A	aggregateCpu()	15	15	3
A	aggregateMemory()	15	15	3
A	getCommand()	0	4	1

<?php
/**
 * Created by PhpStorm.
 * User: Petrica
 * Date: 5/28/2016
 * Time: 23:53
 */
namespace Petrica\StatsdSystem\Gauge;

use Petrica\StatsdSystem\Collection\ValuesCollection;
use Petrica\StatsdSystem\Model\Process\Process;
use Petrica\StatsdSystem\Model\Process\TopProcessParser;
use Petrica\StatsdSystem\Model\TopCommand;

class ProcessesGauge implements GaugeInterface
{
    protected $cpuAbove;

    protected $memoryAbove;

    /**
     * @var TopCommand
     */
    protected $command;

    /**
     * ProcessesGauge constructor.
     *
     * Track CPU and memory of processes
     *
     * @param float $cpuAbove
     * @param float $memoryAbove
     */
    public function __construct($cpuAbove = 5.0, $memoryAbove = 1.0)
    {
        $this->cpuAbove = $cpuAbove;
        $this->memoryAbove = $memoryAbove;

        $this->command = new TopCommand();
    }

    /**
     * {@inheritdoc}
     */
    public function getSamplingPeriod()
    {
        return 10;
    }

    /**
     * {@inheritdoc}
     */
    public function getCollection()
    {
        $processes = $this->getProcesses();

        $cpu = $this->aggregateCpu($processes);
        $cpu = $this->filterAbove($cpu, $this->cpuAbove);

        $memory = $this->aggregateMemory($processes);
        $memory = $this->filterAbove($memory, $this->memoryAbove);

        $collection = new ValuesCollection();

        foreach ($cpu as $name => $value) {
            $collection->add($name . '.cpu.value', $value);
        }

        foreach ($memory as $name => $value) {
            $collection->add($name . '.memory.value', $value);
        }

        return $collection;
    }

    /**
     * Return parsed data for processes
     */
    protected function getProcesses()
    {
        $data = $this->getCommand()->run();

        $parser = new TopProcessParser($data);
        $parser->parse();

        return $parser->getProcesses();
    }

    /**
     * Return only those processes above certail value
     *
     * @param $processes Process[]
     * @return array
     */
    protected function filterAbove($processes, $gate)
    {
        return array_filter($processes, function ($item) use ($gate) {
            return $item >= $gate;
        });
    }

    /**
     * Aggregate CPU for processes with the same name
     *
     * @param $processes Process[]
     */
    protected function aggregateCpu($processes)

This method seems to be duplicated in your project.

    {
        $cpus = array();

        foreach ($processes as $process) {
            if (isset($cpus[$process->getName()])) {
                $cpus[$process->getName()] += $process->getCpu();
            }
            else {
                $cpus[$process->getName()] = $process->getCpu();
            }
        }

        return $cpus;
    }

    /**
     * Aggregate memory for processes with the same name
     *
     * @param $processes Process[]
     * @return array
     */
    protected function aggregateMemory($processes)

This method seems to be duplicated in your project.

    {
        $memory = array();

        foreach ($processes as $process) {
            if (isset($memory[$process->getName()])) {
                $memory[$process->getName()] += $process->getMemory();
            }
            else {
                $memory[$process->getName()] = $process->getMemory();
            }
        }

        return $memory;
    }

    /**
     * Return command object for top utility
     *
     * @return TopCommand
     */
    protected function getCommand()
    {
        return $this->command;
    }

}