EVOLUTION-NINJA

Edit File: 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.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