Example #1
0
    def __init__(self, pcp_fname, start=None, finish=None, interval=None):
        '''Opens a PCP archive and does an initial walk of the PMNS tree.
           start and finish must be in datetime format. Interval must be in
           seconds'''
        self.pcparchive = pcp_fname
        try:
            self.ctx = pmapi.pmContext(c_api.PM_CONTEXT_ARCHIVE, pcp_fname)
        except pmapi.pmErr as e:
            print("Error: {0}".format(e))
            sys.exit(-1)

        self.ctx.pmTraversePMNS('', self._pmns_callback)
        label = self.ctx.pmGetArchiveLabel()
        self.start = None
        self.finish = None
        self.interval = None
        if start:
            self.start = pmapi.timeval(sec=start)
        else:
            self.start = label.start

        if finish:
            self.finish = pmapi.timeval(sec=start)
        else:
            self.finish = self.ctx.pmGetArchiveEnd()

        if interval:
            self.interval = pmapi.timeval(sec=interval)
Example #2
0
    def get_stats(self, pcp):
        if len(self.metrics) <= 0:
            raise pmapi.pmErr
    
        list_type = type([])
        if self._timestamp.tv_sec == 0:
            first = True
        else:
            first = False

        try:
            metric_result = pcp.pmFetch(self.metric_pmids)
            self._timestamp = copy.deepcopy(metric_result.contents.timestamp)
        except pmapi.pmErr as e:
            self._timestamp = pmapi.timeval(0, 0)
            raise e

        # list of metric names
        for i in range(len(self.metrics)):
            # list of metric results, one per metric name
            for j in range(metric_result.contents.numpmid):
                if (metric_result.contents.get_pmid(j) != self.metric_pmids[i]):
                    continue
                atomlist = []
                # list of instances, one or more per metric.  e.g. there are many 
                # instances for network metrics, one per network interface
                for k in range(metric_result.contents.get_numval(j)):
                    atom = pcp.pmExtractValue(metric_result.contents.get_valfmt(j), metric_result.contents.get_vlist(j, k), self.metric_descs[j].type, self.metric_descs[j].type)
                    atomlist.append(atom)

                value = []
                # metric may require a diff to get a per interval value
                for k in range(metric_result.contents.get_numval(j)):
                    if type(self._last_values[j]) == list_type:
                        try:
                            lastval = self._last_values[j][k]
                        except IndexError:
                            lastval = None
                    else:
                        lastval = self._last_values[j]
                    if first:
                        want_diff = False
                    elif self.metrics[j] in self.diff_metrics:
                        want_diff = True
                    elif (self.metric_descs[j].sem == c_api.PM_SEM_DISCRETE
                          or self.metric_descs[j].sem == c_api.PM_SEM_INSTANT) :
                        want_diff = False
                    else:
                        want_diff = True
                    value.append(self.get_atom_value(atomlist[k], lastval, self.metric_descs[j], want_diff))

                self._last_values[j] = copy.copy(atomlist)
                if metric_result.contents.get_numval(j) == 1:
                    if len(value) == 1:
                        self.metric_values[j] = copy.copy(value[0])
                    else:
                        self.metric_values[j] = 0
                elif metric_result.contents.get_numval(j) > 1:
                    self.metric_values[j] = copy.copy(value)
        pcp.pmFreeResult(metric_result)
Example #3
0
    def get_stats(self, pcp):
        if len(self.metrics) <= 0:
            raise pmErr
    
        list_type = type([])
        if self._timestamp.tv_sec == 0:
            first = True
        else:
            first = False

        try:
            metric_result = pcp.pmFetch(self.metric_pmids)
            self._timestamp = copy.deepcopy(metric_result.contents.timestamp)
        except pmErr as e:
            self._timestamp = timeval(0, 0)
            raise e

        # list of metric names
        for i in range(len(self.metrics)):
            # list of metric results, one per metric name
            for j in range(metric_result.contents.numpmid):
                if (metric_result.contents.get_pmid(j) != self.metric_pmids[i]):
                    continue
                atomlist = []
                # list of instances, one or more per metric.  e.g. there are many 
                # instances for network metrics, one per network interface
                for k in range(metric_result.contents.get_numval(j)):
                    atom = pcp.pmExtractValue(metric_result.contents.get_valfmt(j), metric_result.contents.get_vlist(j, k), self.metric_descs[j].type, self.metric_descs[j].type)
                    atomlist.append(atom)

                value = []
                # metric may require a diff to get a per interval value
                for k in range(metric_result.contents.get_numval(j)):
                    if type(self._last_values[j]) == list_type:
                        try:
                            lastval = self._last_values[j][k]
                        except IndexError:
                            lastval = None
                    else:
                        lastval = self._last_values[j]
                    if first:
                        want_diff = False
                    elif self.metrics[j] in self.diff_metrics:
                        want_diff = True
                    elif (self.metric_descs[j].sem == c_api.PM_SEM_DISCRETE
                          or self.metric_descs[j].sem == c_api.PM_SEM_INSTANT) :
                        want_diff = False
                    else:
                        want_diff = True
                    value.append(self.get_atom_value(atomlist[k], lastval, self.metric_descs[j], want_diff))

                self._last_values[j] = copy.copy(atomlist)
                if metric_result.contents.get_numval(j) == 1:
                    if len(value) == 1:
                        self.metric_values[j] = copy.copy(value[0])
                    else:
                        self.metric_values[j] = 0
                elif metric_result.contents.get_numval(j) > 1:
                    self.metric_values[j] = copy.copy(value)
        pcp.pmFreeResult(metric_result)
Example #4
0
    def finalize_options(self):
        """ Finalize util options """
        # Runtime overrides samples/interval
        if self.util.opts.pmGetOptionFinishOptarg():
            origin = float(self.util.opts.pmGetOptionOrigin(
            )) if self.util.opts.pmGetOptionOrigin() is not None else 0
            self.util.runtime = float(
                self.util.opts.pmGetOptionFinish()) - origin
            if self.util.opts.pmGetOptionSamples():
                self.util.samples = self.util.opts.pmGetOptionSamples()
                if self.util.samples < 2:
                    self.util.samples = 2
                self.util.interval = float(
                    self.util.runtime) / (self.util.samples - 1)
                self.util.opts.pmSetOptionInterval(str(self.util.interval))
                self.util.interval = self.util.opts.pmGetOptionInterval()
            else:
                self.util.interval = self.util.opts.pmGetOptionInterval()
                if not self.util.interval:
                    self.util.interval = pmapi.timeval(0)
                try:
                    self.util.samples = int(self.util.runtime /
                                            float(self.util.interval) + 1)
                except Exception:
                    pass
        else:
            self.util.samples = self.util.opts.pmGetOptionSamples()
            self.util.interval = self.util.opts.pmGetOptionInterval()

        if float(self.util.interval) <= 0:
            sys.stderr.write("Interval must be greater than zero.\n")
            sys.exit(1)
Example #5
0
    def __init__(self):
        """ Construct object, prepare for command line handling """
        self.context = None
        self.daemonize = 0
        self.pmconfig = pmconfig.pmConfig(self)
        self.opts = self.options()

        # Configuration directives
        self.keys = ('source', 'output', 'derived', 'header', 'globals',
                     'samples', 'interval', 'type', 'precision', 'daemonize',
                     'es_server', 'es_index', 'es_hostid', 'count_scale',
                     'space_scale', 'time_scale', 'version', 'speclocal',
                     'instances', 'ignore_incompat', 'omit_flat')

        # The order of preference for options (as present):
        # 1 - command line options
        # 2 - options from configuration file(s)
        # 3 - built-in defaults defined below
        self.check = 0
        self.version = CONFVER
        self.source = "local:"
        self.output = None  # For pmrep conf file compat only
        self.speclocal = None
        self.derived = None
        self.header = 1
        self.globals = 1
        self.samples = None  # forever
        self.interval = pmapi.timeval(60)  # 60 sec
        self.opts.pmSetOptionInterval(str(60))  # 60 sec
        self.delay = 0
        self.type = 0
        self.ignore_incompat = 0
        self.instances = []
        self.omit_flat = 0
        self.precision = 3  # .3f
        self.timefmt = "%H:%M:%S"  # For compat only
        self.interpol = 0
        self.count_scale = None
        self.space_scale = None
        self.time_scale = None

        self.es_server = ES_SERVER
        self.es_index = ES_INDEX
        self.es_hostid = None

        # Internal
        self.runtime = -1

        # Performance metrics store
        # key - metric name
        # values - 0:label, 1:instance(s), 2:unit/scale, 3:type, 4:width, 5:pmfg item
        self.metrics = OrderedDict()
        self.pmfg = None
        self.pmfg_ts = None

        # Read configuration and prepare to connect
        self.config = self.pmconfig.set_config_file(DEFAULT_CONFIG)
        self.pmconfig.read_options()
        self.pmconfig.read_cmd_line()
        self.pmconfig.prepare_metrics()
Example #6
0
 def __init__(self, typed = PM_CONTEXT_HOST, target = "local:"):
     dict.__init__(self)
     MetricCache.__init__(self, typed, target)
     self._options = None
     self._default_delta = timeval(1, 0)
     self._default_pause = None
     self._printer = None
     self._counter = 0
Example #7
0
 def __init__(self, typed=PM_CONTEXT_HOST, target="local:"):
     dict.__init__(self)
     MetricCache.__init__(self, typed, target)
     self._options = None
     self._default_delta = timeval(1, 0)
     self._default_pause = None
     self._printer = None
     self._counter = 0
Example #8
0
 def __init__(self):
     self.metrics = []
     self._timestamp = timeval(0, 0)
     self.diff_metrics = []
     self.metric_pmids = []
     self.metric_descs = []
     self.metric_values = []
     self.metrics_dict = {}
     self._last_values = []
Example #9
0
 def __init__(self):
     self.metrics = []
     self._timestamp = timeval(0, 0)
     self.diff_metrics = []
     self.metric_pmids = []
     self.metric_descs = []
     self.metric_values = []
     self.metrics_dict = {}
     self._last_values = []
Example #10
0
 def __init__(self):
     """ Construct object - prepare for command line handling """
     self.count = 0       # number of samples to report
     self.pause = None    # time interval to pause between samples
     self.shift = 10      # bitshift conversion between B/KB/MB/GB
     self.show_high = 0
     self.show_total = 0
     self.show_compat = 0
     self.opts = self.options()
     self.interval = pmapi.timeval()
     self.context = None
Example #11
0
 def __init__(self):
     """ Construct object - prepare for command line handling """
     self.count = 0  # number of samples to report
     self.pause = None  # time interval to pause between samples
     self.shift = 10  # bitshift conversion between B/KB/MB/GB
     self.show_high = 0
     self.show_total = 0
     self.show_compat = 0
     self.opts = self.options()
     self.interval = pmapi.timeval()
     self.context = None
Example #12
0
 def _computePauseTime(self):
     """ Figure out how long to sleep between samples.
         This needs to take into account whether we were explicitly
         asked for a delay (independent of context type, --pause),
         whether this is an archive or live context, and the sampling
         --interval (including the default value, if none requested).
     """
     if self._default_pause != None:
         return self._default_pause
     if self.type == PM_CONTEXT_ARCHIVE:
         self._default_pause = timeval(0, 0)
     elif self._options != None:
         pause = self._options.pmGetOptionInterval()
         if pause != None:
             self._default_pause = pause
         else:
             self._default_pause = self._default_delta
     else:
         self._default_pause = self._default_delta
     return self._default_pause
Example #13
0
 def _computePauseTime(self):
     """ Figure out how long to sleep between samples.
         This needs to take into account whether we were explicitly
         asked for a delay (independent of context type, --pause),
         whether this is an archive or live context, and the sampling
         --interval (including the default value, if none requested).
     """
     if self._default_pause != None:
         return self._default_pause
     if self.type == PM_CONTEXT_ARCHIVE:
         self._default_pause = timeval(0, 0)
     elif self._options != None:
         pause = self._options.pmGetOptionInterval()
         if pause != None:
             self._default_pause = pause
         else:
             self._default_pause = self._default_delta
     else:
         self._default_pause = self._default_delta
     return self._default_pause
Example #14
0
    def prepare_output(self, operands):
        """ Complete all initialisation and get ready to begin sampling """
        if not operands:
            operands = []
        if len(operands) > 0:
            self.delay = float(operands[0])
        if len(operands) > 1:
            self.samples = int(operands[1])
        if len(operands) > 2:
            sys.stderr.write("Incorrect argument list, try --help\n")
            sys.exit(1)

        if not self.update:
            self.interval = pmapi.timeval(self.delay)

        self.pmconfig.set_signal_handler()
        self.term.set_title(self.arguments)
        self.term.set_theme(self.blackonwhite)
        if self.color == None:
            self.color = self.term.get_color()

        ### Empty ansi and theme databases when colors not in use
        if not self.color:
            for key in COLOR:
                COLOR[key] = ''
            for key in THEME:
                THEME[key] = ''
            for key in ANSI:
                ANSI[key] = ''
            THEME['colors_hi'] = (ANSI['default'],)
            THEME['colors_lo'] = (ANSI['default'],)

        ### Disable line-wrapping
        sys.stdout.write(ANSI['nolinewrap'])

        ### Create pidfile
        if self.pidfile:
           self.create_pidfile()
Example #15
0
 def builder(build, options, argv):
     """ Helper interface, simple PCP monitor argument parsing. """
     manager = build.fromOptions(options, argv)
     manager._default_delta = timeval(options.delta, 0)
     manager._options = options
     return manager
Example #16
0
    def __init__(self):
        """ Construct object, parse command line """
        self.context = None
        self.database = 'pcp'
        self.influxdb_tags = ''
        self.influxdb_address = 'http://127.0.0.1:8086'
        self.influxdb_user = None
        self.influxdb_pass = None
        self.sample_count = 0
        self.unitsstr = None
        self.units = None
        self.units_mult = None

        # option setup
        self.opts = pmapi.pmOptions()
        self.opts.pmSetShortOptions("a:O:s:T:g:p:P:r:m:t:u:h:t:D:LV?")
        self.opts.pmSetShortUsage("[options] metricname ...")
        self.opts.pmSetLongOptionText("""
Description: Periodically, relay raw values of all instances of a
given hierarchies of PCP metrics to an InfluxDB server on the network.""")
        self.opts.pmSetLongOptionHeader("Options")
        self.opts.pmSetOptionCallback(self.option)

        # common options
        self.opts.pmSetLongOptionVersion()
        self.opts.pmSetLongOptionArchive()
        self.opts.pmSetLongOptionOrigin()
        self.opts.pmSetLongOptionSamples()
        self.opts.pmSetLongOptionFinish()
        self.opts.pmSetLongOptionDebug()
        self.opts.pmSetLongOptionHost()
        self.opts.pmSetLongOptionLocalPMDA()
        self.opts.pmSetLongOptionInterval()

        # custom options
        self.opts.pmSetLongOption(
            "influxdb-address", 1, 'i', '', "InfluxDB HTTP/HTTPS address " +
            "(default \"" + self.influxdb_address + "\")")
        self.opts.pmSetLongOption(
            "units", 1, 'u', '',
            "rescale units " + "(e.g. \"MB\", will omit incompatible units)")
        self.opts.pmSetLongOption("database", 1, 'd', '',
                                  "database for metric (default \"pcp\")")
        self.opts.pmSetLongOption("db-user", 1, 'U', '',
                                  "username for InfluxDB database")
        self.opts.pmSetLongOption("db-password", 1, 'P', '',
                                  "password for InfluxDB database")
        self.opts.pmSetLongOption("tag-string", 1, 'I', '',
                                  "string of tags to add to the metrics")
        self.opts.pmSetLongOptionHelp()

        # parse options
        self.context = pmapi.pmContext.fromOptions(self.opts, sys.argv)
        self.interval = self.opts.pmGetOptionInterval() or pmapi.timeval(60, 0)
        if self.unitsstr is not None:
            units = self.context.pmParseUnitsStr(self.unitsstr)
            (self.units, self.units_mult) = units
        self.metrics = []
        self.pmids = []
        self.descs = []
        metrics = self.opts.pmGetNonOptionsFromList(sys.argv)
        if metrics:
            for m in metrics:
                try:
                    self.context.pmTraversePMNS(m,
                                                self.handle_candidate_metric)
                except pmapi.pmErr as error:
                    sys.stderr.write("Excluding metric %s (%s)\n" %
                                     (m, str(error)))

            sys.stderr.flush()

        if len(self.metrics) == 0:
            sys.stderr.write("No acceptable metrics specified.\n")
            raise pmapi.pmUsageErr()

        # Report what we're about to do
        print("Relaying %d %smetric(s) to database %s with tags %s from %s "
              "to %s every %f s" %
              (len(self.metrics), "rescaled " if self.units else "",
               self.database, self.influxdb_tags, self.describe_source(),
               self.influxdb_address, self.interval))

        sys.stdout.flush()
Example #17
0
    def __init__(self):
        """ Construct object, parse command line """
        self.context = None
        self.opts = pmapi.pmOptions()
        self.opts.pmSetShortOptions("g:p:P:u:m:t:h:Lt:D:V?") # must include common options
        self.opts.pmSetShortUsage("[options] metricname ...")
        self.opts.pmSetOptionCallback(self.option)
        self.opts.pmSetOverrideCallback(self.option_override)
        # hack to include some explanatory text
        self.opts.pmSetLongOptionHeader("""
Description: Periodically, relay raw values of all instances of a
given hierarchies of PCP metrics to a graphite/carbon server on the
network.

Options""")
        self.opts.pmSetLongOptionVersion() # -V
        # self.opts.pmSetLongOptionArchive() # -a FILE   -- not supported yet; need -S/etc. controls
        self.opts.pmSetLongOptionDebug() # -D stuff
        self.opts.pmSetLongOptionHost() # -h HOST
        # self.opts.pmSetLongOptionLocalPMDA() # -L
        self.opts.pmSetLongOptionInterval() # -t NUMBER
        self.opts.pmSetLongOption("graphite-host", 1, 'g', '', "graphite server host (default \"localhost\")")
        self.opts.pmSetLongOption("pickled-port", 1, 'p', '', "graphite pickled port (default 2004)")
        self.opts.pmSetLongOption("text-port", 1, 'P', '', "graphite plaintext port (usually 2003)")
        self.opts.pmSetLongOption("units", 1, 'u', '', "rescale all metric units (e.g., \"mbytes/5 sec\")")
        self.opts.pmSetLongOption("prefix", 1, 'm', '', "prefix for metric names (default \"pcp.\")")
        self.opts.pmSetLongOptionHelp()
        self.graphite_host = "localhost"
        self.graphite_port = 2004
        self.pickle = True
        self.prefix = "pcp."
        self.unitsstr = None
        self.units = None # pass verbatim by default
        self.units_mult = None # pass verbatim by default

        # now actually parse
        self.context = pmapi.pmContext.fromOptions(self.opts, sys.argv)
        self.interval = self.opts.pmGetOptionInterval() or pmapi.timeval(60,0)

        if self.unitsstr is not None:
            (self.units, self.units_mult) = self.context.pmParseUnitsStr(self.unitsstr)
        self.metrics = []
        self.pmids = []
        self.descs = []
        metrics = self.opts.pmNonOptionsFromList(sys.argv)
        if metrics:
            for m in metrics:
                try:
                    self.context.pmTraversePMNS(m, self.handle_candidate_metric)
                except pmapi.pmErr as error:
                    sys.stderr.write("Excluding metric %s (%s)\n" % (m, str(error)))
            sys.stderr.flush()

        if len(self.metrics) == 0:
            sys.stderr.write("No acceptable metrics specified.\n")
            raise pmapi.pmUsageErr()

        # Report what we're about to do
        print("Relaying %d %smetric(s) with prefix %s "
              "in %s mode to %s:%d every %f s" % (
                len(self.metrics),
                "rescaled " if self.units else "",
                self.prefix,
                "pickled" if self.pickle else "text",
                self.graphite_host, self.graphite_port,
                self.interval))
        sys.stdout.flush()
Example #18
0
    def __init__(self):
        """ Construct object, prepare for command line handling """
        self.context = None
        self.daemonize = 0
        self.pmconfig = pmconfig.pmConfig(self)
        self.opts = self.options()

        # Configuration directives
        self.keys = ('source', 'output', 'derived', 'header', 'globals',
                     'samples', 'interval', 'type', 'precision', 'daemonize',
                     'graphite_host', 'graphite_port', 'pickle', 'pickle_protocol', 'prefix',
                     'count_scale', 'space_scale', 'time_scale', 'version',
                     'count_scale_force', 'space_scale_force', 'time_scale_force',
                     'type_prefer', 'precision_force', 'limit_filter', 'limit_filter_force',
                     'live_filter', 'rank', 'invert_filter', 'predicate', 'names_change',
                     'speclocal', 'instances', 'ignore_incompat', 'ignore_unknown',
                     'omit_flat')

        # The order of preference for options (as present):
        # 1 - command line options
        # 2 - options from configuration file(s)
        # 3 - built-in defaults defined below
        self.check = 0
        self.version = CONFVER
        self.source = "local:"
        self.output = None # For pmrep conf file compat only
        self.speclocal = None
        self.derived = None
        self.header = 1
        self.globals = 1
        self.samples = None # forever
        self.interval = pmapi.timeval(60)      # 60 sec
        self.opts.pmSetOptionInterval(str(60)) # 60 sec
        self.delay = 0
        self.type = 0
        self.type_prefer = self.type
        self.ignore_incompat = 0
        self.ignore_unknown = 0
        self.names_change = 0 # ignore
        self.instances = []
        self.live_filter = 0
        self.rank = 0
        self.limit_filter = 0
        self.limit_filter_force = 0
        self.invert_filter = 0
        self.predicate = None
        self.omit_flat = 0
        self.precision = 3 # .3f
        self.precision_force = None
        self.timefmt = "%c"
        self.interpol = 0
        self.count_scale = None
        self.count_scale_force = None
        self.space_scale = None
        self.space_scale_force = None
        self.time_scale = None
        self.time_scale_force = None

        self.graphite_host = SERVER
        self.graphite_port = PORT
        self.pickle = 1
        self.pickle_protocol = 0
        self.prefix = PREFIX

        # Internal
        self.runtime = -1
        self.socket = None

        # Performance metrics store
        # key - metric name
        # values - 0:txt label, 1:instance(s), 2:unit/scale, 3:type,
        #          4:width, 5:pmfg item, 6:precision, 7:limit
        self.metrics = OrderedDict()
        self.pmfg = None
        self.pmfg_ts = None

        # Read configuration and prepare to connect
        self.config = self.pmconfig.set_config_file(DEFAULT_CONFIG)
        self.pmconfig.read_options()
        self.pmconfig.read_cmd_line()
        self.pmconfig.prepare_metrics()
        self.pmconfig.set_signal_handler()
Example #19
0
    def __init__(self):
        """ Construct object, parse command line """
        self.context = None
        self.socket = None
        self.sample_count = 0
        self.opts = pmapi.pmOptions()
        self.opts.pmSetShortOptions("a:O:s:T:g:p:P:r:u:m:t:h:t:D:LV?")
        self.opts.pmSetShortUsage("[options] metricname ...")
        self.opts.pmSetOptionCallback(self.option)
        self.opts.pmSetOverrideCallback(self.option_override)
        self.opts.pmSetLongOptionText("""
Description: Periodically, relay raw values of all instances of a
given hierarchies of PCP metrics to a graphite/carbon server on the
network.""")
        self.opts.pmSetLongOptionHeader("Options")
        self.opts.pmSetLongOptionVersion() # -V
        self.opts.pmSetLongOptionArchive() # -a FILE
        self.opts.pmSetLongOptionOrigin() # -O TIME
        self.opts.pmSetLongOptionSamples() # -s NUMBER
        self.opts.pmSetLongOptionFinish() # -T NUMBER
        self.opts.pmSetLongOptionDebug() # -D stuff
        self.opts.pmSetLongOptionHost() # -h HOST
        self.opts.pmSetLongOptionLocalPMDA() # -L
        self.opts.pmSetLongOptionInterval() # -t NUMBER
        self.opts.pmSetLongOption("graphite-host", 1, 'g', '',
                                  "graphite server host " +
                                  "(default \"localhost\")")
        self.opts.pmSetLongOption("pickled-port", 1, 'p', '',
                                  "graphite pickled port (default 2004)")
        self.opts.pmSetLongOption("text-port", 1, 'P', '',
                                  "graphite plaintext port (usually 2003)")
        self.opts.pmSetLongOption("units", 1, 'u', '',
                                  "rescale units " +
                                  "(e.g. \"MB\", will omit incompatible units)")
        self.opts.pmSetLongOption("prefix", 1, 'm', '',
                                  "prefix for metric names (default \"pcp.\")")
        self.opts.pmSetLongOption("pickle-protocol", 1, 'r', 'PROTOCOL',
                                  "graphite pickle protocol (default 0)")
        self.opts.pmSetLongOptionHelp()
        self.graphite_host = "localhost"
        self.graphite_port = 2004
        self.pickle = True
        self.pickle_protocol = 0
        self.prefix = "pcp."
        self.unitsstr = None
        self.units = None # pass verbatim by default
        self.units_mult = None # pass verbatim by default

        # now actually parse
        self.context = pmapi.pmContext.fromOptions(self.opts, sys.argv)
        self.interval = self.opts.pmGetOptionInterval() or pmapi.timeval(60, 0)
        if self.unitsstr is not None:
            units = self.context.pmParseUnitsStr(self.unitsstr)
            (self.units, self.units_mult) = units
        self.metrics = []
        self.pmids = []
        self.descs = []
        metrics = self.opts.pmGetNonOptionsFromList(sys.argv)
        if metrics:
            for m in metrics:
                try:
                    self.context.pmTraversePMNS(m, self.handle_candidate_metric)
                except pmapi.pmErr as error:
                    sys.stderr.write("Excluding metric %s (%s)\n" %
                                     (m, str(error)))
            sys.stderr.flush()

        if len(self.metrics) == 0:
            sys.stderr.write("No acceptable metrics specified.\n")
            raise pmapi.pmUsageErr()

        # Report what we're about to do
        print("Relaying %d %smetric(s) with prefix %s from %s "
              "in %s mode to %s:%d every %f s" %
              (len(self.metrics),
               "rescaled " if self.units else "",
               self.prefix,
               self.describe_source(),
               "pickled" if self.pickle else "text",
               self.graphite_host, self.graphite_port,
               self.interval))
        sys.stdout.flush()
Example #20
0
    def __init__(self):
        """ Construct object, parse command line """
        self.context = None
        self.socket = None
        self.sample_count = 0
        self.opts = pmapi.pmOptions()
        self.opts.pmSetShortOptions("a:O:s:T:g:p:P:r:u:m:t:h:t:D:LV?")
        self.opts.pmSetShortUsage("[options] metricname ...")
        self.opts.pmSetOptionCallback(self.option)
        self.opts.pmSetOverrideCallback(self.option_override)
        self.opts.pmSetLongOptionText("""
Description: Periodically, relay raw values of all instances of a
given hierarchies of PCP metrics to a graphite/carbon server on the
network.""")
        self.opts.pmSetLongOptionHeader("Options")
        self.opts.pmSetLongOptionVersion()  # -V
        self.opts.pmSetLongOptionArchive()  # -a FILE
        self.opts.pmSetLongOptionOrigin()  # -O TIME
        self.opts.pmSetLongOptionSamples()  # -s NUMBER
        self.opts.pmSetLongOptionFinish()  # -T NUMBER
        self.opts.pmSetLongOptionDebug()  # -D stuff
        self.opts.pmSetLongOptionHost()  # -h HOST
        self.opts.pmSetLongOptionLocalPMDA()  # -L
        self.opts.pmSetLongOptionInterval()  # -t NUMBER
        self.opts.pmSetLongOption(
            "graphite-host", 1, 'g', '',
            "graphite server host " + "(default \"localhost\")")
        self.opts.pmSetLongOption("pickled-port", 1, 'p', '',
                                  "graphite pickled port (default 2004)")
        self.opts.pmSetLongOption("text-port", 1, 'P', '',
                                  "graphite plaintext port (usually 2003)")
        self.opts.pmSetLongOption(
            "units", 1, 'u', '',
            "rescale units " + "(e.g. \"MB\", will omit incompatible units)")
        self.opts.pmSetLongOption(
            "prefix", 1, 'm', '', "prefix for metric names (default \"pcp.\")")
        self.opts.pmSetLongOption("pickle-protocol", 1, 'r', 'PROTOCOL',
                                  "graphite pickle protocol (default 0)")
        self.opts.pmSetLongOptionHelp()
        self.graphite_host = "localhost"
        self.graphite_port = 2004
        self.pickle = True
        self.pickle_protocol = 0
        self.prefix = "pcp."
        self.unitsstr = None
        self.units = None  # pass verbatim by default
        self.units_mult = None  # pass verbatim by default

        # now actually parse
        self.context = pmapi.pmContext.fromOptions(self.opts, sys.argv)
        self.interval = self.opts.pmGetOptionInterval() or pmapi.timeval(60, 0)
        if self.unitsstr is not None:
            units = self.context.pmParseUnitsStr(self.unitsstr)
            (self.units, self.units_mult) = units
        self.metrics = []
        self.pmids = []
        self.descs = []
        metrics = self.opts.pmGetNonOptionsFromList(sys.argv)
        if metrics:
            for m in metrics:
                try:
                    self.context.pmTraversePMNS(m,
                                                self.handle_candidate_metric)
                except pmapi.pmErr as error:
                    sys.stderr.write("Excluding metric %s (%s)\n" %
                                     (m, str(error)))
            sys.stderr.flush()

        if len(self.metrics) == 0:
            sys.stderr.write("No acceptable metrics specified.\n")
            raise pmapi.pmUsageErr()

        # Report what we're about to do
        print(
            "Relaying %d %smetric(s) with prefix %s from %s "
            "in %s mode to %s:%d every %f s" %
            (len(self.metrics), "rescaled " if self.units else "", self.prefix,
             self.describe_source(), "pickled" if self.pickle else "text",
             self.graphite_host, self.graphite_port, self.interval))
        sys.stdout.flush()
Example #21
0
File: pmatop.py Project: Aconex/pcp
def main(stdscr_p):
    global stdscr
    stdscr = _StandardOutput(stdscr_p)
    sort = ""
    duration = 0.0
    i = 1

    ss = Subsystem()
    ss.init_processor_metrics()
    ss.init_memory_metrics()
    ss.init_disk_metrics()
    ss.init_network_metrics()
    ss.init_process_metrics()

    cpu = _ProcessorPrint(ss, stdscr)
    mem = _MemoryPrint(ss, stdscr)
    disk = _DiskPrint(ss, stdscr)
    net = _NetPrint(ss, stdscr)
    proc = _ProcPrint(ss, stdscr)

    proc.output_type = opts.output_type
    stdscr.width = opts.width

    pmc = pmapi.pmContext.fromOptions(opts.opts, sys.argv)
    if pmc.type == c_api.PM_CONTEXT_ARCHIVE:
        pmc.pmSetMode(c_api.PM_MODE_FORW, pmapi.timeval(0, 0), 0)


    host = pmc.pmGetContextHostName()

    (delta, errmsg) = pmc.pmParseInterval(str(opts.interval_arg) + " seconds")

    ss.setup_metrics(pmc)

    if opts.create_archive:
        delta_seconds = c_api.pmtimevalToReal(delta.tv_sec, delta.tv_usec)
        msec = str(int(1000.0 * delta_seconds))
        configuration = "log mandatory on every " + msec + " milliseconds { "
        configuration += ss.dump_metrics()
        configuration += "}"
        if opts.n_samples != 0:
            duration = float(opts.n_samples) * delta_seconds
        else:
            duration = float(10) * delta_seconds
        status = record(pmgui.GuiClient(), configuration, duration, opts.output_file, host)
        if status != "":
            return status
        record_add_creator(opts.output_file)
        sys.exit(0)

    i_samples = 0

    disk.interval = delta.tv_sec
    disk.replay_archive = opts.replay_archive

    try:
        elapsed = ss.get_metric_value('kernel.all.uptime')
        while (i_samples < opts.n_samples) or (opts.n_samples == 0):
            ss.get_stats(pmc)
            stdscr.move(0, 0)
            stdscr.addstr('ATOP - %s\t\t%s elapsed\n\n' % (
                    time.strftime("%c"),
                    datetime.timedelta(0, elapsed)))
            elapsed = delta.tv_sec
            stdscr.move(2, 0)

            try:
                cpu.prc()
                cpu.cpu()
                mem.mem()
                disk.disk(pmc)
                net.net(pmc)
                proc.set_line()
                proc.proc()
            except pmapi.pmErr as e:
                return str(e) + " while processing " + str(ssx[0])
            except Exception as e: # catch all errors, pcp or python or other
                pass
            stdscr.move(proc.command_line, 0)
            stdscr.refresh()

            stdscr.timeout(delta.tv_sec * 1000)
            char = stdscr.getch()

            if char != -1:       # user typed a command
                try:
                    cmd = chr(char)
                except ValueError:
                    cmd = None
                if cmd == "q":
                    raise KeyboardInterrupt
                elif cmd == "":
Example #22
0
 def builder(build, options, argv):
     """ Helper interface, simple PCP monitor argument parsing. """
     manager = build.fromOptions(options, argv)
     manager._default_delta = timeval(options.delta, 0)
     manager._options = options
     return manager
Example #23
0
    def __init__(self):
        """ Construct object, parse command line """
        self.opts = pmapi.pmOptions()
        self.opts.pmSetShortOptions("a:O:s:T:g:i:u:m:t:h:t:D:LV?")
        self.opts.pmSetShortUsage("[options] metricname ...")
        self.opts.pmSetOptionCallback(self.option)
        self.opts.pmSetOverrideCallback(self.option_override)
        self.opts.pmSetLongOptionText("""
Description: Periodically, relay raw values of all instances of a
given hierarchies of PCP metrics to a elasticsearch/carbon server on the
network.""")
        self.opts.pmSetLongOptionHeader("Options")
        self.opts.pmSetLongOptionVersion()  # -V
        self.opts.pmSetLongOptionArchive()  # -a FILE
        self.opts.pmSetLongOptionOrigin()  # -O TIME
        self.opts.pmSetLongOptionSamples()  # -s NUMBER
        self.opts.pmSetLongOptionFinish()  # -T NUMBER
        self.opts.pmSetLongOptionDebug()  # -D stuff
        self.opts.pmSetLongOptionHost()  # -h HOST
        self.opts.pmSetLongOptionLocalPMDA()  # -L
        self.opts.pmSetLongOptionInterval()  # -t NUMBER
        self.opts.pmSetLongOption(
            "elasticsearch-host", 1, 'g', '', "elasticsearch server host " +
            "(default \"http://*****:*****@timestamp': {
                                                   'type': 'date'
                                               },
                                               'host-id': {
                                                   'type': 'string'
                                               }
                                           }
                                       }
                                   }
                               })

        # Report what we're about to do
        print("Relaying %d %smetric(s) with es_index %s from %s "
              "to %s every %f s" %
              (len(self.metrics),
               "rescaled " if self.units else "", self.es_index,
               self.describe_source(), self.elasticsearch_host, self.interval))
        sys.stdout.flush()
Example #24
0
    def __init__(self):
        """ Construct object, prepare for command line handling """
        self.context = None
        self.daemonize = 0
        self.pmconfig = pmconfig.pmConfig(self)
        self.opts = self.options()

        # Configuration directives
        self.keys = ('source', 'output', 'derived', 'header', 'globals',
                     'samples', 'interval', 'type', 'precision', 'daemonize',
                     'timestamp', 'unitinfo', 'colxrow', 'delay', 'width',
                     'delimiter', 'extcsv', 'extheader', 'repeat_header',
                     'timefmt', 'interpol', 'count_scale', 'space_scale',
                     'time_scale', 'version', 'speclocal', 'instances',
                     'ignore_incompat', 'omit_flat')

        # The order of preference for options (as present):
        # 1 - command line options
        # 2 - options from configuration file(s)
        # 3 - built-in defaults defined below
        self.check = 0
        self.version = CONFVER
        self.source = "local:"
        self.output = OUTPUT_STDOUT
        self.speclocal = None
        self.derived = None
        self.header = 1
        self.unitinfo = 1
        self.globals = 1
        self.timestamp = 0
        self.samples = None  # forever
        self.interval = pmapi.timeval(1)  # 1 sec
        self.opts.pmSetOptionInterval(str(1))  # 1 sec
        self.delay = 0
        self.type = 0
        self.ignore_incompat = 0
        self.instances = []
        self.omit_flat = 0
        self.colxrow = None
        self.width = 0
        self.precision = 3  # .3f
        self.delimiter = None
        self.extcsv = 0
        self.extheader = 0
        self.repeat_header = 0
        self.timefmt = None
        self.interpol = 1
        self.count_scale = None
        self.space_scale = None
        self.time_scale = None

        # Not in pmrep.conf, won't overwrite
        self.outfile = None

        # Internal
        self.format = None  # stdout format
        self.writer = None
        self.pmi = None
        self.localtz = None
        self.prev_ts = None
        self.runtime = -1
        self.found_insts = []

        # Performance metrics store
        # key - metric name
        # values - 0:label, 1:instance(s), 2:unit/scale, 3:type, 4:width, 5:pmfg item
        self.metrics = OrderedDict()
        self.pmfg = None
        self.pmfg_ts = None

        # Read configuration and prepare to connect
        self.config = self.pmconfig.set_config_file(DEFAULT_CONFIG)
        self.pmconfig.read_options()
        self.pmconfig.read_cmd_line()
        self.pmconfig.prepare_metrics()
        self.pmconfig.set_signal_handler()
Example #25
0
        sys.exit(1)

    # Setup some default reporting if none specified so far
    if len(subsys) == 0:
        subsys.append(cpu)
        subsys.append(disk)
        subsys.append(net)
        if opts.create_archive:
            subsys.append(interrupt)
            subsys.append(memory)

    pm = pmapi.pmContext.fromOptions(opts.opts, sys.argv)
    if pm.type == c_api.PM_CONTEXT_ARCHIVE:
        replay_archive = True
        input_file = opts.opts.pmGetOptionArchives()[0]
        pm.pmSetMode(c_api.PM_MODE_FORW, pmapi.timeval(0, 0), 0)

    # Find server-side pmcd host-name
    host = pm.pmGetContextHostName()

    (delta, errmsg) = pm.pmParseInterval(str(opts.interval_arg) + " seconds")
    delta_seconds = c_api.pmtimevalToReal(delta.tv_sec, delta.tv_usec)

    if opts.duration_arg != 0:
        (timeval, errmsg) = pm.pmParseInterval(str(opts.duration_arg))
        duration = c_api.pmtimevalToReal(timeval.tv_sec, timeval.tv_usec)
        opts.n_samples = int((duration / delta_seconds) + 0.5)

    if opts.create_archive:
        msec = str(int(1000.0 * delta_seconds))
        configuration = "log mandatory on every " + msec + " milliseconds {\n"
Example #26
0
    def __init__(self, arguments):
        """ Construct object, prepare for command line handling """
        global op
        op = self

        self.context = None
        self.opts = self.options()
        self.arguments = arguments
        self.pmconfig = pmconfig.pmConfig(self)

        ### Add additional dstat metric specifiers
        dspec = (None, 'printtype', 'colorstep', 'plugin')
        mspec = self.pmconfig.metricspec + dspec
        self.pmconfig.metricspec = mspec

        ### Add global dstat configuration directives
        self.keys = ('header', 'interval', 'timefmt')

        ### The order of preference for options (as present):
        # 1 - command line options
        # 2 - options from configuration file(s)
        # 3 - built-in defaults defined below
        self.check = 0
        self.version = self.CONFIG_VERSION
        self.source = "local:"
        self.output = None
        self.instances = None
        self.speclocal = None
        self.derived = None
        self.globals = 1
        self.samples = -1 # forever
        self.interval = pmapi.timeval(1)      # 1 sec
        self.opts.pmSetOptionInterval(str(1)) # 1 sec
        self.missed = 0
        self.delay = 1.0
        self.type = 0
        self.type_prefer = self.type
        self.ignore_incompat = 0
        self.precision = 5 # .5f
        self.timefmt = self.TIMEFMT
        self.interpol = 0

        # Internal
        self.missed = 0
        self.runtime = -1
        self.plugins = []     # list of requested plugin names
        self.allplugins = []  # list of all known plugin names
        self.timeplugins = [] # list of the time plugin names
        self.timelist = []    # DstatPlugin time objects list
        self.totlist = []     # active DstatPlugin object list
        self.vislist = []     # visible DstatPlugin object list
        self.mapping = {}     # maps 'section/label' to plugin

        self.bits = False
        self.blackonwhite = False
        self.color = None
        self.debug = False
        self.header = 1
        self.output = True
        self.update = True
        self.pidfile = False
        self.float = False
        self.integer = False

        # Options for specific plugins
        self.cpulist = None
        self.disklist = None
        self.intlist = None
        self.netlist = None
        self.swaplist = None

        ### Implicit if no terminal is used
        if not sys.stdout.isatty():
            self.color = False
            self.header = False
            self.update = False

        atexit.register(self.finalize)

        # Performance metrics store
        # key    - plugin/metric name
        # values - 0:text label, 1:instance(s), 2:unit/scale, 3:type,
        #          4:width, 5:pmfg item, 6:precision, 7:limit,
        #          [ 8:printtype, 9:colorstep, 10:plugin <- Dstat extras ]
        self.metrics = OrderedDict()
        self.pmfg = None
        self.pmfg_ts = None

        ### Initialise output device
        self.term = DstatTerminal()

        ### Read configuration and initialise plugins
        configs = self.prepare_plugins()
        self.create_time_plugins()

        ### Complete command line processing and terminal/file setup
        operands = self.pmconfig.read_cmd_line()
        self.prepare_metrics(configs)
        self.prepare_output(operands)
Example #27
0
    # Setup some default reporting if none specified so far
    if len(subsys) == 0:
        subsys.append(cpu)
        subsys.append(disk)
        subsys.append(net)
        if opts.create_archive:
            subsys.append(interrupt, memory)

    if opts.duration_arg != 0:
        (timeval, errmsg) = pm.pmParseInterval(str(opts.duration_arg))
        duration = c_api.pmtimevalToReal(timeval)

    pm = pmapi.pmContext.fromOptions(opts.opts, sys.argv)
    if pm.type == c_api.PM_CONTEXT_ARCHIVE:
        pm.pmSetMode(c_api.PM_MODE_FORW, pmapi.timeval(0, 0), 0)

    # Find server-side pmcd host-name
    host = pm.pmGetContextHostName()

    (delta, errmsg) = pmapi.pmContext.pmParseInterval(str(opts.interval_arg) + " seconds")

    if opts.create_archive:
        delta_seconds = c_api.pmtimevalToReal(delta.tv_sec, delta.tv_usec)
        msec = str(int(1000.0 * delta_seconds))
        configuration = "log mandatory on every " + msec + " milliseconds { "
        configuration += ss.dump_metrics()
        configuration += "}"
        if duration == 0.0:
            if opts.n_samples != 0:
                duration = float(opts.n_samples) * delta_seconds
Example #28
0
    def __init__(self):
        """ Construct object, parse command line """
        self.context = None
        self.database = 'pcp'
        self.influxdb_tags = ''
        self.influxdb_address = 'http://127.0.0.1:8086'
        self.influxdb_user = None
        self.influxdb_pass = None
        self.sample_count = 0
        self.unitsstr = None
        self.units = None
        self.units_mult = None

        # option setup
        self.opts = pmapi.pmOptions()
        self.opts.pmSetShortOptions("a:O:s:T:g:p:P:r:m:t:u:h:t:D:LV?")
        self.opts.pmSetShortUsage("[options] metricname ...")
        self.opts.pmSetLongOptionText("""
Description: Periodically, relay raw values of all instances of a
given hierarchies of PCP metrics to an InfluxDB server on the network.""")
        self.opts.pmSetLongOptionHeader("Options")
        self.opts.pmSetOptionCallback(self.option)

        # common options
        self.opts.pmSetLongOptionVersion()
        self.opts.pmSetLongOptionArchive()
        self.opts.pmSetLongOptionOrigin()
        self.opts.pmSetLongOptionSamples()
        self.opts.pmSetLongOptionFinish()
        self.opts.pmSetLongOptionDebug()
        self.opts.pmSetLongOptionHost()
        self.opts.pmSetLongOptionLocalPMDA()
        self.opts.pmSetLongOptionInterval()

        # custom options
        self.opts.pmSetLongOption("influxdb-address", 1, 'i', '',
                                  "InfluxDB HTTP/HTTPS address " +
                                  "(default \"" + self.influxdb_address +
                                  "\")")
        self.opts.pmSetLongOption("units", 1, 'u', '',
                                  "rescale units " +
                                  "(e.g. \"MB\", will omit incompatible units)")
        self.opts.pmSetLongOption("database", 1, 'd', '',
                                  "database for metric (default \"pcp\")")
        self.opts.pmSetLongOption("db-user", 1, 'U', '',
                                  "username for InfluxDB database")
        self.opts.pmSetLongOption("db-password", 1, 'P', '',
                                  "password for InfluxDB database")
        self.opts.pmSetLongOption("tag-string", 1, 'I', '',
                                  "string of tags to add to the metrics")
        self.opts.pmSetLongOptionHelp()

        # parse options
        self.context = pmapi.pmContext.fromOptions(self.opts, sys.argv)
        self.interval = self.opts.pmGetOptionInterval() or pmapi.timeval(60, 0)
        if self.unitsstr is not None:
            units = self.context.pmParseUnitsStr(self.unitsstr)
            (self.units, self.units_mult) = units
        self.metrics = []
        self.pmids = []
        self.descs = []
        metrics = self.opts.pmGetNonOptionsFromList(sys.argv)
        if metrics:
            for m in metrics:
                try:
                    self.context.pmTraversePMNS(m,
                                                self.handle_candidate_metric)
                except pmapi.pmErr as error:
                    sys.stderr.write("Excluding metric %s (%s)\n" %
                                     (m, str(error)))

            sys.stderr.flush()

        if len(self.metrics) == 0:
            sys.stderr.write("No acceptable metrics specified.\n")
            raise pmapi.pmUsageErr()

        # Report what we're about to do
        print("Relaying %d %smetric(s) to database %s with tags %s from %s "
              "to %s every %f s" %
              (len(self.metrics),
               "rescaled " if self.units else "",
               self.database,
               self.influxdb_tags,
               self.describe_source(),
               self.influxdb_address,
               self.interval))

        sys.stdout.flush()
Example #29
0
    def __init__(self):
        """ Construct object, parse command line """
        self.context = None
        self.opts = pmapi.pmOptions()
        self.opts.pmSetShortOptions("g:p:P:u:m:t:h:Lt:D:V?")  # must include common options
        self.opts.pmSetShortUsage("[options] metricname ...")
        self.opts.pmSetOptionCallback(self.option)
        self.opts.pmSetOverrideCallback(self.option_override)
        # hack to include some explanatory text
        self.opts.pmSetLongOptionHeader(
            """
Description: Periodically, relay raw values of all instances of a
given hierarchies of PCP metrics to a graphite/carbon server on the
network.

Options"""
        )
        self.opts.pmSetLongOptionVersion()  # -V
        # self.opts.pmSetLongOptionArchive() # -a FILE   -- not supported yet; need -S/etc. controls
        self.opts.pmSetLongOptionDebug()  # -D stuff
        self.opts.pmSetLongOptionHost()  # -h HOST
        # self.opts.pmSetLongOptionLocalPMDA() # -L
        self.opts.pmSetLongOptionInterval()  # -t NUMBER
        self.opts.pmSetLongOption("graphite-host", 1, "g", "", 'graphite server host (default "localhost")')
        self.opts.pmSetLongOption("pickled-port", 1, "p", "", "graphite pickled port (default 2004)")
        self.opts.pmSetLongOption("text-port", 1, "P", "", "graphite plaintext port (usually 2003)")
        self.opts.pmSetLongOption("units", 1, "u", "", 'rescale all metric units (e.g., "mbytes/5 sec")')
        self.opts.pmSetLongOption("prefix", 1, "m", "", 'prefix for metric names (default "pcp.")')
        self.opts.pmSetLongOptionHelp()
        self.graphite_host = "localhost"
        self.graphite_port = 2004
        self.pickle = True
        self.prefix = "pcp."
        self.unitsstr = None
        self.units = None  # pass verbatim by default
        self.units_mult = None  # pass verbatim by default

        # now actually parse
        self.context = pmapi.pmContext.fromOptions(self.opts, sys.argv)
        self.interval = self.opts.pmGetOptionInterval() or pmapi.timeval(60, 0)

        if self.unitsstr is not None:
            (self.units, self.units_mult) = self.context.pmParseUnitsStr(self.unitsstr)
        self.metrics = []
        self.pmids = []
        self.descs = []
        metrics = self.opts.pmNonOptionsFromList(sys.argv)
        if metrics:
            for m in metrics:
                try:
                    self.context.pmTraversePMNS(m, self.handle_candidate_metric)
                except pmapi.pmErr as error:
                    sys.stderr.write("Excluding metric %s (%s)\n" % (m, str(error)))
            sys.stderr.flush()

        if len(self.metrics) == 0:
            sys.stderr.write("No acceptable metrics specified.\n")
            raise pmapi.pmUsageErr()

        # Report what we're about to do
        print(
            "Relaying %d %smetric(s) with prefix %s "
            "in %s mode to %s:%d every %f s"
            % (
                len(self.metrics),
                "rescaled " if self.units else "",
                self.prefix,
                "pickled" if self.pickle else "text",
                self.graphite_host,
                self.graphite_port,
                self.interval,
            )
        )
        sys.stdout.flush()
Example #30
0
    def __init__(self):
        """ Construct object, prepare for command line handling """
        self.context = None
        self.daemonize = 0
        self.pmconfig = pmconfig.pmConfig(self)
        self.opts = self.options()

        # Configuration directives
        self.keys = ('source', 'output', 'derived', 'header', 'globals',
                     'samples', 'interval', 'type', 'precision', 'daemonize',
                     'timefmt', 'extended', 'everything', 'exact_types',
                     'count_scale', 'space_scale', 'time_scale', 'version',
                     'count_scale_force', 'space_scale_force',
                     'time_scale_force', 'type_prefer', 'precision_force',
                     'limit_filter', 'limit_filter_force', 'live_filter',
                     'rank', 'invert_filter', 'predicate', 'speclocal',
                     'instances', 'ignore_incompat', 'omit_flat')

        # The order of preference for options (as present):
        # 1 - command line options
        # 2 - options from configuration file(s)
        # 3 - built-in defaults defined below
        self.check = 0
        self.version = CONFVER
        self.source = "local:"
        self.output = None  # For pmrep conf file compat only
        self.speclocal = None
        self.derived = None
        self.header = 1
        self.globals = 1
        self.samples = None  # forever
        self.interval = pmapi.timeval(60)  # 60 sec
        self.opts.pmSetOptionInterval(str(60))  # 60 sec
        self.delay = 0
        self.type = 0
        self.type_prefer = self.type
        self.ignore_incompat = 0
        self.instances = []
        self.live_filter = 0
        self.rank = 0
        self.limit_filter = 0
        self.limit_filter_force = 0
        self.invert_filter = 0
        self.predicate = None
        self.omit_flat = 0
        self.precision = 3  # .3f
        self.precision_force = None
        self.timefmt = TIMEFMT
        self.interpol = 0
        self.count_scale = None
        self.count_scale_force = None
        self.space_scale = None
        self.space_scale_force = None
        self.time_scale = None
        self.time_scale_force = None

        # Not in pcp2json.conf, won't overwrite
        self.outfile = None

        self.extended = 0
        self.everything = 0
        self.exact_types = 0

        # Internal
        self.runtime = -1

        self.data = None
        self.prev_ts = None
        self.writer = None

        # Performance metrics store
        # key - metric name
        # values - 0:txt label, 1:instance(s), 2:unit/scale, 3:type,
        #          4:width, 5:pmfg item, 6:precision, 7:limit
        self.metrics = OrderedDict()
        self.pmfg = None
        self.pmfg_ts = None

        # Read configuration and prepare to connect
        self.config = self.pmconfig.set_config_file(DEFAULT_CONFIG)
        self.pmconfig.read_options()
        self.pmconfig.read_cmd_line()
        self.pmconfig.prepare_metrics()
        self.pmconfig.set_signal_handler()
Example #31
0
    def __init__(self):
        """ Construct object, prepare for command line handling """
        self.context = None
        self.daemonize = 0
        self.pmconfig = pmconfig.pmConfig(self)
        self.opts = self.options()

        # Configuration directives
        self.keys = ('source', 'output', 'derived', 'header', 'globals',
                     'samples', 'interval', 'type', 'precision', 'daemonize',
                     'zabbix_server', 'zabbix_port', 'zabbix_host',
                     'zabbix_interval', 'zabbix_prefix', 'zabbix_lld',
                     'count_scale', 'space_scale', 'time_scale', 'version',
                     'count_scale_force', 'space_scale_force',
                     'time_scale_force', 'type_prefer', 'precision_force',
                     'limit_filter', 'limit_filter_force', 'live_filter',
                     'rank', 'invert_filter', 'predicate', 'names_change',
                     'speclocal', 'instances', 'ignore_incompat',
                     'ignore_unknown', 'omit_flat')

        # The order of preference for options (as present):
        # 1 - command line options
        # 2 - options from configuration file(s)
        # 3 - built-in defaults defined below
        self.check = 0
        self.version = CONFVER
        self.source = "local:"
        self.output = None  # For pmrep conf file compat only
        self.speclocal = None
        self.derived = None
        self.header = 1
        self.globals = 1
        self.samples = None  # forever
        self.interval = pmapi.timeval(60)  # 60 sec
        self.opts.pmSetOptionInterval(str(60))  # 60 sec
        self.delay = 0
        self.type = 0
        self.type_prefer = self.type
        self.ignore_incompat = 0
        self.ignore_unknown = 0
        self.names_change = 0  # ignore
        self.instances = []
        self.live_filter = 0
        self.rank = 0
        self.limit_filter = 0
        self.limit_filter_force = 0
        self.invert_filter = 0
        self.predicate = None
        self.omit_flat = 0
        self.precision = 3  # .3f
        self.precision_force = None
        self.timefmt = "%H:%M:%S"  # For compat only
        self.interpol = 0
        self.count_scale = None
        self.count_scale_force = None
        self.space_scale = None
        self.space_scale_force = None
        self.time_scale = None
        self.time_scale_force = None

        self.zabbix_server = ZBXSERVER
        self.zabbix_port = ZBXPORT
        self.zabbix_host = None
        self.zabbix_interval = None
        self.zabbix_prefix = ZBXPREFIX

        self.zabbix_lld = 0
        # Dictionary storing metric:[instance, instance ...] objects
        self.lld_history = {}

        # Internal
        self.runtime = -1

        self.zabbix_prevsend = None
        self.zabbix_metrics = []

        # Performance metrics store
        # key - metric name
        # values - 0:txt label, 1:instance(s), 2:unit/scale, 3:type,
        #          4:width, 5:pmfg item, 6:precision, 7:limit
        self.metrics = OrderedDict()
        self.pmfg = None
        self.pmfg_ts = None

        # Read configuration and prepare to connect
        self.config = self.pmconfig.set_config_path(DEFAULT_CONFIG)
        self.pmconfig.read_options()
        self.pmconfig.read_cmd_line()
        self.pmconfig.prepare_metrics()
        self.pmconfig.set_signal_handler()
Example #32
0
def main(stdscr_p):
    global stdscr
    stdscr = _StandardOutput(stdscr_p)
    sort = ""
    duration = 0.0
    i = 1

    ss = Subsystem()
    ss.init_processor_metrics()
    ss.init_memory_metrics()
    ss.init_disk_metrics()
    ss.init_network_metrics()
    ss.init_process_metrics()

    cpu = _ProcessorPrint(ss, stdscr)
    mem = _MemoryPrint(ss, stdscr)
    disk = _DiskPrint(ss, stdscr)
    net = _NetPrint(ss, stdscr)
    proc = _ProcPrint(ss, stdscr)

    proc.output_type = opts.output_type
    stdscr.width = opts.width

    pmc = pmapi.pmContext.fromOptions(opts.opts, sys.argv)
    if pmc.type == c_api.PM_CONTEXT_ARCHIVE:
        pmc.pmSetMode(c_api.PM_MODE_FORW, pmapi.timeval(0, 0), 0)


    host = pmc.pmGetContextHostName()

    (delta, errmsg) = pmc.pmParseInterval(str(opts.interval_arg) + " seconds")

    ss.setup_metrics(pmc)

    if opts.create_archive:
        delta_seconds = c_api.pmtimevalToReal(delta.tv_sec, delta.tv_usec)
        msec = str(int(1000.0 * delta_seconds))
        configuration = "log mandatory on every " + msec + " milliseconds { "
        configuration += ss.dump_metrics()
        configuration += "}"
        if opts.n_samples != 0:
            duration = float(opts.n_samples) * delta_seconds
        else:
            duration = float(10) * delta_seconds
        status = record(pmgui.GuiClient(), configuration, duration, opts.output_file, host)
        if status != "":
            return status
        record_add_creator(opts.output_file)
        sys.exit(0)

    i_samples = 0

    disk.interval = delta.tv_sec
    disk.replay_archive = opts.replay_archive

    try:
        elapsed = ss.get_metric_value('kernel.all.uptime')
        while (i_samples < opts.n_samples) or (opts.n_samples == 0):
            ss.get_stats(pmc)
            stdscr.move(0, 0)
            stdscr.addstr('ATOP - %s                %s elapsed\n\n' % (
                    time.strftime("%c"),
                    datetime.timedelta(0, elapsed)))
            elapsed = delta.tv_sec
            stdscr.move(2, 0)

            try:
                cpu.prc()
                cpu.cpu()
                mem.mem()
                disk.disk(pmc)
                net.net(pmc)
                proc.set_line()
                proc.proc()
            except pmapi.pmErr as e:
                return str(e) + " while processing " + str(ssx[0])
            except Exception as e: # catch all errors, pcp or python or other
                pass
            stdscr.move(proc.command_line, 0)
            stdscr.refresh()

            stdscr.timeout(delta.tv_sec * 1000)
            char = stdscr.getch()

            if char != -1:       # user typed a command
                try:
                    cmd = chr(char)
                except ValueError:
                    cmd = None
                if cmd == "q":
                    raise KeyboardInterrupt
                elif cmd == "":
Example #33
0
    def __init__(self):
        """ Construct object, prepare for command line handling """
        self.context = None
        self.daemonize = 0
        self.maxlong = pow(2, 63)  # java long limit, applied by elasticsearch
        self.pmconfig = pmconfig.pmConfig(self)
        self.opts = self.options()

        # Configuration directives
        self.keys = ('source', 'output', 'derived', 'header', 'globals',
                     'samples', 'interval', 'type', 'precision', 'daemonize',
                     'es_server', 'es_index', 'es_hostid', 'es_search_type',
                     'count_scale', 'space_scale', 'time_scale', 'version',
                     'count_scale_force', 'space_scale_force',
                     'time_scale_force', 'type_prefer', 'precision_force',
                     'limit_filter', 'limit_filter_force', 'live_filter',
                     'rank', 'invert_filter', 'predicate', 'names_change',
                     'speclocal', 'instances', 'ignore_incompat',
                     'ignore_unknown', 'omit_flat', 'include_labels')

        # Ignored for pmrep(1) compatibility
        self.keys_ignore = ('timestamp', 'unitinfo', 'colxrow',
                            'separate_header', 'fixed_header', 'delay',
                            'width', 'delimiter', 'extcsv', 'width_force',
                            'extheader', 'repeat_header', 'timefmt',
                            'interpol', 'dynamic_header', 'overall_rank',
                            'overall_rank_alt', 'sort_metric', 'instinfo',
                            'include_texts')

        # The order of preference for options (as present):
        # 1 - command line options
        # 2 - options from configuration file(s)
        # 3 - built-in defaults defined below
        self.check = 0
        self.version = CONFVER
        self.source = "local:"
        self.output = None  # For pmrep conf file compat only
        self.speclocal = None
        self.derived = None
        self.header = 1
        self.globals = 1
        self.samples = None  # forever
        self.interval = pmapi.timeval(60)  # 60 sec
        self.opts.pmSetOptionInterval(str(60))  # 60 sec
        self.delay = 0
        self.type = 0
        self.type_prefer = self.type
        self.ignore_incompat = 0
        self.ignore_unknown = 0
        self.names_change = 0  # ignore
        self.instances = []
        self.live_filter = 0
        self.rank = 0
        self.limit_filter = 0
        self.limit_filter_force = 0
        self.invert_filter = 0
        self.predicate = None
        self.omit_flat = 0
        self.include_labels = 0
        self.precision = 3  # .3f
        self.precision_force = None
        self.timefmt = "%H:%M:%S"  # For compat only
        self.interpol = 0
        self.count_scale = None
        self.count_scale_force = None
        self.space_scale = None
        self.space_scale_force = None
        self.time_scale = None
        self.time_scale_force = None

        self.es_server = ES_SERVER
        self.es_index = ES_INDEX
        self.es_search_type = ES_SEARCH_TYPE
        self.es_hostid = None
        self.es_failed = False

        # Internal
        self.runtime = -1

        # Performance metrics store
        # key - metric name
        # values - 0:txt label, 1:instance(s), 2:unit/scale, 3:type,
        #          4:width, 5:pmfg item, 6:precision, 7:limit
        self.metrics = OrderedDict()
        self.pmfg = None
        self.pmfg_ts = None

        # Read configuration and prepare to connect
        self.config = self.pmconfig.set_config_path(DEFAULT_CONFIG)
        self.pmconfig.read_options()
        self.pmconfig.read_cmd_line()
        self.pmconfig.prepare_metrics()
        self.pmconfig.set_signal_handler()
Example #34
0
    def __init__(self):
        """ Construct object, prepare for command line handling """
        self.context = None
        self.daemonize = 0
        self.pmconfig = pmconfig.pmConfig(self)
        self.opts = self.options()

        # Configuration directives
        self.keys = ('source', 'output', 'derived', 'header', 'globals',
                     'samples', 'interval', 'type', 'precision', 'daemonize',
                     'timefmt', # XXX Custom options here, if any (see below)
                     'count_scale', 'space_scale', 'time_scale', 'version',
                     'count_scale_force', 'space_scale_force', 'time_scale_force',
                     'type_prefer', 'precision_force', 'limit_filter', 'limit_filter_force',
                     'live_filter', 'rank', 'invert_filter', 'predicate', 'names_change',
                     'speclocal', 'instances', 'ignore_incompat', 'ignore_unknown',
                     'omit_flat')

        # Ignored for pmrep(1) compatibility
        # XXX Keep in sync with self.keys in pmrep
        self.keys_ignore = (
                     'timestamp', 'unitinfo', 'colxrow', 'separate_header', 'fixed_header',
                     'delay', 'width', 'delimiter', 'extcsv', 'width_force',
                     'extheader', 'repeat_header', 'interpol',
                     'dynamic_header', 'overall_rank', 'overall_rank_alt', 'sort_metric',
                     'instinfo', 'include_labels', 'include_texts')

        # The order of preference for options (as present):
        # 1 - command line options
        # 2 - options from configuration file(s)
        # 3 - built-in defaults defined below
        self.check = 0
        self.version = CONFVER
        self.source = "local:"
        self.output = None # For pmrep conf file compat only
        self.speclocal = None
        self.derived = None
        self.header = 1
        self.globals = 1
        self.samples = None # forever
        # XXX Adjust default interval as needed
        self.interval = pmapi.timeval(10)      # 10 sec
        self.opts.pmSetOptionInterval(str(10)) # 10 sec
        self.delay = 0
        self.type = 0
        self.type_prefer = self.type
        self.ignore_incompat = 0
        self.ignore_unknown = 0
        self.names_change = 0 # ignore
        self.instances = []
        self.live_filter = 0
        self.rank = 0
        self.limit_filter = 0
        self.limit_filter_force = 0
        self.invert_filter = 0
        self.predicate = None
        self.omit_flat = 0
        self.precision = 3 # .3f
        self.precision_force = None
        self.timefmt = TIMEFMT
        self.interpol = 0
        self.count_scale = None
        self.count_scale_force = None
        self.space_scale = None
        self.space_scale_force = None
        self.time_scale = None
        self.time_scale_force = None

        # Not in pcp2XXX.conf, won't overwrite
        self.outfile = None

        # XXX Custom options here, if any (keep in sync with self.keys)

        # Internal
        self.runtime = -1

        self.writer = None

        # Performance metrics store
        # key - metric name
        # values - 0:txt label, 1:instance(s), 2:unit/scale, 3:type,
        #          4:width, 5:pmfg item, 6:precision, 7:limit
        self.metrics = OrderedDict()
        self.pmfg = None
        self.pmfg_ts = None

        # Read configuration and prepare to connect
        self.config = self.pmconfig.set_config_path(DEFAULT_CONFIG)
        self.pmconfig.read_options()
        self.pmconfig.read_cmd_line()
        self.pmconfig.prepare_metrics()
        self.pmconfig.set_signal_handler()