nginx_upstream_multi_

Sadly there is no documentation for this plugin.
#!/usr/bin/env python3
#
# Munin plugin to monitor requests number, cache statuses, http status codes and average request
# times of specified nginx upstreams.
#
# Copyright Igor Borodikhin
#
# License : GPLv3
#
# Configuration parameters:
# env.graphs - which graphs to produce (optional, list of graphs separated by spaces, default -
#              cache http time request)
# env.log - log file path (mandatory, ex.: /var/log/nginx/upstream.log)
# env.upstream - list of upstreams to monitor (mandatory, including port numbers separated by
#                space, e.g.: 10.0.0.1:80 10.0.0.2:8080)
# env.statuses - list of http status codes to monitor (optional, default - all statuses,
#                e.g.: 200 403 404 410 500 502)
# env.percentiles - which percentiles to draw on time graphs (optional, list of percentiles
#                   separated by spaces, default - 80)
#
# ## Installation
# Copy file to directory /usr/share/munin/pligins/ and create symbolic link(s) for each log file
# you wish to monitor.
#
# Specify log_format at /etc/nginx/conf.d/upstream.conf:
# log_format upstream "ua=[$upstream_addr] ut=[$upstream_response_time] us=[$upstream_status] \
#     cs=[$upstream_cache_status]"
#
# Use it in your site configuration (/etc/nginx/sites-enabled/anything.conf):
# access_log /var/log/nginx/upstream.log upstream;
#
# Attention! Since the default user (nobody) does not have read permission for nginx log files we
# need to run it as root.
#
# And specify some options in /etc/munin/plugin-conf.d/munin-node:
#
#     [nginx_upstream_multi_upstream]
#     user root
#     env.graphs cache http time request
#     env.log /var/log/nginx/upstream.log
#     env.upstream 10.0.0.1:80 10.0.0.2:8080 unix:/tmp/upstream3
#     env.statuses 200 403 404 410 500 502
#     env.percentiles 50 80
#
#  #%# family=contrib

import copy
import math
import os
import re
import sys
import time


# How we've been called
progName = sys.argv[0]
progName = progName[progName.rfind("/") + 1:]


# Where to store plugin state
stateDir = os.environ.get("MUNIN_PLUGSTATE", None)

# Which site configuration we should use
siteName = progName[len("nginx_upstream_multi_"):]

# Log path
logPath = os.environ.get("log", "/var/log/nginx/access.log")

# Http statuses list
httpStatusString = (
    "100:Continue;101:Switching protocols;102:Processing;200:OK;201:Created;202:Accepted;"
    "203:Non-Authoritative Information;204:No content;205:Reset content;206:Partial content;"
    "207:Multi-status;226:IM used;300:Multiple choices;301:Moved permanently;"
    "302:Moved temporarily;303:See other;304:Not modified;305:Use proxy;307:Temporary redirect;"
    "400:Bad request;401:Unauthorized;402:Payment required;403:Forbidden;404:Not found;"
    "405:Method not allowed;406:Not acceptable;407:Proxy Authentication Required;"
    "408:Request timeout;409:Conflict;410:Gone;411:Length required;412:Precondition failed;"
    "413:Request entity too large;414:Request URI too large;415:Unsupported media type;"
    "416:Request range not satisfiable;417:Expectation failed;422:Unprocessable entity;"
    "423:Locked;424:Failed dependency;425:Unordered collection;426:Upgrade required;"
    "449:Retry with;456:Unrecoverable error;500:Internal server error;501:Not implemented;"
    "502:Bad gateway;503:Service unavailable;504:Gateway timeout;505:HTTP version not supported;"
    "506:Variant also negotiates;507:Insufficient storage;508:Loop detected;"
    "509:Bandwidth limit exceeded;510:Not extended")

# an empty list of wanted statuses is interpreted as: all statuses
statuses = os.environ.get("statuses", "").split()

httpStatusList = {}
for statusString in httpStatusString.split(";"):
    [code, title] = statusString.split(":")
    if len(statuses) > 0 and code in statuses or len(statuses) == 0:
        httpStatusList[code] = {
            "title": title,
            "requests": 0
        }

cacheStatusList = {"MISS": 0, "BYPASS": 0, "EXPIRED": 0, "UPDATING": 0, "STALE": 0, "HIT": 0}

# Parse upstreams
upstreams = {}
if "upstream" in os.environ:
    upstreamString = os.environ["upstream"]
    upstreamList = upstreamString.split()
    for upstream in upstreamList:
        upstreams[upstream] = {
            "requests": 0,
            "time": 0,
            "times": [],
            "cache": copy.deepcopy(cacheStatusList),
            "http": copy.deepcopy(httpStatusList)
        }
else:
    raise Exception("No upstreams specified")

percentiles = os.environ.get("percentiles", "80").split()

graphs_enabled = os.environ.get("graphs", "cache http time request").split()

now = int(time.time())

lastBytePath = os.path.join(stateDir, "nginx_upstream_multi_{}_lastByte.txt".format(siteName))
try:
    lastRun = os.path.getmtime(lastBytePath)
except OSError:
    lastRun = now


def sanitize(string):
    return string.replace(".", "_").replace(":", "_").replace("/", "_").replace("-", "_")


if len(sys.argv) == 2 and sys.argv[1] == "config":
    # Parent graph declaration
    print("multigraph nginx_upstream_multi_%s" % siteName.replace(".", "_"))
    print("graph_title Requests number")
    print("graph_vlabel rps")
    print("graph_category webserver")
    for upstream in upstreams.keys():
        print("us%s_requests.label %s" % (sanitize(upstream), upstream))

    # Requests graph declaration
    if "request" in graphs_enabled:
        for upstream in upstreams.keys():
            print()
            print("multigraph nginx_upstream_multi_%s.%s_requests"
                  % (sanitize(siteName), sanitize(upstream)))
            print("graph_title Requests number - %s" % upstream)
            print("graph_vlabel rps")
            print("graph_category webserver")
            print("us%s_requests.label %s" % (sanitize(upstream), upstream))
            print()

    # Times graph declaration
    if "time" in graphs_enabled:
        for upstream in upstreams.keys():
            print()
            print("multigraph nginx_upstream_multi_%s.%s_times"
                  % (sanitize(siteName), sanitize(upstream)))
            print("graph_title Request time - %s" % upstream)
            print("graph_vlabel sec.")
            print("graph_category webserver")
            print("us%s_times.label average" % (sanitize(upstream)))
            for percentile in percentiles:
                print("us%s_times_percentile_%s.label %s-percentile"
                      % (sanitize(upstream), percentile, percentile))
            print()

    # HTTP Status codes graph declaration
    if "http" in graphs_enabled:
        for upstream in upstreams.keys():
            print()
            print("multigraph nginx_upstream_multi_%s.%s_statuses"
                  % (sanitize(siteName), sanitize(upstream)))
            print("graph_title HTTP - %s" % upstream)
            print("graph_vlabel rps")
            print("graph_category webserver")
            for status in sorted(httpStatusList.keys()):
                print("http%s_%s_status.label %s - %s"
                      % (status, sanitize(upstream), status, httpStatusList[status]["title"]))
            print()

    # Cache status graph declaration
    if "cache" in graphs_enabled:
        for upstream in upstreams.keys():
            print()
            print("multigraph nginx_upstream_multi_%s.%s_cache"
                  % (sanitize(siteName), sanitize(upstream)))
            print("graph_title Cache - %s" % upstream)
            print("graph_vlabel rps")
            print("graph_category webserver")
            for status in cacheStatusList:
                print("us%s_%s_cache.label %s" % (sanitize(status), sanitize(upstream), status))
            print()
else:
    timeElapsed = now - lastRun

    lastByteHandle = None

    try:
        lastByteHandle = open(lastBytePath, "r")
        lastByte = int(lastByteHandle.read())
    except Exception:
        lastByte = 0

    if lastByteHandle is not None:
        lastByteHandle.close()

    try:
        logHandle = open(logPath, "r")
    except Exception as e:
        print("Log file %s not readable: %s" % (logPath, e.strerror), file=sys.stderr)
        sys.exit(1)

    try:
        logSize = int(os.path.getsize(logPath))
    except ValueError:
        logSize = 0

    if logSize < lastByte:
        lastByte = 0

    regExp = re.compile(r"ua=\[(.*?)\]\s+ut=\[(.*?)\]\s+us=\[(.*?)\]\s+cs=\[(.*?)\]")

    logHandle.seek(lastByte)
    for line in logHandle:
        match = regExp.search(line)
        if (match):
            # Extract data
            address = match.group(1)
            request_time = match.group(2)
            status = match.group(3)
            cache = match.group(4)

            # Replace separators by space
            address = address.replace(",", " ")
            address = address.replace(" : ", " ")
            address = re.sub(r"\s+", " ", address)

            request_time = request_time.replace(",", " ")
            request_time = request_time.replace(" : ", " ")
            request_time = re.sub(r"\s+", " ", request_time)

            status = status.replace(",", " ")
            status = status.replace(" : ", " ")
            status = re.sub(r"\s+", " ", status)

            cache = cache.replace(",", " ")
            cache = cache.replace(" : ", " ")
            cache = re.sub(r"\s+", " ", cache)

            addresses = address.split()
            times = request_time.split()
            statuses = status.split()
            caches = cache.split()

            index = 0
            for uAddress in addresses:
                if uAddress in upstreams.keys():
                    try:
                        uTime = float(times[index])
                    except ValueError:
                        uTime = 0

                    if index < len(statuses):
                        uStatus = statuses[index]
                    else:
                        uStatus = "-"

                    if index < len(caches):
                        uCache = caches[index]
                    else:
                        uCache = "-"

                    if uAddress != "-":
                        upstreams[uAddress]["requests"] += 1
                    if uTime != "-":
                        upstreams[uAddress]["time"] += uTime
                        upstreams[uAddress]["times"].append(uTime)
                    if uStatus != "-" and uStatus in upstreams[uAddress]["http"].keys():
                        upstreams[uAddress]["http"][uStatus]["requests"] += 1
                    if uCache != "-":
                        upstreams[uAddress]["cache"][uCache] += 1
                index += 1

    try:
        lastByteHandle = open(lastBytePath, "w")
        lastByteHandle.write(str(logHandle.tell()))
        lastByteHandle.close()
    except Exception as e:
        print("Failed to write status file (%s): %s" % (lastBytePath, e.strerror), file=sys.stderr)
        sys.exit(1)

    logHandle.close()

    # Parent graph data
    for upstream in upstreams.keys():
        value = 0
        if timeElapsed > 0:
            value = upstreams[upstream]["requests"] / timeElapsed

        print("us%s_requests.value %s" % (sanitize(upstream), value))

    # Requests graph data
    if "request" in graphs_enabled:
        for upstream in upstreams.keys():
            print()
            print("multigraph nginx_upstream_multi_%s.%s_requests"
                  % (sanitize(siteName), sanitize(upstream)))
            value = 0
            if timeElapsed > 0:
                value = upstreams[upstream]["requests"] / timeElapsed
            print("us%s_requests.value %s" % (sanitize(upstream), value))
            print()

    # Times graph data
    if "time" in graphs_enabled:
        for upstream in upstreams.keys():
            uTime = 0
            if upstreams[upstream]["requests"] > 0:
                uTime = upstreams[upstream]["time"] / upstreams[upstream]["requests"]
                upstreams[upstream]["times"].sort()
            print()
            print("multigraph nginx_upstream_multi_%s.%s_times"
                  % (sanitize(siteName), sanitize(upstream)))
            print("us%s_times.value %s" % (sanitize(upstream), uTime))
            for percentile in percentiles:
                percentileValue = 0
                if upstreams[upstream]["requests"] > 0:
                    uTime = upstreams[upstream]["time"] / upstreams[upstream]["requests"]
                    percentileKey = int(percentile) * len(upstreams[upstream]["times"]) / 100
                    if len(upstreams[upstream]["times"]) % 2 > 0:
                        low = int(math.floor(percentileKey))
                        high = int(math.ceil(percentileKey))
                        percentileValue = (upstreams[upstream]["times"][low]
                                           + upstreams[upstream]["times"][high]) / 2
                    else:
                        percentileValue = upstreams[upstream]["times"][int(percentileKey)]
                print("us%s_times_percentile_%s.value %s"
                      % (sanitize(upstream), percentile, percentileValue))
            print()

    # HTTP Status codes graph data
    if "http" in graphs_enabled:
        for upstream in upstreams.keys():
            print()
            print("multigraph nginx_upstream_multi_%s.%s_statuses"
                  % (sanitize(siteName), sanitize(upstream)))
            for status in sorted(httpStatusList.keys()):
                value = 0
                if timeElapsed > 0:
                    value = upstreams[upstream]["http"][status]["requests"] / timeElapsed

                print("http%s_%s_status.value %s" % (status, sanitize(upstream), value))
            print()

    # Cache status graph data
    if "cache" in graphs_enabled:
        for upstream in upstreams.keys():
            print()
            print("multigraph nginx_upstream_multi_%s.%s_cache"
                  % (sanitize(siteName), sanitize(upstream)))
            for status in cacheStatusList:
                value = 0
                if timeElapsed > 0:
                    value = upstreams[upstream]["cache"][status] / timeElapsed

                print("us%s_%s_cache.value %s" % (sanitize(status), sanitize(upstream), value))
            print()