EVOLUTION-NINJA

Edit File: jmx.py

import agent_util
import logging
import sys

logger = logging.getLogger(__name__)

def parse_jmx_config(config):
    """
    Split the jmx configuration into multiple instances based on the number
    of comma separated instances there are.

:param config: Dict
    :return: List of Dicts
    """
    configs = {}
    jvm_path = None
    for key, value in config.items():
        if key == "jvm_path":
            jvm_path = value
        elif key == "debug":
            continue
        else:
            for i, inner in enumerate(value.split(",")):
                if i not in configs.keys():
                    configs[i] = {}
                if len(value) > 0:
                    configs[i][key] = inner.strip(" ")

for key in configs:
        configs[key]["jvm_path"] = jvm_path
    if sys.version_info >= (3, 0):
        return list(configs.values())
    else:
        return configs.values()

class JMXPlugin(agent_util.Plugin):
    textkey = "jmx"
    label = "JMX"

@classmethod
    def get_metadata(self, config):
        status = agent_util.SUPPORTED
        msg = None

# Check for jmx configuration block
        if not config:
            self.log.info("No JMX configuration found")
            return {}

configs = parse_jmx_config(config)

# Check for config setting sin jmx configuration block
        invalid_configs = []
        missing_keys = []
        for entry in configs:
            for key in ["port", "host", "jvm_path"]:
                if key not in entry.keys():
                    invalid_configs.append(entry)
                    missing_keys.append(key)
                    configs.remove(entry)

if len(invalid_configs) == len(configs):
            msg = (
                "Missing value for %s in the [jmx] block of the agent config file."
                % missing_keys
            )
            self.log.info(msg)
            status = agent_util.MISCONFIGURED

try:
            import jpype
        except:
            msg = "Unable to access JMX metrics due to missing jpype library."
            self.log.info(msg)
            status = agent_util.MISCONFIGURED

try:
            if status == agent_util.SUPPORTED and not jpype.isJVMStarted():
                jpype.startJVM(config["jvm_path"])
        except:
            msg = "Unable to access JMX metrics because JVM cannot be started."
            self.log.info(msg)
            status = agent_util.MISCONFIGURED

if status == agent_util.SUPPORTED:
            invalid_configs = []
            for entry in configs:
                try:
                    from jpype import java, javax

jhash = java.util.HashMap()
                    if config.get("username") and config.get("password"):
                        jarray = jpype.JArray(java.lang.String)(
                            [config["username"], config["password"]]
                        )
                        jhash.put(
                            javax.management.remote.JMXConnector.CREDENTIALS, jarray
                        )
                    url = "service:jmx:rmi:///jndi/rmi://%s:%d/jmxrmi" % (
                        entry["host"],
                        int(entry["port"]),
                    )
                    jmxurl = javax.management.remote.JMXServiceURL(url)
                    javax.management.remote.JMXConnectorFactory.connect(jmxurl, jhash)
                except:
                    self.log.exception("Unable to connect to JMX %s" % str(entry))
                    invalid_configs.append(entry)

if len(invalid_configs) == len(configs):
                msg = (
                    "Unable to access JMX metrics, JMX is not running or not installed. Check configs %s"
                    % (str(invalid_configs))
                )
                self.log.info(msg)
                status = agent_util.MISCONFIGURED

metadata = {
            "jmx.custom": {
                "label": "Custom JMX Metric",
                "options": None,
                "status": status,
                "error_message": msg,
                "option_string": True,
            }
        }
        return metadata

def check(self, textkey, data, config):
        try:
            import jpype
            from jpype import java, javax

configs = parse_jmx_config(config)
            jvm_path = configs[0]["jvm_path"]

try:
                data, port = data.split("::")
            except ValueError:
                port = None
                # No port came in the data.
                if len(configs) > 1:
                    self.log.error(
                        "Port information missing from mBean. Unable to pick environment to execute. Aborting"
                    )
                    return

if port:
                found = False
                for config in configs:
                    if config["port"] == port:
                        found = True
                        break
                if not found:
                    # Check sent a port that doesn't match.
                    self.log.error(
                        "Port %s is not one of the configured ones. Check cannot execute"
                        % port
                    )
                    return

if not jpype.isJVMStarted():
                jpype.startJVM(jvm_path)
            jhash = java.util.HashMap()
            if config.get("username") and config.get("password"):
                jarray = jpype.JArray(java.lang.String)(
                    [config["username"], config["password"]]
                )
                jhash.put(javax.management.remote.JMXConnector.CREDENTIALS, jarray)
            url = "service:jmx:rmi:///jndi/rmi://%s:%d/jmxrmi" % (
                config["host"],
                int(config["port"]),
            )
            jmxurl = javax.management.remote.JMXServiceURL(url)
            jmxsoc = javax.management.remote.JMXConnectorFactory.connect(jmxurl, jhash)
            connection = jmxsoc.getMBeanServerConnection()
            """
            Look for two Mbeans || separated and calculate the %.
            The expected input will be: MBean1||MBean2. Example for MemoryHeapUsage:
            java.lang:type=Memory/HeapMemoryUsage/used||java.lang:type=Memory/HeapMemoryUsage/committed
            """
            if "||" in data:
                data = data.split("||")
                # Create a list from the two MBeans || separated.
                calc = []
                for i in data:
                    # Iterate the list to get each MBean value that will be set for the % calculation.
                    res = self._get_bean_value(i, connection)
                    if res is None:
                        return None
                    calc.append(res)

return 100 * calc[0] / calc[1]
            return self._get_bean_value(data, connection)
        except:
            self.log.exception("Error gathering JMX metric")
            return

def _get_bean_value(self, bean_str, connection):
        try:
            from jpype import javax

last_slash = bean_str.rfind("/")
            if -1 == last_slash:
                return None
            obj_name = bean_str[:last_slash]

java_obj = javax.management.ObjectName(obj_name)
            attribute = bean_str[last_slash + 1 :]
            # self.log.debug('Checking object name {} attr {}'.format(obj_name, attribute))
            if connection.isRegistered(java_obj):
                res = connection.getAttribute(java_obj, attribute)
                return res.floatValue()
            last_slash = obj_name.rfind("/")
            if -1 == last_slash:
                return None
            key = attribute
            next_obj_name = obj_name[:last_slash]
            java_obj = javax.management.ObjectName(next_obj_name)
            attribute = obj_name[last_slash + 1 :]
            # self.log.debug('Checking object name {} attr {}'.format(next_obj_name, attribute))
            if connection.isRegistered(java_obj):
                res = connection.getAttribute(java_obj, attribute)
                if hasattr(res, "contents"):
                    res = res.contents.get(key)
                else:
                    res = res.get(key)
                return res.floatValue()
            self.log.error("Could not find object name %s" % bean_str)
            return None

except:
            self.log.exception("_get_bean_value %s caught an exception" % bean_str)
            return None