Memcache

Complexity

Total Complexity

20

Size/Duplication

Total Lines	182
Duplicated Lines	43.41 %

Importance

Changes	1
Bugs	1	Features	1

5 Methods

Rating	Name	Duplication	Size	Complexity
B	connect()	2	26	3
D	get_stats()	28	32	8
B	poll()	25	25	5
A	__init__()	22	22	1
A	disconnect()	0	10	3

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

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

import sys

PY3 = sys.version_info > (3,)

import time
import socket

import plumd
import plumd.plugins
from plumd.calc import Differential


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

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

import re
import os
import sys

PY3 = sys.version_info > (3,)

import plumd
import plumd.plugins
from plumd.util import get_file_list


class Memcache(plumd.plugins.Reader):
    """Plugin to record memcache stats."""

    STAT_CMD = "stats\n"
    RECV_SIZE = 4096

    # default config values
    defaults = {
        'poll.interval': 10,
        'gauges': [
            "auth_cmds",
            "auth_errors",
            "bytes",
            "bytes_read",
            "bytes_written",
            "cas_badval",
            "cas_hits",
            "cas_misses",
            "cmd_flush",
            "cmd_get",
            "cmd_set",
            "cmd_touch",
            "connection_structures",
            "conn_yields",
            "curr_connections",
            "curr_items",
            "decr_hits",
            "decr_misses",
            "delete_hits",
            "delete_misses",
            "evicted_unfetched",
            "evictions",
            "expired_unfetched",
            "get_hits",
            "get_misses",
            "hash_bytes",
            "hash_is_expanding",
            "hash_power_level",
            "incr_hits",
            "incr_misses",
            "limit_maxbytes",
            "listen_disabled_num",
            "reclaimed",
            "reserved_fds",
            "rusage_system",
            "rusage_user",
            "threads",
            "total_connections",
            "total_items",
            "touch_hits",
            "touch_misses",
            "uptime"
        ],
        'rates': [],
        'host': '127.0.0.1', # memcache server hostname/ip
        'port': 11211,       # memcache server port
        'timeout': 10        # connection timeouts
    }

    def __init__(self, log, config):

This code seems to be duplicated in your project.

        """Plugin to record memcache stats.

        :param log: A logger
        :type log: logging.RootLogger
        :param config: a plumd.config.Conf configuration helper instance.
        :type config: plumd.config.Conf
        """
        super(Memcache, self).__init__(log, config)
        self.config.defaults(Memcache.defaults)

        # metrics to record
        self.gauges = self.config.get('gauges')
        self.rates = self.config.get('rates')

        # memcached connection
        host = self.config.get('host')
        port = self.config.get('port')
        self.addr = (host, port)
        self.socket = None
        self.timeout = config.get('timeout')
        self.calc = Differential()


    def poll(self):

This code seems to be duplicated in your project.

        """Query memcache for stats.

        :rtype: ResultSet
        """
        result = plumd.Result("memcache")

        name = self.name
        stats = self.get_stats()
        ts = time.time()

        # record gauges
        for stat in self.gauges:
            if stat in stats:
                mname = "{0}.{1}".format(name, stat)
                result.add(plumd.Float(mname, stats[stat]))

        # record rates
        for stat in self.rates:
            if stat in stats:
                mname = "{0}.{1}".format(name, stat)
                mval = self.calc.per_second(mname, float(stats[stat]), ts)
                result.add(plumd.Float(mname, mval))

        return plumd.ResultSet([result])


    def get_stats(self):
        """Request and read stats from memcache socket."""
        stats = {}

        if not self.socket and not self.connect():

This code seems to be duplicated in your project.

            return {}

        try:
            if PY3:
                self.socket.sendall(bytes(Memcache.STAT_CMD, 'utf8'))
            else:
                self.socket.sendall(Memcache.STAT_CMD)

            st_str = self.socket.recv(Memcache.RECV_SIZE)
            self.log.debug("Memcached: read: {0}".format(st_str))

            for line in st_str.split("\n"):
                vals = line.split()
                if len(vals) != 3:
                    continue
                stype, sname, sval = vals
                if stype == "STAT":
                    msg = "Memcached: {0} = {1}"
                    self.log.debug(msg.format(sname, sval))
                    stats[sname] = sval

        except Exception as e:
            msg = "Memcached: {0}: poll: exception: {1}"
            self.log.error(msg.format(self.addr, e))
            self.disconnect()

        return stats


    def connect(self):
        """Connect to memcached, returns True if sucessful, False otherwise.

        :rtype: bool
        """
        self.log.debug("Memcached: connecting: {0}".format(self.addr))
        if self.socket:
            self.disconnect()
        try:
            # create the socket
            self.socket = socket.socket(socket.AF_INET,
                                        socket.SOCK_STREAM)
            # set timeout for socket operations
            self.socket.settimeout(self.timeout)
            # connect
            self.socket.connect(self.addr)
            # log and return
            msg = "Memcached: connected: {0}"
            self.log.info(msg.format(self.addr))
            return True
        except Exception as e:
            # log exception, ensure cleanup is done (disconnect)
            msg = "Memcached: {0}: connect: excception: {1}"
            self.log.error(msg.format(self.addr, e))
            return False
        return False


    def disconnect(self):
        """Severe the memcached connection."""
        if self.socket:
            try:
                self.socket.close()
                self.socket = None
            except Exception as e:
                msg = "Memcached: dicsonnect: exception {0}".format(e)
                self.log.error(msg)
                self.socket = None