Extração de dados do gráfico de Capacity Planning

fmaced1
(usa CentOS)

Enviado em 01/05/2018 - 18:31h

Pessoal boa noite,

Estou estudando e testando o Nagios e achei bem interessante porem meio confuso o relatório de capacity planning (ele pode ajudar na hora de explicar o porque investir em mais recurso), teria alguma forma de extrair os dados desse relatório para personalizar a visualização ?

Tentei usar a opção de extrair para csv, porem não aparece como na tabela do gráfico.

Achei o script em python que o Nagios usa pra pegar os dados de performace ".rrd" e calcular a matriz, mas como não manjo muito de Python to apanhando um pouco, mas acredito que o segredo esta nesse script.

/usr/local/nagiosxi/html/includes/components/capacityplanning/backend/capacityplanning.py

Alguém poderia me ajudar a alterar esse script em Python para extrair no formato "Timestamp,valor" os dados de Observed e Predicted ?

ex: capacityplanning.py -H "localhost" -S "PING" -T "rta" -M "Holt-Winters" -P "30" --json-indent=3

#!/usr/bin/env python



import os

import optparse

import warnings

import logging

import rrddatastore

import forecast

import re

import datetime

import numpy as np



warnings.filterwarnings('ignore')



try:

    import json

except ImportError:

    import simplejson as json







logging.basicConfig(level=logging.DEBUG,

                    format='%(asctime)s %(levelname)-8s %(message)s',

                    datefmt='%a, %d %b %Y %H:%M:%S',

                    filename='/usr/local/nagiosxi/var/components/capacityplanning.log',

                    filemode='a')









def parse_period(period):

    try:

        period = int(period)

    except TypeError:

        period = 1

    except ValueError:

        WEEKS_IN_YEAR = 52

        WEEKS_IN_MONTH = 4



        period = str(period)

        result = re.search(r'.*([0-9]+)(.*)', period)

        if result:

            prefix = int(result.group(1))

            unit = result.group(2).strip().lower()

            if 'year' in unit:

                period = prefix * WEEKS_IN_YEAR

            elif 'month' in unit:

                period = prefix * WEEKS_IN_MONTH

            else:

                period = prefix

        else:

            period = 1

    return period





def parse_values(dtype, parser, values, message):

    if values is not None:

        try:

            return [dtype(x) for x in values.split(',')]

        except Exception, e:

            parser.error(message)

    else:

        return None









def parse_args():

    """Parse the input args of the script. """



    parser = optparse.OptionParser()







    datagroup = optparse.OptionGroup(parser, "Data Selection Options",

        "Use these to specify the host/service/track to report on.")



    datagroup.add_option("-D", "--dir", default="/usr/local/nagios/share/perfdata",

        help="Base directory to search for data files (default: %default).")

    datagroup.add_option("-H", "--host",

        help="Host name to run report for. *Required*")

    datagroup.add_option("-S", "--service",

        help="Service name to run report for. *Required*")

    datagroup.add_option("-T", "--track",

        help="Track name to run report for.")



    parser.add_option_group(datagroup)





    #capacityplanning.py -H "localhost" -S "PING" -T "rta" -M "Holt-Winters" -P "2" --json-indent=INDENT





    manipulation = optparse.OptionGroup(parser, "Extrapolation Options",

        "Use these to specify how the data will be extrapolated.")



    manipulation.add_option("-M", "--method", default="Holt-Winters",

        choices=['Holt-Winters', 'Linear Fit', 'Quadratic Fit', 'Cubic Fit'],

        help="Extrapolation method: Holt-Winters, Linear Fit, Quadratic Fit or Cubic Fit (default: %default).")

    manipulation.add_option("-E", "--end", default="now",

        help="End time of observed data to extrapolate from (default: %default).")

    manipulation.add_option("-P", "--period", default=1,

        help="Period of data to use as a basis for future data (default: %default).")

    manipulation.add_option("-s", "--steps", type="int", default=1,

        help="Number of periods to extrapolate out (default: %default).")



    parser.add_option_group(manipulation)







    reporting = optparse.OptionGroup(parser, "Reporting Options",

        "Use these to specify information to be reported.")



    reporting.add_option("--no-highcharts",

        dest="highcharts", action="store_false", default=True,

        help="Suppress outpout of Highcharts JSON data.")



    reporting.add_option("-j", "--json-indent", type="int", metavar="INDENT",

        help="Specify a JSON indent level for human-readable output.")

    reporting.add_option("-k", "--json-sort", action="store_true", default=False,

        help="Sort JSON keys for human-readable output.")

    reporting.add_option("-p", "--json-prettify", type="int", metavar="INDENT",

        help="Prettify JSON output, sorting the keys and using the specified indent level. This is equivalent to specifying: '--json-indent=INDENT --json-sort'.")



    reporting.add_option("-d", "--dates",

        help="Comma-delimited list of unix timestamps to get extrapolated values for. Output a list of date-string / value pairs.")

    reporting.add_option("-t", "--times",

        help="Comma-delimited list of unix timestamps to get extrapolated values for. Output a list of timestamp / value pairs.")



    reporting.add_option("--gt",

        help="Comma-delimited list of values to return times the extrapolation becomes greater than.")

    reporting.add_option("--ge",

        help="Comma-delimited list of values to return times the extrapolation becomes greater than or equal to.")

    reporting.add_option("--lt",

        help="Comma-delimited list of values to return times the extrapolation becomes less than.")

    reporting.add_option("--le",

        help="Comma-delimited list of values to return times the extrapolation becomes less than or equal to.")

    reporting.add_option("--eq",

        help="Comma-delimited list of values to return times the extrapolation becomes equal to.")



    reporting.add_option("-w", "--warn", action="store_true", default=False,

        help="Return the first time the extrapolation exceeds its track's warning value.")

    reporting.add_option("-c", "--crit", action="store_true", default=False,

        help="Return the first time the extrapolation exceeds its track's critical value.")



    parser.add_option_group(reporting)







    # Process the argv/argc command line.

    options, args = parser.parse_args()





    if not os.path.isdir(options.dir + '/.'):

        parser.error("'%s' is not an accessible directory." % options.dir)

    if not options.host:

        parser.error('Host is a required argument.')

    if not options.service:

        parser.error('Service is a required argument.')

    if not options.track:

        parser.error('Track is a required argument.')



    # Extract a sane period value.

    options.period = parse_period(options.period)



    logging.info("dir: %s, host: %s, service: %s, track: %s, method: %s, steps: %d, period: %d." % (options.dir, options.host, options.service, options.track, options.method, options.steps, options.period))



    if options.json_prettify is not None:

        options.json_indent = options.json_prettify

        options.json_sort = True



    # Convert comma-separated timestamps to lists.

    options.dates = parse_values(int, parser, options.dates,

        "Dates values must be unix timestamps.")

    options.times = parse_values(int, parser, options.times,

        "Times values must be unix timestamps.")



    # Convert comma-separated real (floating point) values to lists.

    options.gt = parse_values(float, parser, options.gt,

        "'Greater than' values must be numbers.")

    options.ge = parse_values(float, parser, options.ge,

        "'Greater than or equal' values must be numbers.")

    options.lt = parse_values(float, parser, options.lt,

        "'Less than' values must be numbers.")

    options.le = parse_values(float, parser, options.le,

        "'Less than or equal' values must be numbers.")

    options.eq = parse_values(float, parser, options.eq,

        "'Equal to' values must be numbers.")





    #logging.info(options)

    return options









def main():

    o = parse_args()



    datastore = rrddatastore.Datastore(o.dir, o.host, o.service, o.track)

    datastore.parse_rrd_file(o.period * 2, o.end)

    datastore.parse_xml_file()

    observed = datastore.dataset

    observed.set_period(o.period)





    if o.method == 'Holt-Winters':

        extrapolated, f, residues = forecast.holt_winters(observed, o.steps)

    elif o.method == 'Linear Fit':

        extrapolated, f, residues = forecast.linear_fit(observed, o.steps)

    elif o.method == 'Quadratic Fit':

        extrapolated, f, residues = forecast.quadratic_fit(observed, o.steps)

    elif o.method == 'Cubic Fit':

        extrapolated, f, residues = forecast.cubic_fit(observed, o.steps)







    # Our output information starts with the forecast and some statistics.

    info = forecast.make_projections(observed, extrapolated, f, residues)



    info['dmean'] = observed.get_mean()

    info['dmax']  = observed.get_max()

    info['emean'] = extrapolated.get_mean()

    info['emax']  = extrapolated.get_max()

    info['unit']      = observed.unit

    info['integrity'] = observed.get_integrity()



    info['t_start'] = observed.start

    info['t_step'] = observed.step

    info['t_stop'] = extrapolated.end







    # Add Highcharts data to the output if requested.

    if o.highcharts:

        info['highcharts'] = [observed.get_highcharts_dataset('Observed'),

                              extrapolated.get_highcharts_dataset('Predicted')]



        fit_params = (observed, observed.start, extrapolated.end, observed.step)



        fit = forecast.get_fitted_dataset(*(fit_params + (f,)))

        fit.label = 'Fit'

        fit_chart = fit.get_highcharts_dataset(fit.label, 'line')

        fit_chart['color'] = '#005656'

        fit_chart['zIndex'] = 1,



        info['highcharts'] += [fit_chart]







    # Process and add dates and times values to the output if present.

    if o.dates is not None:

        info['dates'] = [{'date': datetime.datetime.fromtimestamp(x).strftime('%c'),

                          'value': extrapolated.get_value_on_date(x)

                         } for x in o.dates]

    if o.times is not None:

        info['times'] = [{'time': x,

                          'value': extrapolated.get_value_on_date(x)

                         } for x in o.times]





    # Finally process any requested comparisons against the extrapolation.

    # We'll use a helper function to build a list of points that match values

    # passed to the list options.

    def process_comparison(method, values, key):

        if values is not None:

            info[key] = [time_value_dict(method, x) for x in values]



    # Another helper function that calls a method with a value to get a point

    # p, and then zips that point into a {'time':p[0], 'value':p[1]} dict.

    def time_value_dict(method, value):

        return dict(zip(('time', 'value'), method(value)))



    process_comparison(extrapolated.get_point_gt, o.gt, 'gt')

    process_comparison(extrapolated.get_point_ge, o.ge, 'ge')

    process_comparison(extrapolated.get_point_lt, o.lt, 'lt')

    process_comparison(extrapolated.get_point_le, o.le, 'le')

    process_comparison(extrapolated.get_point_eq, o.eq, 'eq')



    # Our warning and critical values are scalar and not output as arrays.

    if o.warn:

        info['warn'] = time_value_dict(extrapolated.get_point_ge, extrapolated.warn)

    if o.crit:

        info['crit'] = time_value_dict(extrapolated.get_point_ge, extrapolated.crit)



    logging.info("warn: %s, crit: %s" % (extrapolated.warn, extrapolated.crit))



    try:

        info['warn_level'] = float(extrapolated.warn)

        logging.info("warn: %s" % info['warn_level'])

    except Exception:

        pass



    try:

        info['crit_level'] = float(extrapolated.crit)

        logging.info("crit: %s" % info['crit_level'])

    except Exception:

        pass







    # ....ahhhnnnd we're finally done.

    print json.dumps(info, allow_nan=False, sort_keys=o.json_sort, indent=o.json_indent)

    #print json.dumps(info, allow_nan=False)







if __name__ == '__main__':

    try:

        main()

    except Exception, e:

        logging.exception(e)

        info = {

            'emax': None,

            'emean': None,

            'dmax': None,

            'dmean': None,

            'integrity': 0,

            'highcharts': [],

            'error': str(e),

        }

        print json.dumps(info, sort_keys=True)

 

---------------------------------------------------------------------------------------------

Output:
{
"emax": 0.086753530266276441,
"eslope": 3.9106800338371787e-15,
"evalue_max": 0.079700628533427936,
"t_start": 1488693600,
"warn_level": 100.0,
"dmean": 0.079239679388081879,
"t_stop": 1543147200,
"dmax": 0.094486518518518553,
"integrity": 0.0029744199881023281,
"unit": "ms",
"residue": 0.00052850205957779379,
"emean": 0.079162432183103912,
"edate": 1543125600,
"evalue": 0.079139750151537083,
"nd": 1680.0,
"ne": 840.0,
"evalue_min": 0.07857887176964623,
"adjusted_sigma": 0.18856731199170268,
"t_step": 21600,
"crit_level": 500.0,
"f_of_x_on_date": 0.079239821298840801,
"sigma": 0.00056087838189084827,
"highcharts": [
{
"pointStart": 1488693600000,
"pointInterval": 21600000,
"type": "area",
"name": "Observed",
"data": [
0.079239679388083739,
0.079239679388083739,
...
{
"pointStart": 1525003200000,
"pointInterval": 21600000,
"type": "area",
"name": "Predicted",
"data": [
0.079185020141343626,
...
{
"name": "Fit",
"pointStart": 1488693600000,
"data": [
0.079239608432705194,
0.079239608517175888,
...
"pointInterval": 21600000,
"zIndex": [
1
],
"color": "#005656",
"type": "line"
}