es

proc.py

#!/usr/bin/python
import psutil
import math
import time
import os
import graphyte
import socket
import requests
GRAPHITE_SERVER = '10.132.159.81'
GRAPHITE_PORT   = 2003
METRICS_PREFIX  = socket.gethostname()
graphyte.init(GRAPHITE_SERVER,GRAPHITE_PORT, prefix=METRICS_PREFIX)
bluprocesses = {
                  "elasticsearch":"bootstrap.Elasticsearch"
               }
bluproc_map = {}
class NodeData:
    def __init__(self, heap, ram, cpu, load_1m,load_5m,load_15):
        self.heap_percent = heap
        self.ram_percent  = ram
        self.cpu_percent  = cpu
        self.load_1m      = load_1m
        self.load_5m      = load_5m
        self.load_15m     = load_15
def es_stats():
    ES_HEALTH_URL = "http://10.132.159.172:9200/_cat/nodes?v"
    try:
        r = requests.get(ES_HEALTH_URL,timeout=30)
        lines = r.text.split("\n")
        for idx, line in enumerate(lines):
            if idx == 0:
                continue
            line = line.strip()
            if not line :
                continue
            fields = line.split()
            key = fields[0].replace(".", "-")
            #print(str(key) + "." + "heap.percent" + ":" + str(fields[1]))
            graphyte.send(str(key + "." + "heap.percent"),int(fields[1]))
            graphyte.send(str(key + "." + "ram.percent"),int(fields[2]))
            graphyte.send(str(key + "." + "cpu.percent"),int(fields[3]))
            graphyte.send(str(key + "." + "load.1m"),float(fields[4]))
            graphyte.send(str(key + "." + "load.5m"),float(fields[5]))
            graphyte.send(str(key + "." + "load.15m"),float(fields[6]))
    except requests.exceptions.Timeout as to:
        pass
        print("Request Timeout")
def convert_size(size_bytes):
   if size_bytes == 0:
       return "0B"
   size_name = ("B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB")
   i = int(math.floor(math.log(size_bytes, 1024)))
   p = math.pow(1024, i)
   s = round(size_bytes / p, 2)
   return "%s %s" % (s, size_name[i])
class BluProcInfo(object):
    def __init__(self, lname, proc):
        self.name      = lname
        self.pid       = proc.pid
        self.phybytes  = proc.memory_info().rss
        self.virbytes  = proc.memory_info().vms
        self.phystr    = convert_size(self.phybytes)
        self.cpuper    = proc.cpu_percent(interval=1.0)
        self.virstr    = convert_size(self.virbytes)
        self.phypercent = round(proc.memory_percent(memtype="rss"),2)
        self.virpercent = round(proc.memory_percent(memtype="vms"),2)
    def __str__(self):
        retstr = self.name + " (" + str(self.pid)  + ")\t\t"
        retstr +=  str(self.phybytes) + "  " + self.phystr + "  " + str(self.phypercent) + "%\t\t"
        retstr +=  str(self.virbytes) + "  " + self.virstr + "  " + str(self.virpercent) + "%"
        return retstr
def monitor_processes():
    allpids = psutil.pids()
    for pid in allpids:
        try:
            proc = psutil.Process(pid)
            if "java" in proc.name():
                cmd = proc.cmdline()
                for key, value in bluprocesses.iteritems():
                    if value in str(cmd):
                        elem = BluProcInfo(key,proc)
                        bluproc_map[key+str(pid)] = elem
                        break
        except Exception as e:
            print(str(e))
            continue
    #print("%25s%52s%52s" % ("Process","Physical Memory","Virtual Memory"))
    pstr  = '{:^25s}'.format('Process')
    pystr = '{:^40s}'.format('Physical Memory')
    vistr = '{:^40s}'.format('Virtual Memory')
    print (pstr + " | " + pystr + " | " + vistr)
    for proc in bluproc_map.values():
         procname = '{:15s}'.format(proc.name).strip()
         procpid  = '{:8d}'.format(proc.pid)
         namepidstr = '{}[{}]'.format(procname,procpid)
         phystr  = '{:12d} {:15s} {:10f}%'.format(proc.phybytes,proc.phystr,proc.phypercent)
         vmemstr =  '{:10d} {:15s} {:10f}%'.format(proc.virbytes,proc.virstr,proc.virpercent)
         #print("%15s(%6d) %12d%10s%6.2f%c %12d%10s%6.2f%c" % (proc.name,proc.pid,proc.phybytes,proc.phystr,proc.phypercent,'%', proc.virbytes,proc.virstr,proc.virpercent,'%'))
         #print(namepidstr + " | " + phystr + " | " + vmemstr)
         #print(namepidstr + " | " + str(proc.phybytes) + " | " + str(proc.virbytes))
         #key = procname
         #value = proc.phybytes
         procname.rstrip()
         print("{:^25s} => {:12d}".format(str(procname + "." + "physical.memory"),proc.phybytes))
         print("{:^25s} => {:12d}".format(str(procname + "." + "virtual.memory"),proc.virbytes))
         print("-------------------------------------------------------------------------------")
         graphyte.send(str(procname + "." + "physical.memory"),proc.phybytes)
         graphyte.send(str(procname + "." + "virtual.memory"),proc.virbytes)
         graphyte.send(str(procname + "." + "cpu.usage"),proc.cpuper)
while True:
     os.system('clear')
     print("system.cpu.info", psutil.cpu_percent(interval=1))
     #print("system.mem.info", psutil.memory_info(memtype="rss"))
        ()
     if (METRICS_PREFIX == "poc-node-01"):
         es_stats()
     #exit()
     time.sleep(10)