DiskStats

Complexity

Total Complexity

10

Size/Duplication

Total Lines	74
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
B	__init__()	0	29	4
A	poll()	0	6	1
B	check()	0	23	5

# -*- coding: utf-8 -*-
"""Disk io stats reader from /proc on Linux."""
import re
import time

import plumd
from plumd.util import Differential
from plumd.util import get_file_map, get_file

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


class DiskStats(plumd.Reader):
    """Plugin to measure various kernel metrics from /proc."""

    proc_colums = 14

    defaults = {
        'poll.interval': 10,
        'proc_path': '/proc',
        'diskstats_dev_re': "dm-\d",

A suspicious escape sequence \d was found. Did you maybe forget to add an r prefix?

        'diskstats_cols': ["r", "r_merge", "r_sector", "r_time", "w", "w_merge",
                           "w_sector", "w_time", "io_inprog", "io_time",
                           "io_weighted_time"]
    }

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

        :param log: A logger
        :type log: logging.RootLogger
        :param config: a plumd.config.Conf configuration helper instance.
        :type config: plumd.config.Conf
        """
        super(DiskStats, self).__init__(log, config)
        config.defaults(DiskStats.defaults)
        self.calc = Differential()
        self.proc_file = "{0}/diskstats".format(config.get('proc_path'))
        self.diskstats_dev_re = re.compile(config.get('diskstats_dev_re'))
        self.diskstats_cols = self.config.get('diskstats_cols')
        self.devices = []  # list of device names to record metrics for
        self.enabled = True
        # get list of available devices:
        dat = get_file_map(self.proc_file, 2, 0)
        # key is the device name, exclude ones matching the re
        for key in dat.keys():
            if not self.diskstats_dev_re.match(key):
                self.devices.append(key)
        # check format of proc file
        ncols = len(get_file(self.proc_file).split("\n")[0].split())
        self.enabled = ncols == DiskStats.proc_colums
        if not self.enabled:
            msg = "DiskStats: invalid format: {0} has {1} cols, not {2}"
            self.log.error(msg.format(self.proc_file, ncols,
                                      DiskStats.proc_colums))

    def poll(self):
        """Poll for kernel metrics under /proc.

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

    def check(self):
        """Return disk io metrics from proc file diskstats.

        :rtype: plumd.Result
        """
        # times in ms
        cols = self.diskstats_cols
        result = plumd.Result("diskstats")
        if not self.enabled:
            return [result]
        dat = {}
        # read and process /proc/diskstats
        dat = get_file_map(self.proc_file, 2, 0)
        times = time.time()
        for dev in self.devices:
            if dev not in dat:
                continue
            for mname in cols:
                mval = float(dat[dev].popleft())
                mstr = "{0}.{1}".format(dev, mname)
                dval = self.calc.per_second(mstr, mval, times)
                result.add(plumd.Float(mstr, dval))
        return [result]