SockStat

Complexity

Total Complexity

7

Size/Duplication

Total Lines	71
Duplicated Lines	25.35 %

Importance

Changes	3
Bugs	0	Features	1

3 Methods

Rating	Name	Duplication	Size	Complexity
A	poll()	0	6	1
B	check()	0	37	5
A	__init__()	16	18	1

# -*- coding: utf-8 -*-
"""Socket stat reader for /proc on Linux."""

import time

The import time seems to be unused.

from collections import deque

import plumd
from plumd.util import Differential
from plumd.util import get_file_map_list, get_file, Filter

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


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

    defaults = {
        'poll.interval': 10,
        'proc_path': '/proc'
    }

    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(SockStat, self).__init__(log, config)
        self.config.defaults(SockStat.defaults)
        self.calc = Differential()
        proc_path = config.get('proc_path')
        self.proc_file = "{0}/net/sockstat".format(proc_path)
        # sys/net/ipv4/tcp_mem format: min, pressure, max
        self.fname_limits = "{0}/sys/net/ipv4/tcp_mem".format(proc_path)
        # orphan limit: /proc/sys/net/ipv4/tcp_max_orphans
        self.fname_orph = "{0}/sys/net/ipv4/tcp_max_orphans".format(proc_path)
        self.filter = Filter()

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

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

    def check(self):
        """Return network socket metrics from proc file net/sockstat.

        Note: sockstat.TCP.mem is measured in pages, you can get the system page
        size from os.sysconf("SC_PAGESIZE")

        Note: FRAG: ip fragmentation

        :rtype: plumd.Result
        """
        result = plumd.Result("sockstat")

        # read and process - dat is a list of lines from fname
        dat = get_file_map_list(self.proc_file, 0, 0)

        # each entry is a key: [metric, val, metric, val]
        for key, val in dat.items():
            mstr = key[:-1]
            mnames = val[::2]
            # 1::2 - every second item
            mvals = deque([int(i) for i in val[1::2]])
            for mname in mnames:
                metric = "{0}.{1}".format(mstr, mname)
                result.add(plumd.Int(metric, mvals.popleft()))

        # also record configured tcp mem limits
        dat = get_file(self.fname_limits).split()
        if len(dat) == 3:
            # eg. for alerting/dashboard on pages allocated vs max values
            result.add(plumd.Int("TCP.mem_min", dat[0]))
            result.add(plumd.Int("TCP.mem_pressure", dat[1]))
            result.add(plumd.Int("TCP.mem_max", dat[1]))

        # and max orphans
        dat = get_file(self.fname_orph)
        result.add(plumd.Int("TCP.orphan_max", dat))
        return [result]