Add more plugins for Server Density

files/sd-plugins/HAProxy.py

+import httplib # Used only for handling httplib.HTTPException (case #26701)
+import logging
+import logging.handlers
+import re
+import urllib
+import urllib2
+import csv
+
+# Build the request headers
+headers = {
+        'User-Agent': 'Server Density Agent',
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'Accept': 'text/html, */*',
+}
+
+class HAProxy:
+    def __init__( self, agentConfig, mainLogger, rawConfig ):
+        self.agentConfig = agentConfig
+        self.mainLogger = mainLogger
+        self.rawConfig = rawConfig
+
+    def myrun( self ):
+
+        if 'haproxy_url' not in self.rawConfig['Main']:
+            self.mainLogger.error("haproxy_url MUST be in the config")
+            return False
+        if 'haproxy_svname' not in self.rawConfig['Main']:
+            self.mainLogger.error("haproxy_svname MUST be in the config")
+            return False
+
+        svname = self.rawConfig['Main']['haproxy_svname']
+
+        if 'haproxy_username' in self.rawConfig['Main'] and self.rawConfig['Main']['haproxy_username'] != '':
+            password_mgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
+            password_mgr.add_password(None, self.rawConfig['Main']['haproxy_url'], self.rawConfig['Main']['haproxy_username'], self.rawConfig['Main']['haproxy_password'])
+            handler = urllib2.HTTPBasicAuthHandler(password_mgr)
+            opener = urllib2.build_opener(handler)
+            urllib2.install_opener(opener)
+            pass
+
+        req = urllib2.Request(self.rawConfig['Main']['haproxy_url'] + ';csv;norefresh', None, headers)
+        request = urllib2.urlopen(req)
+        response = request.read()
+
+        # Parse out the returned CSV data
+        reader = csv.DictReader(p.stdout)
+        output = []
+        for row in reader:
+            output.append(row)
+            pass
+
+        # Now find the row that has our svname
+        scur = 0
+        wredis = 0
+        stot = 0
+        for i in output:
+            if i['svname'] == svname:
+                # Pull out scur, wredis, and stot
+                scur = i['scur']
+                wredis = i['wredis']
+                stot = i['stot']
+
+        return {'scur': scur, 'wredis': wredis, 'stot': stot}
+
+    def run( self ):
+        try:
+            return self.myrun()
+        except urllib2.HTTPError, e:
+            self.mainLogger.error('Unable to get HAProxy status - HTTPError = ' + str(e))
+            return False
+        except urllib2.URLError, e:
+            self.mainLogger.error('Unable to get HAProxy status - URLError = ' + str(e))
+            return False
+        
+        except httplib.HTTPException, e:
+            self.mainLogger.error('Unable to get HAProxy status - HTTPException = ' + str(e))
+            return False
+        
+        except Exception, e:
+            import traceback
+            self.mainLogger.error('Unable to get HAProxy status - Exception = ' + traceback.format_exc())
+            return False

files/sd-plugins/HAProxyPro.py

+import csv
+import os
+from urllib import urlopen
+from datetime import date, datetime
+
+class HAProxyPro:
+  def __init__( self, agentConfig, logger, rawConfig ):
+    logger.debug("HAProxy - initializing")
+    self.agent_config = agentConfig
+    self.logger = logger
+    self.raw_config = rawConfig
+    self.csv_filepath = '/etc/sd-agent/response.csv'
+
+    logger.debug("HAProxy - initialized")
+
+  def debug( self ):
+    self.logger.debug("HAProxy - agentConfig keys")
+    self.logger.debug( self.agent_config.keys() )
+    self.logger.debug("HAProxy - rawConfig keys")
+    self.logger.debug( self.raw_config.keys() )
+    self.logger.debug({
+      'date': datetime.today(),
+      'agentConfig': self.agent_config,
+      'rawConfig': self.raw_config
+    })
+
+  def num( self, s ):
+    if s:
+      return int(s)
+    else:
+      return 0
+
+  def main( self ):
+    self.logger.debug("HAProxy - inside main()")
+
+    if 'haproxy_url' not in self.raw_config['Main']:
+      self.logger.error("HAProxy - haproxy_url required in /etc/sd-agent/config.cfg but missing")
+      return False
+
+    self.status_page_url = self.raw_config['Main']['haproxy_url'] + "/;csv;norefresh"
+    self.getStatusPage()
+    self.logger.debug("HAProxy - status page")
+    self.parseStatusPage()
+
+  def getStatusPage( self ):
+    response = urlopen(self.status_page_url).read()
+    self.raw_status = response # [2:]
+
+  def parseStatusPage( self ):
+    self.parsed_status = []
+
+    f = open('/etc/sd-agent/parsed_status.csv', 'w')
+    reader = csv.DictReader( self.raw_status.split('\n'), delimiter=',' )
+    for row in reader:
+      self.parsed_status.append(row)
+      f.write("%s\n" % row)
+
+    self.createKeyedStatus()
+    self.parseTotals()
+
+  def createKeyedStatus( self ):
+    self.servers = {}
+
+    for server in self.parsed_status:
+      self.logger.debug("HAProxy - Server found: "+ server['svname'] )
+
+      self.servers[ server['# pxname'] +"_"+ server['svname'] ] = {
+        'sessions-per-second': self.num( server['rate'] ),
+        'sessions-current': self.num( server['scur'] ),
+        'sessions-max': self.num( server['smax'] ),
+        'sessions-limit': self.num( server['slim'] ),
+        'sessions-total': self.num( server['stot'] ),
+        'sessions-rate-limit': self.num( server['rate_lim'] ),
+        'sessions-rate-max': self.num( server['rate_max'] ),
+        'bytes-in': self.num( server['bin'] ),
+        'bytes-out': self.num( server['bout'] ),
+        'server-active': self.num( server['act'] ),
+        'server-backup': self.num( server['bck'] ),
+        'connection-errors': self.num( server['econ'] ),
+        'failed-health-checks': self.num( server['hanafail'] ),
+        'response-errors': self.num( server['eresp'] ),
+        'responses-denied': self.num( server['dresp'] ),
+        'responses-1xx': self.num( server['hrsp_1xx'] ),
+        'responses-2xx': self.num( server['hrsp_2xx'] ),
+        'responses-3xx': self.num( server['hrsp_3xx'] ),
+        'responses-4xx': self.num( server['hrsp_4xx'] ),
+        'responses-5xx': self.num( server['hrsp_5xx'] ),
+        'responses-xxx': self.num( server['hrsp_other'] ),
+        'client-aborts': self.num( server['cli_abrt'] ),
+        'server-aborts': self.num( server['srv_abrt'] ),
+        'lb-total': self.num( server['lbtot'] ),
+        'request-errors': self.num( server['ereq'] ),
+        'requests-denied': self.num( server['dreq'] ),
+        'requests-per-second': self.num( server['req_rate'] ),
+        'requests-per-second-max': self.num( server['req_rate_max'] ),
+        'requests-total': self.num( server['req_tot'] ),
+        'requests-queued-current': self.num( server['qcur'] ),
+        'requests-queued-max': self.num( server['qmax'] ),
+        'server-type': self.num( server['type'] ),
+        'server-weight': self.num( server['weight'] ),
+        'retries': self.num( server['wretr'] ),
+        'redispatches': self.num( server['wredis'] ),
+      }
+
+    self.logger.debug(self.servers.keys())
+
+  def parseTotals( self ):
+    totals = {}
+
+    for server_name, stats in self.servers.items():
+      self.logger.debug("HAProxy - Parsing server stats: "+ server_name)
+      for key, val in stats.items():
+        if totals.get(key):
+          totals[key] += val
+        else:
+          totals[key] = val
+
+    self.logger.debug("HAProxy - stats totals")
+    self.logger.debug(totals)
+    self.totals = totals
+
+  def clean_url( self ):
+    return
+
+  def run(self):
+    self.logger.debug("HAProxy - run()")
+    self.logger.debug("Running in directory: "+ os.getcwd() + " in path "+ os.path.realpath( __file__ ) )
+    self.debug()
+
+    try:
+      self.logger.debug("HAProxy - running main()")
+      self.main()
+      return self.totals
+    except Exception, e:
+      import traceback
+      self.logger.error('HAProxy - failure \n'+ traceback.format_exc())
\ No newline at end of file

files/sd-plugins/MySQLReplication.py

+import MySQLdb
+
+
+class MySQLReplication(object):
+    def __init__(self, agentConfig, checksLogger, rawConfig):
+        self.agentConfig = agentConfig
+        self.checksLogger = checksLogger
+        self.rawConfig = rawConfig
+
+    def run(self):
+        try:
+            db = MySQLdb.connect(
+                host=self.agentConfig['MySQLServer'],
+                user=self.agentConfig['MySQLUser'],
+                passwd=self.agentConfig['MySQLPass'])
+            cursor = db.cursor(MySQLdb.cursors.DictCursor)
+
+            cursor.execute("show slave status")
+            row = cursor.fetchone() or {}
+        except:
+            row = {}
+            result = {'Running': 0}
+        else:
+            result = {'Running': 1}
+
+        # convert flags to integer values 1/0
+        for key in ['Slave_SQL_Running', 'Slave_IO_Running']:
+            result[key] = int(row.get(key, 'No') == 'Yes')
+
+        # if the slave is not running set the metric to -1
+        key = 'Seconds_Behind_Master'
+        try:
+            result[key] = int(row.get(key, -1))
+        except TypeError:
+            result[key] = -1
+
+        # integer values
+        for key in [
+                'Master_Port', 'Until_Log_Pos', 'Skip_Counter',
+                'Relay_Log_Pos', 'Connect_Retry']:
+            result[key] = row.get(key, -1)
+
+        return result

files/sd-plugins/Oracle.py

+#!/usr/bin/env python
+
+__author__ = 'jurgenhaas'
+
+import subprocess
+
+class Oracle:
+    def __init__(self, agentConfig, checksLogger, rawConfig):
+        self.agentConfig = agentConfig
+        self.checksLogger = checksLogger
+        self.rawConfig = rawConfig
+
+    def run(self):
+        system_names = {'SYSAUX': 1, 'SYSTEM': 2, 'UNDOTBS1': 3}
+        out = subprocess.check_output('/usr/bin/sd-agent/plugins/Oracle.sh')
+        r_allocated = 0
+        r_used = 0
+        r_percentage = 0
+        r_allocated_userdata = 0
+        r_used_userdata = 0
+        r_percentage_userdata = 0
+        r_percentage_max = 0
+        try:
+            for name, allocated, used, blocks, percentage, dummy in [line.split('|') for line in out.splitlines()]:
+                print name.strip() + ':'
+                r_allocated += int(allocated)
+                r_used += float(used)
+                if name.strip() not in system_names:
+                    print ' is userdata'
+                    r_allocated_userdata += int(allocated)
+                    r_used_userdata += float(used)
+                percentage = float(percentage.rstrip('%'))
+                if percentage > r_percentage_max:
+                    r_percentage_max = percentage
+        except Exception, e:
+            pass
+
+        if r_allocated > 0:
+            r_percentage = r_used / r_allocated * 100
+
+        if r_allocated_userdata > 0:
+            r_percentage_userdata = r_used_userdata / r_allocated_userdata * 100
+
+        result = {
+            'allocated': str(r_allocated),
+            'allocated_userdata': str(r_allocated_userdata),
+            'used': str(r_used),
+            'used_userdata': str(r_used_userdata),
+            'percentage': str(r_percentage),
+            'percentage_userdata': str(r_percentage_userdata),
+            'percentage_max': str(r_percentage_max)
+        }
+        return result
+
+if __name__ == '__main__':
+    oracle = Oracle(None, None, None)
+    print oracle.run()

files/sd-plugins/Oracle.sh

+#!/bin/bash
+
+export ORACLE_HOME=/u01/app/oracle/product/11.2.0/xe
+export ORACLE_SID=XE
+export NLS_LANG=`$ORACLE_HOME/bin/nls_lang.sh`
+export ORACLE_BASE=/u01/app/oracle
+export LD_LIBRARY_PATH=$ORACLE_HOME/lib:$LD_LIBRARY_PATH
+export PATH=$ORACLE_HOME/bin:$PATH
+
+sqlplus -S sys/root as sysdba < /usr/bin/sd-agent/plugins/Oracle.sql

files/sd-plugins/Oracle.sql

+set colsep '|'
+set echo off
+set feedback off
+set linesize 1000
+set pagesize 0
+set sqlprompt ''
+set trimspool on
+set headsep off
+
+select nvl(b.tablespace_name,
+nvl(a.tablespace_name,'UNKNOWN'))
+tablespace_name,
+kbytes_alloc kbytes,
+kbytes_alloc-nvl(kbytes_free,0)
+size_alloc_bytes,
+round(((kbytes_alloc-nvl(kbytes_free,0))/ kbytes_alloc)*200) used_chart,
+to_char(((kbytes_alloc-nvl(kbytes_free,0))/ kbytes_alloc)*100,
+'999G999G999G999G999G999G990D00') ||'%' used,
+data_files
+from ( select sum(bytes)/1024/1024 Kbytes_free,
+max(bytes)/1024/1024 largest,
+tablespace_name
+from  sys.dba_free_space
+group by tablespace_name ) a,
+( select sum(bytes)/1024/1024 Kbytes_alloc,
+tablespace_name,
+count(*) data_files
+from sys.dba_data_files
+group by tablespace_name ) b
+where a.tablespace_name (+) = b.tablespace_name;