Stat

Complexity

Total Complexity

16

Size/Duplication

Total Lines	103
Duplicated Lines	40.78 %

Importance

Changes	1
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
B	check()	0	25	6
A	proc_stat_cpu_percent()	20	20	4
A	poll()	0	6	1
B	proc_stat_cpu()	22	22	4

# -*- coding: utf-8 -*-

__author__ = 'Kenny Freeman'
__email__ = 'kenny.freeman@gmail.com'
__license__ = "ISCL"
__docformat__ = 'reStructuredText'

import time
from collections import deque

import plumd
import plumd.plugins
from plumd.calc import Differential
from plumd.util import get_file_map


## todo: switch from list with pop(0) to deque
class Stat(plumd.plugins.Reader):
    """Class to read metrics from /proc/stat"""
    defaults = {
        'cpu_metrics': ["user", "nice", "system", "idle", "iowait", "irq",
                        "softirq","steal", "guest", "guest_nice"],
        'per_cpu': False,
    }

    def __init__(self, log, config):
        """Plugin to measure various kernel metrics from /proc/stat

        :param log: A logger
        :type log: logging.RootLogger
        :param config: a plumd.config.Conf configuration helper instance.
        :type config: plumd.config.Conf
        """
        super(Stat, self).__init__(log, config)
        config.defaults(Stat.defaults)
        self.calc = Differential()
        self.proc_file = "{0}/stat".format(config.get('proc_path'))
        self.per_cpu = config.get('per_cpu')
        self.cpu_metrics = config.get('cpu_metrics')


    def poll(self):
        """Return cpu utilization and process metrics from proc file stat.

        :rtype: plumd.ResultSet
        """
        return plumd.ResultSet(self.check())


    def check(self):
        """Return cpu utilization and process metrics from proc file stat.

        :rtype: collections.deque
        """
        per_cpu = self.per_cpu
        results = deque()
        result = plumd.Result("stat")
        dat = get_file_map(self.proc_file, 0, 0)
        ts = time.time()
        # parse
        for key, val in dat.items():
            # cpu and btime are the only special metrics
            if key == "btime":
                result.add(plumd.Int(key, val[0]))
            elif key == "cpu":
                results.append(self.proc_stat_cpu_percent(key, val, ts))
            elif per_cpu and key.startswith("cpu"):
                results.append(self.proc_stat_cpu_percent(key, val, ts))
            else:
                # val will be a list, take the first item from it
                mval = self.calc.per_second(key, float(val[0]), ts)
                result.add(plumd.Int(key, mval))
        results.append(result)
        return results


    def proc_stat_cpu_percent(self, key, val, ts):

This code seems to be duplicated in your project.

        """Return cpu utilization metrics in percentage.

        :param key: The metric name (eg. cpu, cpu0, cpu1, etc)
        :type key: str
        :param val: A deque populated with the metric values from stat
        :type val: deque
        :rtype: list
        """
        result = plumd.Result("cpu")
        total = sum([ float(i) for i in val])
        cpu = self.config.get('cpu_metrics')
        for map_val in cpu:
            if len(val) < 1:
                break
            metric_val = float(val.popleft())
            mstr = "{0}_{1}".format(key, map_val)
            percent_val = metric_val / total * 100.00
            result.add(plumd.Float(mstr, percent_val))
        return result


    def proc_stat_cpu(self, key, val, ts):

This code seems to be duplicated in your project.

        """Return cpu utilization metrics in USER_HZ or Jiffies
        (most likely units of 100Hz intervals ie. 100ms intervals).

        :param key: The metric name (eg. cpu, cpu0, cpu1, etc)
        :type key: str
        :param val: A deque populated with the metric values from stat
        :type val: deque
        :rtype: list
        """
        result = plumd.Result("cpus")
        total = sum([ float(i) for i in val])
        cpu = self.config.get('cpu_metrics')
        for map_val in cpu:
            if len(val) < 1:
                break
            metric_val = float(val.popleft())
            mstr = "{0}_{1}".format(key, map_val)
            percent_val = float(metric_val / total) * 100.00
            mval = self.calc.per_second(key, percent_val, ts)
            result.add(plumd.Float(mstr, mval))
        return result