EVOLUTION-NINJA

Edit File: nginx.py

import re
import agent_util
import logging
import glob
from library.log_matcher import LogMatcher

try:
    # Python3
    from urllib.request import urlopen
except ImportError:
    # Python2
    from urllib2 import urlopen

logger = logging.getLogger(__name__)

def execute_query(query):
    ret, output = agent_util.execute_command(query)
    return str(output)

LOG_COUNT_EXPRESSIONS = {"4xx": r"4\d{2}", "5xx": r"5\d{2}", "2xx": r"2\d{2}"}
DEFAULT_NGINX_LOG = "/var/log/nginx/access.log"

class NginxPlugin(agent_util.Plugin):
    textkey = "nginx"
    label = "Nginx"

DEFAULTS = {"console_url": "http://localhost"}

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

# check if nginx is even installed or running
        installed = agent_util.which("nginx")
        if not installed and not config.get("from_docker"):
            self.log.info("nginx binary not found")
            status = agent_util.UNSUPPORTED
            return {}

if "console_url" not in config:
            config.update(self.DEFAULTS)

if status == agent_util.SUPPORTED and not config.get("from_docker"):
            query = "%s/nginx_status" % config["console_url"]
            nginxStatus = (
                urlopen("%s/nginx_status" % config["console_url"]).read().decode()
            )
            if config.get("debug", False):
                self.log.debug("Nginx command '%s' output:" % query)
                self.log.debug(str(nginxStatus))

if not nginxStatus:
                status = agent_util.MISCONFIGURED
                msg = "The nginx_status path is not configured."

data = {
            "active_connections": {
                "label": "Number of open connections",
                "options": None,
                "status": status,
                "error_message": msg,
                "unit": "connections",
            },
            "accepted_connections": {
                "label": "Number of accepted connections per second",
                "options": None,
                "status": status,
                "error_message": msg,
                "unit": "connections/s",
            },
            "dropped_connections": {
                "label": "Number of dropped connections per second",
                "options": None,
                "status": status,
                "error_message": msg,
                "unit": "connections/s",
            },
            "handled_connections": {
                "label": "Number of handled connections per second",
                "options": None,
                "status": status,
                "error_message": msg,
                "unit": "connections/s",
            },
            "requests_per_second": {
                "label": "Average requests per second",
                "options": None,
                "status": status,
                "error_message": msg,
                "unit": "requests/s",
            },
            "requests_per_connection": {
                "label": "Number of requests per connection",
                "options": None,
                "status": status,
                "error_message": msg,
                "unit": "requests",
            },
            "nginx_reading": {
                "label": "Read request header",
                "options": None,
                "status": status,
                "error_message": msg,
                "unit": "requests/s",
            },
            "nginx_writing": {
                "label": "Read request body",
                "options": None,
                "status": status,
                "error_message": msg,
                "unit": "requests/s",
            },
            "nginx_waiting": {
                "label": "Keep alive connections",
                "options": None,
                "status": status,
                "error_message": msg,
                "unit": "connections/s",
            },
            "4xx": {
                "label": "Rate of 4xx's events",
                "options": None,
                "status": status,
                "error_message": msg,
                "unit": "entries/s",
            },
            "2xx": {
                "label": "Rate of 2xx's events",
                "options": None,
                "status": status,
                "error_message": msg,
                "unit": "entries/s",
            },
            "5xx": {
                "label": "Rate of 5xx's events",
                "options": None,
                "status": status,
                "error_message": msg,
                "unit": "entries/s",
            },
        }

return data

@classmethod
    def get_metadata_docker(self, container, config):
        if "console_url" not in config:
            try:
                ip = agent_util.get_container_ip(container)
                config["console_url"] = "http://%s" % ip
            except Exception:
                import sys

_, e, _ = sys.exc_info()
                self.log.exception(e)

config["from_docker"] = True

return self.get_metadata(config)

def _calculate_delta(self, textkey, value, is_rate=True):
        """
        Extract the previous cached value, calculate the delta,
        and store the current one.
        """
        cached = self.get_cache_results("nginx:%s" % textkey, None)
        if not cached:
            self.log.info("Empty nginx cache! Building for first time")
            self.cache_result("nginx:%s" % textkey, None, value, replace=True)
            return None
        delta, previous_value = cached[0]
        self.cache_result("nginx:%s" % textkey, None, value, replace=True)
        if previous_value > value:
            return None
        if is_rate:
            return (value - previous_value) / float(delta)
        else:
            return value - previous_value

def check(self, textkey, data, config):
        if not config.get("console_url"):
            config.update(self.DEFAULTS)
        result = urlopen("%s/nginx_status" % config["console_url"]).read().decode()
        statLines = result.split("\n")
        p = re.compile(r"(\d+)")
        connections = p.findall(statLines[2])
        connectionsByStatus = p.findall(statLines[3])
        result = 0
        status_map = {
            "nginx_reading": int(connectionsByStatus[0]),
            "nginx_writing": int(connectionsByStatus[1]),
            "nginx_waiting": int(connectionsByStatus[2]),
        }
        if textkey == "active_connections":
            active_connections = p.findall(statLines[0])
            result = int(active_connections[0])
        elif textkey == "requests_per_connection":
            active_connections = p.findall(statLines[0])
            active_connections = int(active_connections[0])
            requests = int(connections[2])
            requests_textkey = "%s:%s" % (textkey, "requests")
            requests_diff = self._calculate_delta(
                requests_textkey, requests, is_rate=False
            )
            if active_connections and requests_diff:
                return requests_diff / active_connections
            else:
                return None
        # All these values use the delta calculation method
        elif textkey in (
            "nginx_reading",
            "nginx_writing",
            "nginx_waiting",
            "requests_per_second",
            "accepted_connections",
            "handled_connections",
            "handles_request",
            "dropped_connections",
        ):
            # The only difference is in how they get the current value
            if textkey in ("nginx_reading", "nginx_writing", "nginx_waiting"):
                current_res = status_map[textkey]
            elif textkey == "accepted_connections":
                current_res = int(connections[0])
            elif textkey == "handled_connections":
                current_res = int(connections[1])
            elif textkey in ("requests_per_second"):
                current_res = int(connections[2])
            elif textkey in ("dropped_connections"):
                current_res = int(connections[0]) - int(connections[1])
            return self._calculate_delta(textkey, current_res)

# Handle the log count metrics
        elif textkey in ("4xx", "5xx", "2xx"):
            log_files = [DEFAULT_NGINX_LOG]
            for key, value in config.items():
                if key not in ["debug", "console_url"]:
                    value = value.strip('"').strip("'")
                    if "*" in value:
                        log_files += glob.glob(value)
                    else:
                        log_files += [value]
            file_inodes = {}
            total_metrics = 0
            timescale = 1
            column = 8

expression = LOG_COUNT_EXPRESSIONS.get(textkey)

for target in log_files:
                # Extract the file current inode
                try:
                    file_inodes[target] = LogMatcher.get_file_inode(target)
                except OSError:
                    import sys

_, error, _ = sys.exc_info()
                    logging.error("Error opening %s file." % (target))
                    logging.error(error)
                    continue

# Extract data from the agent cache about the check
                log_data = self.get_cache_results(
                    textkey, "%s/%s" % (self.schedule.id, target)
                )
                if log_data:
                    log_data = log_data[0][-1]
                else:
                    log_data = dict()

last_line_number = log_data.get("last_known_line")
                stored_inode = log_data.get("inode")
                results = log_data.get("results", [])

# Extract the lines of the file.
                try:
                    total_lines, current_lines = LogMatcher.get_file_lines(
                        last_line_number, target, file_inodes[target], stored_inode
                    )
                except IOError:
                    import sys

_, e, _ = sys.exc_info()
                    logging.error(
                        "Unable to read log file: %s. Make sure fm-agent user belongs to group adm"
                        % str(e)
                    )
                    continue

logging.info(
                    "Stored line %s Current line %s Looking at %s lines"
                    % (str(last_line_number), str(total_lines), str(len(current_lines)))
                )
                # Perform the matching of the expression in the lines
                log_matcher = LogMatcher(stored_inode)
                results = log_matcher.match_in_column(current_lines, expression, column)
                metric, results = log_matcher.calculate_metric(results, timescale)
                total_metrics += metric and metric or 0
                logging.info(
                    'Found %s instances of "%s" in %s'
                    % (str(metric or 0), expression, target)
                )

previous_result = self.get_cache_results(
                    textkey, "%s/%s" % (self.schedule.id, target)
                )
                cache_data = dict(
                    inode=file_inodes[target],
                    last_known_line=total_lines,
                    results=results,
                )
                self.cache_result(
                    textkey,
                    "%s/%s" % (self.schedule.id, target),
                    cache_data,
                    replace=True,
                )
                if not previous_result:
                    result = None
                else:
                    delta, prev_data = previous_result[0]
                    try:
                        prev_count = prev_data.get("results")[0][-1]
                        curr_count = cache_data.get("results")[0][-1]
                        result = curr_count / float(delta)
                    except IndexError:
                        result = None
        return result

def check_docker(self, container, textkey, data, config):
        if "console_url" not in config:
            try:
                ip = agent_util.get_container_ip(container)
                config["console_url"] = "http://%s" % ip
            except Exception:
                import sys

_, e, _ = sys.exc_info()
                self.log.exception(e)

config["from_docker"] = True

return self.check(textkey, data, config)