Tryag File Manager - Edit By Mr.SaHr

//usr/lib/fm-agent/plugins/process.py

import os
import sys
import agent_util
try:
    import psutil
except:
    psutil = None
import re

class ProcessPlugin(agent_util.Plugin):
    textkey = "process"
    label = "Process"

@classmethod
    def get_metadata(self, config):

status = agent_util.SUPPORTED
        msg = None
        if 'aix' in sys.platform:
            status = agent_util.SUPPORTED
            msg = None
        elif "darwin" in sys.platform:
            status = agent_util.SUPPORTED
            msg = None
        elif 'vmware' in sys.platform:
            status = agent_util.SUPPORTED
            msg = None
        elif psutil is None:
            # Unable to import psutil
            self.log.info("Unable to import psutil library, no process metrics available")
            status = agent_util.UNSUPPORTED
            msg = "Unable to import psutil library, please install and rebuild metadata"
        elif not os.path.exists("/proc"):
            self.log.info("/proc not found")
            status = agent_util.UNSUPPORTED
            msg = "Enable procfs."
            return {}

if 'vmware' in sys.platform:
            metadata = {
                "process.named_count": {
                    "label": "Number of processes - name",
                    "options": None,
                    "status": status,
                    "error_message": msg,
                    "unit": "processes",
                    "option_string": True
                },
                "process.named_count.full": {
                    "label": "Number of processes - full command line",
                    "options": None,
                    "status": status,
                    "error_message": msg,
                    "unit": "processes",
                    "option_string": True
                },
                "process.exists": {
                    "label": "Process is running",
                    "options": None,
                    "status": status,
                    "error_message": msg,
                    "unit": "boolean",
                    "option_string": True
                },
                "process.exists.full": {
                    "label": "Process is running - full command line",
                    "options": None,
                    "status": status,
                    "error_message": msg,
                    "unit": "boolean",
                    "option_string": True
                },

}

else:
            metadata = {
                "process.running_count": {
                    "label": "Number of processes running",
                    "options": None,
                    "status": status,
                    "error_message": msg,
                    "unit": "processes"
                },
                "process.named_count": {
                    "label": "Number of processes - name",
                    "options": None,
                    "status": status,
                    "error_message": msg,
                    "unit": "processes",
                    "option_string": True
                },
                "process.named_memory_percentage": {
                    "label": "Memory percentage of processes - name",
                    "options": None,
                    "status": status,
                    "error_message": msg,
                    "unit": "percent",
                    "option_string": True
                },
                "process.named_cpu_percentage": {
                    "label": "CPU percentage of processes - name",
                    "options": None,
                    "status": status,
                    "error_message": msg,
                    "unit": "percent",
                    "option_string": True
                },
                "process.exists": {
                    "label": "Process is running",
                    "options": None,
                    "status": status,
                    "error_message": msg,
                    "unit": "boolean",
                    "option_string": True
                },
                "process.thread_count": {
                    "label": "Process Thread Count - executable name only",
                    "options": None,
                    "status": status,
                    "error_message": msg,
                    "unit": "threads",
                    "option_string": True
                },
                "process.named_count.full": {
                    "label": "Number of processes - full command line",
                    "options": None,
                    "status": status,
                    "error_message": msg,
                    "unit": "processes",
                    "option_string": True
                },
                "process.named_memory_percentage.full": {
                    "label": "Memory percentage of processes - full command line",
                    "options": None,
                    "status": status,
                    "error_message": msg,
                    "unit": "percent",
                    "option_string": True
                },
                "process.named_memory_raw_mb.full": {
                    "label": "MB of memory used by processes - full command line",
                    "options": None,
                    "status": status,
                    "error_message": msg,
                    "unit": "MB",
                    "option_string": True
                },
                "process.named_cpu_percentage.full": {
                    "label": "CPU percentage of processes - full command line",
                    "options": None,
                    "status": status,
                    "error_message": msg,
                    "unit": "percent",
                    "option_string": True
                },
                "process.exists.full": {
                    "label": "Process is running - full command line",
                    "options": None,
                    "status": status,
                    "error_message": msg,
                    "unit": "boolean",
                    "option_string": True
                },
                "process.thread_count.full": {
                    "label": "Process Thread Count - executable name and args",
                    "options": None,
                    "status": status,
                    "error_message": msg,
                    "unit": "threads",
                    "option_string": True
                }
            }
        return metadata

def check(self, textkey, data, config):

if 'aix' in sys.platform or 'sunos' in sys.platform:
            #ps_cmd = "ps -eo %p' '%a"
            if 'aix' in sys.platform:
                ps_cmd = "ps axww"
            elif 'sunos' in sys.platform:
                ps_cmd = "ps -eo pid' 'args"
            retcode, output = agent_util.execute_command(ps_cmd)
            output = output.split('\n')

if textkey.endswith('.full'): textkey = textkey.rstrip('.full')
            if textkey == 'process.running_count':
                return len(output)-1
            else:
                count = 0
                pids = []
                for line in output[1:]:
                    if data in line:
                        count += 1
                        pids.append(line.split()[0])

if textkey == 'process.named_count':
                    return count
                elif textkey == 'process.exists':
                    if count: return 1
                    else: return 0
                elif textkey in ["process.named_memory_percentage", "process.named_cpu_percentage", "named_memory_raw_mb"]:
                    all_cpu = 0
                    all_mem = 0
                    all_raw_kb = 0
                    for pid in pids:
                        if 'aix' in sys.platform:
                            ps = "ps -fp %s -o pcpu,pmem,rss" % pid
                        elif 'sunos' in sys.platform:
                            ps = "ps -fp %s -o pcpu,pmem,rss" % pid
                        ret, output = agent_util.execute_command(ps)
                        output = output.strip().split('\n')
                        if len(output) < 2: continue
                        fields = output[1].split()
                        cpu = float(fields[0])
                        mem = float(fields[1])
                        raw_kb = float(fields[2])
                        all_cpu += cpu
                        all_mem += mem
                        all_raw_kb += raw_kb
                    if textkey == "process.named_memory_percentage": return all_mem
                    if textkey == "process.named_memory_raw_mb": return float(all_raw_kb)/1024
                    else: return all_cpu

# Unknown AIX/Solaris textkey
            return None
        # vmware logic
        elif 'vmware' in sys.platform:
            pgrep = agent_util.which("pgrep")
            cmd = ""
            if not pgrep:
                self.log.error("Unable to find 'pgrep'! Unable to check for processes")
                return None
            if textkey.endswith(".full"):
                cmd = "%s -f" % (pgrep)
            else:
                cmd = "%s" % (pgrep)
                cmd += ' %s' % data
            ret, output = agent_util.execute_command(cmd)
            out = output.split('\n')

if textkey.startswith('process.named_count'):
                return len(out)-1
            if textkey.startswith('process.exists'):
                if len(out) - 1 > 0:
                    return 1
                else:
                    return 0

if psutil is None:
            # Unable to import psutil, log and move on
            self.log.info("Unable to import psutil library, no process metrics available")
            return None
        # Default Linux/FreeBSD logic
        search = "name"
        if textkey.endswith(".full"):
            textkey = textkey.rstrip(".full")
            search = "cmdline_str"

# updated to use psutil library to get all processes and pull the name, pid and cmdline
        # this gets all the processes as objects
        process_objs = psutil.process_iter()
        processes = []
        data = str(data)
        if textkey.startswith("process.named_cpu_percentage") and search == 'name':
            for proc in process_objs:
                try:
                    if re.search(data, proc.name()):
                        processes.append(
                            proc.as_dict(attrs=['pid', 'cmdline', 'name', 'cpu_times'])
                        )
                except psutil.NoSuchProcess:
                    self.log.exception('Unable to get process.')
                    continue
        elif textkey.startswith("process.named_cpu_percentage") and search == 'cmdline_str':
            for proc in process_objs:
                try:
                    if re.search(data, ' '.join(proc.cmdline())):
                        processes.append(
                            proc.as_dict(attrs=['pid', 'cmdline', 'name', 'cpu_times'])
                        )
                except psutil.NoSuchProcess:
                    self.log.exception('Unable to get process.')
                    continue
        else:
            # this iterates through and shaves off infomation that isn't needed so we can filter on it later
            for proc in process_objs:
                try:
                    processes.append(
                        proc.as_dict(attrs=['pid', 'cmdline', 'name', 'cpu_percent', 'memory_percent', 'memory_info', 'num_threads'])
                    )
                except psutil.NoSuchProcess:
                    self.log.exception('Unable to get process.')
                    continue
        # setting up a process list for us to transform the split cmdline entires into cmdline_str
        for proc in processes:
            if not proc['cmdline']:
                proc['cmdline_str'] = ''
                continue
            proc['cmdline_str'] = ' '.join(proc['cmdline'])
        self.log.debug("All running processes:\n%s\n" % processes)

if textkey == "process.running_count" or textkey == "count":
            return len(psutil.pids())

if textkey == "process.named_count":
            found_procs = []
            self.log.info("Searching processes for '%s'" % data)
            for proc in processes:
                if proc[search] is not None and re.search(data, proc[search]):
                    found_procs.append(proc)
            self.log.debug(found_procs)
            return len(found_procs)

elif textkey == "process.exists":
            found_procs = []
            self.log.info("Searching processes for '%s'" % data)
            for proc in processes:
                if proc[search] is not None and re.search(data, proc[search]):
                    found_procs.append(proc)
            self.log.debug(found_procs)
            if found_procs:
                return 1
            else:
                return 0

elif textkey in ["process.named_memory_percentage", "process.named_memory_raw_mb", "process.thread_count"]:
            found_procs = []
            self.log.info("Searching processes for '%s'" % data)
            for proc in processes:
                if proc[search] is not None and re.search(data, proc[search]):
                    found_procs.append(proc)
            self.log.debug(found_procs)
            self.log.debug("Found matching processes: %s" % [p[search] for p in found_procs])
            # return 0 if no procs found
            if not found_procs:
                return 0

all_cpu = 0
            all_mem = 0
            all_raw_mem = 0
            all_thread_count = 0
            if 'darwin' == sys.platform:
                rv = self.findDarwinProcInfo(found_procs)
                all_cpu = rv['cpu_percent']
                all_mem = rv['memory_percent']
                all_raw_mem = rv['memory_info']
                all_thread_count = rv['num_threads']

else:
                for pid in found_procs:
                    cpu = pid['cpu_percent']
                    mem = pid['memory_percent']
                    mem_raw = pid['memory_info'].rss
                    thread_count = pid['num_threads']

all_cpu += cpu
                    all_mem += mem
                    all_raw_mem += mem_raw
                    all_thread_count += thread_count
                all_raw_mem = float(all_raw_mem)/(1024*1024)

if textkey == "process.named_memory_percentage": return all_mem
            if textkey == "process.named_memory_raw_mb": return all_raw_mem
            if textkey == "process.thread_count": return all_thread_count
            else: return all_cpu

elif textkey in ['process.named_cpu_percentage', 'process.named_cpu_percentage.full']:
            if processes:
                user_sum = sum([p.get('cpu_times').user + p.get('cpu_times').system for p in processes])
            else:
                return 0.
            last_result = self.get_cache_results(textkey, data)
            if not last_result:
                self.cache_result(textkey, data, user_sum)
                return None
            delta, previous = last_result[0]
            time_used_result = (user_sum - previous) / delta
            self.cache_result(textkey, data, user_sum)
            number_of_cores = psutil.cpu_count()
            if not number_of_cores:
                number_of_cores = 1
            return (time_used_result / number_of_cores) * 100

return 0

def findDarwinProcInfo(self, found_procs):
        """
        On OSX, psutil will not report process information on processes
        belonging to other users, unless the requesting process is privileged. 
        https://github.com/giampaolo/psutil/issues/883
        """
        pids = []
        for fp in found_procs:
            pids.append(str(fp['pid']))

rc, output = agent_util.execute_command(
            'ps uM -p {}'.format(','.join(pids))
        )
        lines = output.split('\n')
        procLines = lines[1:]
        rv = {
            'cpu_percent' : float(0),
            'memory_percent' : float(0),
            'memory_info' : float(0),
            'num_threads' : len(procLines)

}
        for l in procLines: 
            info = l.split()
            if len(info) == 14:
                # Full info line for process
                rv['cpu_percent'] += float(info[2])
                rv['memory_percent'] += float(info[3])
                rv['memory_info'] += float(info[5])

m = rv['memory_info']
        rv['memory_info'] = float(m) / 1024
        return rv