VmStat

Complexity

Total Complexity

8

Size/Duplication

Total Lines	90
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	2

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__init__()	0	14	1
B	check()	0	39	6
A	poll()	0	6	1

# -*- 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_list


class VmStat(plumd.plugins.Reader):
    """Plugin to measure various kernel metrics from /proc/vmstat."""
    defaults = {
        'poll.interval': 10,
        'proc_path': '/proc',
        # awk '{ print "\"" $1 "\"," }' /proc/vmstat
        'proc_vmstat_gauges': ["nr_free_pages", "nr_dirtied", "nr_written",
                               "numa_hit", "numa_miss", "numa_foreign",
                               "numa_interleave", "numa_local", "numa_other",
                               "pgpgin", "pgpgout", "pswpin", "pswpout",
                               "pgalloc_dma", "pgalloc_dma32", "pgalloc_normal",
                               "pgalloc_movable", "pgfree", "pgactivate",
                               "pgdeactivate", "pgfault", "pgmajfault",
                               "slabs_scanned", "kswapd_inodesteal",
                               "kswapd_low_wmark_hit_quickly",
                               "kswapd_high_wmark_hit_quickly",
                               "drop_pagecache", "drop_slab",
                               "numa_pte_updates", "numa_huge_pte_updates",
                               "numa_hint_faults", "numa_hint_faults_local",
                               "numa_pages_migrated", "pgmigrate_success",
                               "pgmigrate_fail", "compact_migrate_scanned",
                               "compact_free_scanned", "compact_isolated",
                               "compact_stall", "compact_fail",
                               "compact_success"],
        'proc_vmstat_rates': []
    }

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

        :param log: A logger
        :type log: logging.RootLogger
        :param config: a plumd.config.Conf configuration helper instance.
        :type config: plumd.config.Conf
        """
        super(VmStat, self).__init__(log, config)
        self.config.defaults(VmStat.defaults)
        self.calc = Differential()
        self.proc_file = "{0}/vmstat".format(config.get('proc_path'))
        self.gauges = self.config.get('proc_vmstat_gauges')
        self.rates = self.config.get('proc_vmstat_rates')


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

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


    def check(self):
        """Return metrics from /proc/vmstat.

        :rtype: plumd.Result
        """
        # what metrics do we want to record?
        result = plumd.Result("vmstat")

        # read the proc file
        dat = {}
        with open(self.proc_file, 'r') as f:
            # get a list of values: metric, val, metric, val, etc
            vals = f.read().strip().split()
            # every second item starting at 0, every second item starting at 1
            # take that and put into a dict
            dat = dict(zip(vals[0::2], vals[1::2]))

        # timestamp for Differential calculations
        ts = time.time()

        # now, we have a list of items to record, just need to record them
        for i, metric in enumerate(self.gauges):
            if metric in dat:
                #mval = self.calc.per_second(mstr, int(values[mname]), ts)
                result.add(plumd.Int(metric, dat[metric]))
            else:
                self.log.warn("netstat: unknown metric {0}".format(metric))
                del(self.gauges[i])

        # and the rates as well, if any
        for i, metric in enumerate(self.rates):
            if metric in dat:
                mval = self.calc.per_second(mstr, int(dat[metric]), ts)
                result.add(plumd.Float(metric, mval))
            else:
                self.log.warn("netstat: unknown metric {0}".format(metric))
                del(self.rates[i])

        return [result]