class PrometheusClient:
    def __init__(self):
        #     # Start up the server to expose the metrics.
        start_http_server(EXPORT_PORT)
        self.g = Gauge('sensor_data', 'Value gathered by sensor', ['sensor_id', 'ipe_id', 'category_id', 'unit'])

    def export_data(self, xml_data=None):
        root = ET.fromstring(xml_data)
        ipe_id = root.find('./*[@name="ipeId"]').attrib['val']
        app_id = root.find('./*[@name="appId"]').attrib['val']
        category = root.find('./*[@name="category"]').attrib['val']
        data = int(root.find('./*[@name="data"]').attrib['val'])
        unit = root.find('./*[@name="unit"]').attrib['val']
        # json_body = [
        #     {
        #         "measurement": "sensor_status",
        #         "tags": {
        #             "sensor_id": app_id,
        #             "ipe_id": ipe_id,
        #             "category": category
        #         },
        #         "fields": {
        #             "data": data,
        #             "unit": unit
        #         }
        #     }
        # ]
        self.g.labels(app_id, ipe_id, category, unit).set(data)
示例#2
1
def export_metric(device, id, type, value):
    global temperature_gauge
    if (temperature_gauge == None):
       temperature_gauge = Gauge('temperature', 'Temperatures from MQTT', ['device', 'id', 'type'])
    global gauges
    if (not id in gauges):
        gauges[id] = temperature_gauge.labels(device, id, type)
        logging.debug('New gauge added. Device: ' + device + ' Id: ' + str(id) + ', type: ' + type)
    
    gauges[id].set(value)
    logging.debug('Gauge temperature set with value: ' + str(value) + ' - Device: ' + device + ' Id: ' + id + ' Type: ' + type)
示例#3
0
 def inc_counter(self, key, amount=1):
     """ Increment counter
     """
     prometheus_counter = Gauge(  # pylint: disable=no-value-for-parameter
         key
     )
     prometheus_counter.inc(amount)
示例#4
0
 def dec_counter(self, key, amount=1):
     """ Decrement metric
     """
     prometheus_counter = Gauge(  # pylint: disable=no-value-for-parameter
         key
     )
     prometheus_counter.dec(amount)
 def get_stats(self):
     registry = CollectorRegistry()
     labels = ['region']
     label_values = [self.region]
     duration = Gauge('openstack_exporter_cache_refresh_duration_seconds',
                      'Cache refresh duration in seconds.',
                      labels, registry=registry)
     duration.labels(*label_values).set(self.duration)
     return generate_latest(registry)
示例#6
0
文件: futils.py 项目: elfchief/calico
 def increment(self, stat, by=1):
     self.stats[stat] += by
     # Update the associated Prometheus gauge.
     if stat not in self.prom_gauges:
         gauge = Gauge(sanitize_name("felix_" + self.name + " " + stat),
                       "%s: %s" % (self.name, stat))
         self.prom_gauges[stat] = gauge
     else:
         gauge = self.prom_gauges[stat]
     gauge.inc(by)
class HistogramRoller(RollerBase):
    """Accepts a Histogram object and creates a guage with multiple labels tracking bucket values
    over a given time period.
    """
    def __init__(self, histogram, options=None, registry=REGISTRY, roller_registry=ROLLER_REGISTRY):
        self.hist = histogram
        if self.hist._type != 'histogram':
            raise ValueError('Only a Histogram object should be passed to HistogramRoller')

        options = options or {}
        self.extract_options(options)

        # Keys are 'le' values
        # Holds deques containing values for each gauge
        self.past_values = dict()
        full_name = ""
        for full_name, labels, _ in iter_hist_buckets(self.hist):
            le_label = labels['le']
            self.past_values[le_label] = deque()

        self.configure_with_full_name(full_name, is_histogram=True)

        # A single top level gauge with bucket labels tracks the values
        self.gauge = Gauge(
            self.name,
            self.documentation,
            labelnames=('le',),
            registry=registry
        )

        roller_registry[self.name] = self

    def collect(self):
        """Loop over current histogram bucket values and update gauges.

        Usage:
        * Collect should only be called about every second, not in a tight loop.
        * Should only be called in 1 thread at a time.
        """
        now = datetime.datetime.now()

        # Fetch values from histograms
        for _, labels, value in iter_hist_buckets(self.hist):
            sample_key = labels['le']

            # Add value
            self.past_values[sample_key].append((now, value))

            # Drop old values
            remove_old_values(self.past_values[sample_key], now - self.retention_td)

            # Calculate and record new rolled value
            v = self.reducer(values_to_deltas(self.past_values[sample_key]), **self.reducer_kwargs)
            self.gauge.labels({'le': sample_key}).set(v)
示例#8
0
    def sendGauge(self,metric, description ,value, job, labels):

        for g in self.metrics:
            if g._name == metric and g._type == 'gauge':
                g.labels(resource_id=self.id,snmp_ip=labels['ip'],snmp_port=labels['port']).set(value)
                self.push(job=job)
                return

        g = Gauge(metric, description , ["resource_id","snmp_ip","snmp_port"], registry=self.registry)
        g.labels(resource_id=self.id,snmp_ip=labels['ip'],snmp_port=labels['port']).set(value)
        self.metrics.append(g)
        self.push(job=job)
示例#9
0
class PrometheusMetricsCollector(MetricsCollector):

    def __init__(self):
        super(PrometheusMetricsCollector, self).__init__()
        self.registry = CollectorRegistry()
        self.task_started_counter = Counter(
            'luigi_task_started_total',
            'number of started luigi tasks',
            ['family'],
            registry=self.registry
        )
        self.task_failed_counter = Counter(
            'luigi_task_failed_total',
            'number of failed luigi tasks',
            ['family'],
            registry=self.registry
        )
        self.task_disabled_counter = Counter(
            'luigi_task_disabled_total',
            'number of disabled luigi tasks',
            ['family'],
            registry=self.registry
        )
        self.task_done_counter = Counter(
            'luigi_task_done_total',
            'number of done luigi tasks',
            ['family'],
            registry=self.registry
        )
        self.task_execution_time = Gauge(
            'luigi_task_execution_time_seconds',
            'luigi task execution time in seconds',
            ['family'],
            registry=self.registry
        )

    def generate_latest(self):
        return generate_latest(self.registry)

    def handle_task_started(self, task):
        self.task_started_counter.labels(family=task.family).inc()
        self.task_execution_time.labels(family=task.family)

    def handle_task_failed(self, task):
        self.task_failed_counter.labels(family=task.family).inc()
        self.task_execution_time.labels(family=task.family).set(task.updated - task.time_running)

    def handle_task_disabled(self, task, config):
        self.task_disabled_counter.labels(family=task.family).inc()
        self.task_execution_time.labels(family=task.family).set(task.updated - task.time_running)

    def handle_task_done(self, task):
        self.task_done_counter.labels(family=task.family).inc()
        # time_running can be `None` if task was already complete
        if task.time_running is not None:
            self.task_execution_time.labels(family=task.family).set(task.updated - task.time_running)

    def configure_http_handler(self, http_handler):
        http_handler.set_header('Content-Type', CONTENT_TYPE_LATEST)
    def __init__(self, histogram, options=None, registry=REGISTRY, roller_registry=ROLLER_REGISTRY):
        self.hist = histogram
        if self.hist._type != 'histogram':
            raise ValueError('Only a Histogram object should be passed to HistogramRoller')

        options = options or {}
        self.extract_options(options)

        # Keys are 'le' values
        # Holds deques containing values for each gauge
        self.past_values = dict()
        full_name = ""
        for full_name, labels, _ in iter_hist_buckets(self.hist):
            le_label = labels['le']
            self.past_values[le_label] = deque()

        self.configure_with_full_name(full_name, is_histogram=True)

        # A single top level gauge with bucket labels tracks the values
        self.gauge = Gauge(
            self.name,
            self.documentation,
            labelnames=('le',),
            registry=registry
        )

        roller_registry[self.name] = self
示例#11
0
 def __init__(self):
     super(PrometheusMetricsCollector, self).__init__()
     self.registry = CollectorRegistry()
     self.task_started_counter = Counter(
         'luigi_task_started_total',
         'number of started luigi tasks',
         ['family'],
         registry=self.registry
     )
     self.task_failed_counter = Counter(
         'luigi_task_failed_total',
         'number of failed luigi tasks',
         ['family'],
         registry=self.registry
     )
     self.task_disabled_counter = Counter(
         'luigi_task_disabled_total',
         'number of disabled luigi tasks',
         ['family'],
         registry=self.registry
     )
     self.task_done_counter = Counter(
         'luigi_task_done_total',
         'number of done luigi tasks',
         ['family'],
         registry=self.registry
     )
     self.task_execution_time = Gauge(
         'luigi_task_execution_time_seconds',
         'luigi task execution time in seconds',
         ['family'],
         registry=self.registry
     )
 def get_stats(self):
     registry = CollectorRegistry()
     labels = ['region', 'host', 'aggregate', 'aggregate_id']
     hypervisor_stats_cache = self.get_cache_data()
     for hypervisor_stat in hypervisor_stats_cache:
         stat_gauge = Gauge(
             self.gauge_name_sanitize(
                 hypervisor_stat['stat_name']),
             'Openstack Hypervisor statistic',
             labels,
             registry=registry)
         label_values = [self.osclient.region,
                         hypervisor_stat.get('host', ''),
                         hypervisor_stat.get('aggregate', ''),
                         hypervisor_stat.get('aggregate_id', '')]
         stat_gauge.labels(*label_values).set(hypervisor_stat['stat_value'])
     return generate_latest(registry)
 def get_stats(self):
     registry = CollectorRegistry()
     labels = ['region', 'host', 'service', 'state']
     services_stats_cache = self.get_cache_data()
     for services_stat in services_stats_cache:
         stat_gauge = Gauge(
             self.gauge_name_sanitize(
                 services_stat['stat_name']),
             'Openstack Nova Service statistic',
             labels,
             registry=registry)
         label_values = [self.osclient.region,
                         services_stat.get('host', ''),
                         services_stat.get('service', ''),
                         services_stat.get('state', '')]
         stat_gauge.labels(*label_values).set(services_stat['stat_value'])
     return generate_latest(registry)
def update_gauges(metrics):
    metric_dict = {}
    for (name_list, label_dict, value) in metrics:
        metric_name = format_metric_name(name_list)
        if metric_name not in metric_dict:
            metric_dict[metric_name] = (tuple(label_dict.keys()), {})

        label_keys = metric_dict[metric_name][0]
        label_values = tuple([
            format_label_value(label_dict[key])
            for key in label_keys
        ])

        metric_dict[metric_name][1][label_values] = value

    for metric_name, (label_keys, value_dict) in metric_dict.items():
        if metric_name in gauges:
            (old_label_values_set, gauge) = gauges[metric_name]
        else:
            old_label_values_set = set()
            gauge = Gauge(metric_name, '', label_keys)

        new_label_values_set = set(value_dict.keys())

        for label_values in old_label_values_set - new_label_values_set:
            gauge.remove(*label_values)

        for label_values, value in value_dict.items():
            if label_values:
                gauge.labels(*label_values).set(value)
            else:
                gauge.set(value)

        gauges[metric_name] = (new_label_values_set, gauge)
class CounterRoller(RollerBase):
    """Accepts a Counter object and creates a gauge tracking its value over a given time period.
    """
    def __init__(self, counter, options=None, registry=REGISTRY, roller_registry=ROLLER_REGISTRY):
        self.counter = counter
        if self.counter._type != 'counter':
            raise ValueError('Only a Counter object should be passed to CounterRoller')

        options = options or {}
        self.extract_options(options)

        self.past_values = deque()
        full_name, _, _ = self.get_sample()
        self.configure_with_full_name(full_name)

        self.gauge = Gauge(
            self.name,
            self.documentation,
            registry=registry
        )

        roller_registry[self.name] = self

    def get_sample(self):
        """Returns (full_name, labels, value)
        """
        return self.counter.collect()[0].samples[0]

    def collect(self):
        """Update tracked counter values and current gauge value
        """
        now = datetime.datetime.now()

        # Fetch value from counter
        _, _, value = self.get_sample()

        # Add value
        self.past_values.append((now, value))

        # Drop old values
        remove_old_values(self.past_values, now - self.retention_td)

        # Calculate and record new rolled value
        v = self.reducer(values_to_deltas(self.past_values), **self.reducer_kwargs)
        self.gauge.set(v)
 def get_stats(self):
     registry = CollectorRegistry()
     labels = ['region', 'url', 'service']
     check_api_data_cache = self.get_cache_data()
     for check_api_data in check_api_data_cache:
         label_values = [
             check_api_data['region'],
             check_api_data['url'],
             check_api_data['service']]
         gague_name = self.gauge_name_sanitize(
             "check_{}_api".format(check_api_data['service']))
         check_gauge = Gauge(
             gague_name,
             'Openstack API check. fail = 0, ok = 1 and unknown = 2',
             labels,
             registry=registry)
         check_gauge.labels(*label_values).set(check_api_data['status'])
     return generate_latest(registry)
示例#17
0
class PromClient: # pylint: disable=too-few-public-methods
    """Prometheus client."""

    REQUIRED_LABELS = ['dp_id', 'dp_name']
    _reg = REGISTRY

    def __init__(self, reg=None):
        if reg is not None:
            self._reg = reg
        # TODO: investigate faster alternative (https://bugs.launchpad.net/pbr/+bug/1688405)
        version = VersionInfo('faucet').semantic_version().release_string()
        self.faucet_version = PromGauge( # pylint: disable=unexpected-keyword-arg
            'faucet_pbr_version',
            'Faucet PBR version',
            ['version'],
            registry=self._reg)
        self.faucet_version.labels(version=version).set(1) # pylint: disable=no-member
        self.server = None
        self.thread = None

    def start(self, prom_port, prom_addr, use_test_thread=False):
        """Start webserver."""
        if not self.server:
            app = make_wsgi_app(self._reg)
            if use_test_thread:
                from wsgiref.simple_server import make_server, WSGIRequestHandler
                import threading

                class NoLoggingWSGIRequestHandler(WSGIRequestHandler):
                    """Don't log requests."""

                    def log_message(self, *_args): # pylint: disable=arguments-differ
                        pass

                self.server = make_server(
                    prom_addr, int(prom_port), app, handler_class=NoLoggingWSGIRequestHandler)
                self.thread = threading.Thread(target=self.server.serve_forever)
                self.thread.daemon = True
                self.thread.start()
            else:
                self.server = hub.WSGIServer((prom_addr, int(prom_port)), app)
                self.thread = hub.spawn(self.server.serve_forever)
            self.thread.name = 'prometheus'
示例#18
0
def register_prometheus_gauges(export_internal_raspberry=False):
    g = Gauge("sensor_temperature_in_celsius", "Local room temperature around the raspberry pi", ["sensor"])
    error_g = Gauge("faulty_sensor_read", "Is 1 if the sensor could not be read.", ["sensor"])
    sensors = find_sensors()
    print "Found sensors:", ", ".join(map(lambda x: str(x), sensors))
    for sensor in sensors:
        g.labels(str(sensor)).set_function(sensor)
        sensor.set_error_gauge(error_g.labels(str(sensor)))
    if export_internal_raspberry:
        g = Gauge("cpu_temperature_in_celsius", "CPU Temperature of the Raspberry Pi")
        g.set_function(read_raspberry_pi_temperature)
    return sensors
示例#19
0
def collect_snmp(config, host, port=161):
  """Scrape a host and return prometheus text format for it"""

  start = time.time()
  metrics = {}
  for metric in config['metrics']:
    metrics[metric['name']] = Metric(metric['name'], 'SNMP OID {0}'.format(metric['oid']), 'untyped')

  values = walk_oids(host, port, config['walk'])
  oids = {}
  for oid, value in values:
    oids[tuple(oid)] = value

  for oid, value in oids.items():
    for metric in config['metrics']:
      prefix = oid_to_tuple(metric['oid'])
      if oid[:len(prefix)] == prefix:
        value = float(value)
        indexes = oid[len(prefix):]
        labels = parse_indexes(indexes, metric.get('indexes', {}), metric.get('lookups', {}), oids)
        metrics[metric['name']].add_sample(metric['name'], value=value, labels=labels)

  class Collector():
    def collect(self):
      return metrics.values()
  registry = CollectorRegistry()
  registry.register(Collector())
  duration = Gauge('snmp_scrape_duration_seconds', 'Time this SNMP scrape took, in seconds', registry=registry)
  duration.set(time.time() - start)
  walked = Gauge('snmp_oids_walked', 'Number of oids walked in this scrape', registry=registry)
  walked.set(len(oids))
  return generate_latest(registry)
示例#20
0
 def __init__(self, reg=None):
     if reg is not None:
         self._reg = reg
     # TODO: investigate faster alternative (https://bugs.launchpad.net/pbr/+bug/1688405)
     version = VersionInfo('faucet').semantic_version().release_string()
     self.faucet_version = PromGauge( # pylint: disable=unexpected-keyword-arg
         'faucet_pbr_version',
         'Faucet PBR version',
         ['version'],
         registry=self._reg)
     self.faucet_version.labels(version=version).set(1) # pylint: disable=no-member
     self.server = None
     self.thread = None
示例#21
0
def collect_snmp(config, host, port=161):
  """Scrape a host and return prometheus text format for it"""

  start = time.time()
  metrics = {}
  for metric in config['metrics']:
    metrics[metric['name']] = Metric(metric['name'], 'SNMP OID {0}'.format(metric['oid']), 'untyped')

  do_bulkget = 'bulkget' not in config or config['bulkget']
  values = walk_oids(host, port, config['walk'], config.get('community', 'public'), do_bulkget)

  oids = {}
  for oid, value in values:
    oids[oid_to_tuple(oid)] = value

  # Netsnmp doesn't tell us if an error has occured, so
  # try to spot it by no results.
  if not oids:
    raise Exception("No OIDs returned, device not responding?")

  # Build a tree from the rules based on oid for faster lookup.
  metric_tree = {}
  for metric in config['metrics']:
    prefix = oid_to_tuple(metric['oid'])
    head = metric_tree
    for i in prefix:
      head.setdefault('children', {})
      head['children'].setdefault(i, {})
      head = head['children'][i]
    head['entry'] = metric

  for oid, value in oids.items():
    head = metric_tree
    for i in oid:
      head = head.get('children', {}).get(i)
      if not head:
        break
      if 'entry' in head:
        metric = head['entry']

        prefix = oid_to_tuple(metric['oid'])
        value = float(value)
        indexes = oid[len(prefix):]
        labels = parse_indexes(indexes, metric.get('indexes', {}), metric.get('lookups', {}), oids)
        metrics[metric['name']].add_sample(metric['name'], value=value, labels=labels)
        break

  class Collector():
    def collect(self):
      return metrics.values()
  registry = CollectorRegistry()
  registry.register(Collector())
  duration = Gauge('snmp_scrape_duration_seconds', 'Time this SNMP scrape took, in seconds', registry=registry)
  duration.set(time.time() - start)
  walked = Gauge('snmp_oids_walked', 'Number of oids walked in this scrape', registry=registry)
  walked.set(len(oids))
  return generate_latest(registry)
示例#22
0
class Metric(object):
    __slots__ = ['_collect', '_base_metric']

    def __init__(self, name, description, collect_fn):
        self._collect = collect_fn
        self._base_metric = Gauge('nvidia_' + name, description, ['device_index', 'device_name'])

    def metric_for(self, device_name, device_index, device_handle):
        m = self._base_metric.labels(device_index=device_index, device_name=device_name)

        def collect():
            try:
                return self._collect(device_handle)
            except:
                return 0

        m.set_function(collect)
        return m
    def __init__(self, counter, options=None, registry=REGISTRY, roller_registry=ROLLER_REGISTRY):
        self.counter = counter
        if self.counter._type != 'counter':
            raise ValueError('Only a Counter object should be passed to CounterRoller')

        options = options or {}
        self.extract_options(options)

        self.past_values = deque()
        full_name, _, _ = self.get_sample()
        self.configure_with_full_name(full_name)

        self.gauge = Gauge(
            self.name,
            self.documentation,
            registry=registry
        )

        roller_registry[self.name] = self
示例#24
0
文件: utils.py 项目: headmin/zentral
def get_prometheus_inventory_metrics():
    registry = CollectorRegistry()
    g = Gauge('zentral_inventory_osx_apps', 'Zentral inventory OSX apps',
              ['name', 'version_str', 'source'],
              registry=registry)
    for r in osx_app_count():
        count = r.pop('count')
        g.labels(**r).set(count)
    g = Gauge('zentral_inventory_os_versions', 'Zentral inventory OS Versions',
              ['name', 'major', 'minor', 'patch', 'build', 'source'],
              registry=registry)
    for r in os_version_count():
        count = r.pop('count')
        g.labels(**r).set(count)
    return generate_latest(registry)
示例#25
0
 def __init__(self, name, desc, labels, value, value_converter, url, query, logger=None):
     '''
     name            -- metric name (e.g. node_network_status)
     desc            -- metric description
     labels          -- indexes (tuple of strings) in metric_data taken as labels
     value           -- index in metric_data (dict) taken as value for metric
     value_converter -- sometime value may came in mixed format like - 5s, 3GB.
                        we need to convert this value to numeric.
                        pass a function reference to this converter, can be lambda as well.
     url             -- elasticsearch url to index or GET query
     query           -- elasticsearch query data for POST request
     logger          -- instance of logging.Logger class
     '''
     self.gauge = Gauge(name, desc, list(labels))
     self.name = name
     self.labels = labels
     self.value = value
     self.value_converter = value_converter
     self.url = url
     self.query = query
     self.logger = logger
示例#26
0
def push_inventory_metrics():
    ppg = settings.get('apps', {}).get('zentral.contrib.inventory', {}).get('prometheus_push_gateway', None)
    if not ppg:
        return
    registry = CollectorRegistry()
    g = Gauge('zentral_inventory_osx_apps', 'Zentral inventory OSX apps',
              ['name', 'version_str', 'source'],
              registry=registry)
    for r in osx_app_count():
        count = r.pop('count')
        g.labels(r).set(count)
    g = Gauge('zentral_inventory_os_versions', 'Zentral inventory OS Versions',
              ['name', 'major', 'minor', 'patch', 'build', 'source'],
              registry=registry)
    for r in os_version_count():
        count = r.pop('count')
        g.labels(r).set(count)
    push_to_gateway(ppg, job='zentral_push_inventory_metrics', registry=registry)
示例#27
0
def collect_snmp(config, host, port=161):
  """Scrape a host and return prometheus text format for it"""

  start = time.time()
  metrics = {}
  for metric in config['metrics']:
    prom_type = metric['metric_type'] if 'metric_type' in metric else 'gauge'
    prom_help = metric['metric_help'] if 'metric_help' in metric else 'SNMP OID {0}'.format( metric['oid'] if 'oid' in metric else "NaN" )
    metrics[metric['name']] = Metric(metric['name'], prom_help, prom_type)
  values = walk_oids(host, port, config['walk'], config.get('community', 'public'), config.get('timeout', 5), config.get('retries', 3))
  oids = {}
  for oid, value in values:
    if oid_to_tuple(oid) in oids:
      if (((not oids[oid_to_tuple(oid)]) or oids[oid_to_tuple(oid)] == None) and value):
        oids[oid_to_tuple(oid)] = value
    else:
        oids[oid_to_tuple(oid)] = value

  for oid, value in oids.items():
    for metric in config['metrics']:
      prefix = oid_to_tuple(metric['oid'])
      if oid[:len(prefix)] == prefix:
        try:
            value = float(value)
        except ValueError as e:
            print(e)
            value = 0.0

        indexes = oid[len(prefix):]
        labels = parse_indexes(indexes, metric.get('indexes', {}), metric.get('lookups', {}), oids)
        metrics[metric['name']].add_sample(metric['name'], value=value, labels=labels)

  class Collector():
    def collect(self):
      return metrics.values()
  registry = CollectorRegistry()
  registry.register(Collector())
  duration = Gauge('snmp_scrape_duration_seconds', 'Time this SNMP scrape took, in seconds', registry=registry)
  duration.set(time.time() - start)
  walked = Gauge('snmp_oids_walked', 'Number of oids walked in this scrape', registry=registry)
  walked.set(len(oids))
  return generate_latest(registry)
示例#28
0
    def notify_success(self, source, hostname, filename, stats):
        registry = CollectorRegistry()

        s = Summary('backup_size', 'Size of backup file in bytes', registry=registry)
        s.observe(stats.size)
        s = Summary('backup_dumptime', 'Time taken to dump and compress/encrypt backup in seconds', registry=registry)
        s.observe(stats.dumptime)
        s = Summary('backup_uploadtime', 'Time taken to upload backup in seconds', registry=registry)
        s.observe(stats.uploadtime)
        if stats.retained_copies is not None:
            g = Gauge('backup_retained_copies', 'Number of retained backups found on destination', registry=registry)
            g.set(stats.retained_copies)
        g = Gauge('backup_timestamp', 'Time backup completed as seconds-since-the-epoch', registry=registry)
        g.set_to_current_time()

        def auth_handler(url, method, timeout, headers, data):
            return basic_auth_handler(url, method, timeout, headers, data, self.username, self.password)

        push_to_gateway(self.url, job=source.id, registry=registry, handler=auth_handler)

        logging.info("Pushed metrics for job '%s' to gateway (%s)" % (source.id, self.url))
示例#29
0
from prometheus_client import start_http_server, Gauge

from shared.setup_logging import setup_logging
from providers.beacon_node import BeaconNode, GENESIS_DATETIME
from db.tables import Balance
from db.db_helpers import get_db_uri

logger = logging.getLogger(__name__)
engine = create_engine(get_db_uri(), executemany_mode="batch")

START_DATE = "2020-01-01"

ALREADY_INDEXED_SLOTS = set()

SLOTS_WITH_MISSING_BALANCES = Gauge(
    "slots_with_missing_balances",
    "Slots for which balances still need to be indexed and inserted into the database",
)


@contextmanager
def session_scope():
    """Provide a transactional scope around a series of operations."""
    session = Session(bind=engine)
    try:
        yield session
        session.commit()
    except:
        session.rollback()
        raise
    finally:
        session.close()
def main():
    parser = _create_parser()
    args = parser.parse_args()
    logging.basicConfig(level=logging.DEBUG if args.verbose else logging.INFO)
   
    registry = core.REGISTRY

    total_fb_memory = Gauge('gpu_total_fb_memory_mb',
                            'Total installed frame buffer memory (in '
                            'megabytes)',
                            ['device'],
                            registry=registry)
    free_fb_memory = Gauge('gpu_free_fb_memory_mb',
                           'Unallocated frame buffer memory (in '
                           'megabytes)',
                           ['device'],
                           registry=registry)
    used_fb_memory = Gauge('gpu_used_fb_memory_mb',
                           'Allocated frame buffer memory (in megabytes).'
                           ' Note that the diver/GPU will always set '
                           'a small amount of memory fore bookkeeping.',
                           ['device'],
                           registry=registry)
    gpu_utilization = Gauge('gpu_utilization_pct',
                            'Percent of time over the past sample period '
                            'during which one or more kernels was '
                            'executing on the GPU.',
                            ['device'],
                            registry=registry)
    memory_utilization = Gauge('gpu_mem_utilization_pct',
                               'Percent of time over the past sample '
                               'period during which global (device) memory '
                               'was being read or written',
                               ['device'],
                               registry=registry)

    iteration = 0

    try:
        log.debug('Initializing NVML...')
        nvmlInit()

        log.info('Started with nVidia driver version = %s', 
                 nvmlSystemGetDriverVersion())

        device_count = nvmlDeviceGetCount()
        log.debug('%d devices found.', device_count)

        if args.port:
            log.debug('Starting http server on port %d', args.port)
            start_http_server(args.port)
            log.info('HTTP server started on port %d', args.port)

        while True:

            iteration += 1
            log.debug('Current iteration = %d', iteration)

            for i in range(device_count):
                log.debug('Analyzing device %d...', i)
                try:
                    log.debug('Obtaining handle for device %d...', i)
                    handle = nvmlDeviceGetHandleByIndex(i)
                    log.debug('Device handle for %d is %s', i, str(handle))

                    log.debug('Querying for memory information...')
                    mem_info = nvmlDeviceGetMemoryInfo(handle)
                    log.debug('Memory information = %s', str(mem_info))

                    total_fb_memory.labels(device=i).set(mem_info.total / 1024)
                    free_fb_memory.labels(device=i).set(mem_info.free / 1024)
                    used_fb_memory.labels(device=i).set(mem_info.used / 1024)

                    log.debug('Obtaining utilization statistics...')
                    utilization = nvmlDeviceGetUtilizationRates(handle)
                    log.debug('Utilization statistics = %s', str(utilization))

                    gpu_utilization.labels(device=i).set(utilization.gpu / 100.0)
                    memory_utilization.labels(device=i).set(utilization.memory / 100.0)
                except Exception as e:
                    log.warning(e, exc_info=True)

            if args.gateway:
                log.debug('Pushing metrics to gateway at %s...', args.gateway)
                hostname = platform.node()
                push_to_gateway(args.gateway, job=hostname, registry=core.REGISTRY)
                log.debug('Push complete.')
                
            time.sleep(args.update_period)
        

    except Exception as e:
        log.error('Exception thrown - %s', e, exc_info=True)
    finally:
        nvmlShutdown()
示例#31
0
#!/usr/bin/env python3
#coding:utf-8

import prometheus_client
from prometheus_client import Counter, Gauge
import logging, datetime, logging.config
import tools
from os import path
from flask import Response, Flask
import configparser
from loguru import logger

app = Flask(__name__)
web_code = Gauge("web_code", "Web code of value",
                 ["project", "env", "service_name", "host"])  # 数值可大可小


#metrics监控
@app.route("/metrics")
def metrics():
    #sop project
    sop_urls = ["http://*****:*****@10.80.82.203:30622/"]
    for index, url in enumerate(sop_urls):
        code = tools.get_content(url)
        web_code.labels("sop", "prod", "eurake" + str(index), url).set(code)
        logger.info(prometheus_client.generate_latest(web_code))

    #ai project
    ai_urls = {
        "ai-gpu-prod": "http://47.103.96.111:9081/health_check",
        "ai-video-prod": "http://47.103.96.111:9083/health_check",
示例#32
0
from prometheus_client import Gauge
import pandas as pd
import datetime
from extra_metrics.compliance import ClientCompliance
from extra_metrics.logs import logger

device_checkin_days = Gauge(
    'extra_metrics_devices_by_checkin_days',
    'various interesting stats on a per device basis, days since checked, compliance status',
    [
        "days",
    ])

device_client_modelnumber = Gauge(
    'extra_metrics_per_device_modelnum',
    'provides a value of the model number per device', ["device_name"])

device_client_compliance = Gauge(
    'extra_metrics_per_device_compliance',
    'provides a value of the compliance state per device, used for device health graph',
    ["compliance"])

device_client_version = Gauge('extra_metrics_per_device_client_version',
                              'number of devices rolled up by client version',
                              ["fw_client_version"])

device_client_platform = Gauge('extra_metrics_per_device_platform',
                               'number of devices rolled up by platform',
                               ["platform"])

device_client_tracked = Gauge('extra_metrics_per_device_tracked',
示例#33
0
# port to listen on
PORT = int(os.environ.get('PORT', 3001))

# URL of the GitLab instance, defaults to hosted GitLab
URL = str(os.environ.get('URL', 'https://gitlab.com'))

# Secret token for the app to authenticate itself
TOKEN = str(os.environ.get('TOKEN'))

# Login to GitLab
gl = gitlab.Gitlab(URL, TOKEN)
gl.auth()

# Initialize Prometheus instrumentation
projects_total = Gauge('gitlab_projects_total', 'Number of projects')
builds_total = Gauge('gitlab_builds_total', 'Number of builds',
                     ['project_id', 'project_name'])
build_duration_seconds = Summary(
    'gitlab_build_duration_seconds', 'Seconds the build took to run',
    ['project_id', 'project_name', 'stage', 'status', 'ref'])
open_issues_total = Gauge('gitlab_open_issues_total', 'Number of open issues',
                          ['project_id', 'project_name'])
pipeline_duration_seconds = Summary(
    'gitlab_pipeline_duration_seconds', 'Seconds the pipeline took to run',
    ['project_id', 'project_name', 'status', 'ref'])


def get_projects():
    try:
        projects = gl.projects.list(all=True)
示例#34
0
 def __init__(self, metrics_name, points):
     self.metrics = Gauge(metrics_name, '...', points)
示例#35
0
import logging

from datetime import datetime

from tabi.core import InternalMessage

from kafka.consumer import KafkaConsumer
from kafka import KafkaClient
from kafka.common import ProduceRequest
from kafka.protocol import create_message

from prometheus_client import Counter, Gauge, start_http_server


raw_bgp_messages = Counter("raw_bgp_messages", "all the BGP messages", ["collector", "peer_as"])
latency = Gauge("latency", "BGP peers latency", ["collector", "peer_as"])


logger = logging.getLogger(__name__)

RIPE_SERVERS = ["node{}.kafka.ris.ripe.net".format(i) for i in range(1, 6)]


PARTITIONS = {
    "rrc18": 0,
    "rrc19": 1,
    "rrc20": 2,
    "rrc21": 3,
}

示例#36
0
文件: registry.py 项目: onyb/trinity
    def __init__(self, registry: CollectorRegistry) -> None:
        #
        # Interop
        #

        # libp2p_peers
        self.libp2p_peers = Gauge("libp2p_peers",
                                  "Tracks number of libp2p peers",
                                  registry=registry)  # noqa: E501

        # On slot transition
        self.beacon_slot = Gauge("beacon_slot",
                                 "Latest slot of the beacon chain state",
                                 registry=registry)  # noqa: E501

        # On block transition
        self.beacon_head_slot = Gauge(
            "beacon_head_slot",
            "Slot of the head block of the beacon chain",
            registry=registry,
        )  # noqa: E501
        self.beacon_head_root = Gauge(
            "beacon_head_root",
            "Root of the head block of the beacon chain",
            registry=registry,
        )  # noqa: E501

        # On epoch transition
        self.beacon_previous_justified_epoch = Gauge(
            "beacon_previous_justified_epoch",
            "Current previously justified epoch",
            registry=registry,
        )  # noqa: E501
        self.beacon_previous_justified_root = Gauge(
            "beacon_previous_justified_root",
            "Current previously justified root",
            registry=registry,
        )  # noqa: E501
        self.beacon_current_justified_epoch = Gauge(
            "beacon_current_justified_epoch",
            "Current justified epoch",
            registry=registry,
        )  # noqa: E501
        self.beacon_current_justified_root = Gauge(
            "beacon_current_justified_root",
            "Current justified root",
            registry=registry)  # noqa: E501
        self.beacon_finalized_epoch = Gauge("beacon_finalized_epoch",
                                            "Current finalized epoch",
                                            registry=registry)  # noqa: E501
        self.beacon_finalized_root = Gauge("beacon_finalized_root",
                                           "Current finalized root",
                                           registry=registry)  # noqa: E501

        #
        # Other
        #

        # Validator
        self.validator_proposed_blocks = Counter(
            "validator_proposed_blocks",
            "counter of proposed blocks",
            registry=registry)  # noqa: E501
        self.validator_sent_attestation = Counter(
            "validator_sent_attestation",
            "counter of attested",
            registry=registry)  # noqa: E501
from prometheus_client import Gauge, Counter
from contextlib import contextmanager

active_conns = Gauge("replayserver_active_connections_count",
                     "Count of currently active connections.", ["category"])
served_conns = Counter("replayserver_served_connections_total",
                       "How many connections we served to completion.",
                       ["result"])

running_replays = Gauge("replayserver_running_replays_count",
                        "Count of currently running replays.")
finished_replays = Counter("replayserver_finished_replays_total",
                           "Number of replays ran to completion.")
saved_replays = Counter("replayserver_saved_replay_files_total",
                        "Total replays successfully saved to disk.")


@contextmanager
def track(metric):
    try:
        metric.inc()
        yield
    finally:
        metric.dec()
示例#38
0
from prometheus_client import CollectorRegistry, Gauge, push_to_gateway

registry = CollectorRegistry()
g = Gauge('mktemp_job_last_success_unixtime', 'Last time a batch job successfully finished', registry=registry)
g.set_to_current_time()
push_to_gateway('localhost:9091', job='mktemp', registry=registry)
示例#39
0
 def add_guage(self, latest_weather):
     for key, value in latest_weather.iteritems():
         name = self.to_underscore(key)
         self.guages["{}".format(key)] = Gauge(
             "weather_{}".format(name), "Current Weather {}".format(name),
             ['city'])
示例#40
0
from aiohttp import web
from prometheus_client import (
    REGISTRY,
    Counter,
    Gauge,
    Histogram,
    generate_latest,
)

CLIENT_CONNECTIONS = Gauge(
    'hpfeeds_broker_client_connections',
    'Number of clients connected to broker',
)

CONNECTION_MADE = Counter(
    'hpfeeds_broker_connection_made',
    'Number of connections established',
)

CONNECTION_READY = Counter(
    'hpfeeds_broker_connection_ready',
    'Number of connections established + authenticated',
    ['ident'],
)

CONNECTION_ERROR = Counter(
    'hpfeeds_broker_connection_error',
    'Number of connections that experienced a protocol error',
    ['ident', 'category'],
)
示例#41
0
import vaping
import vaping.plugins
from builtins import str
from prometheus_client import start_http_server, Summary, Counter, Gauge

min_latency = Summary('minimum_latency_milliseconds',
                      'Minimum latency in milliseconds.', ['host'])  # NOQA
max_latency = Summary('maximum_latency_milliseconds',
                      'Maximum latency in milliseconds.', ['host'])  # NOQA
avg_latency = Summary('average_latency_milliseconds',
                      'Average latency in milliseconds.', ['host'])  # NOQA
sent_packets = Counter('number_of_packets_sent',
                       'Number of pings sent to host.', ['host'])  # NOQA
packet_loss = Gauge('packet_loss', '% packet loss to host (0-100)',
                    ['host'])  # NOQA


@vaping.plugin.register('prometheus')
class Prometheus(vaping.plugins.EmitBase):
    def init(self):
        self.log.debug('init prometheus plugin')
        port = self.pluginmgr_config.get('port', 9099)
        start_http_server(port)

    def emit(self, data):
        raw_data = data.get('data')
        self.log.debug("data: " + str(raw_data))
        for host_data in raw_data:
            host_name = host_data.get('host')
            min_latency.labels(host_name).observe(host_data.get('min'))
            max_latency.labels(host_name).observe(host_data.get('max'))
示例#42
0
from awx.conf.license import get_license
from awx.main.utils import (get_awx_version, get_ansible_version)
from awx.main.analytics.collectors import (
    counts,
    instance_info,
    job_instance_counts,
    job_counts,
)

REGISTRY.unregister(PROCESS_COLLECTOR)
REGISTRY.unregister(PLATFORM_COLLECTOR)
REGISTRY.unregister(GC_COLLECTOR)

SYSTEM_INFO = Info('awx_system', 'AWX System Information')
ORG_COUNT = Gauge('awx_organizations_total', 'Number of organizations')
USER_COUNT = Gauge('awx_users_total', 'Number of users')
TEAM_COUNT = Gauge('awx_teams_total', 'Number of teams')
INV_COUNT = Gauge('awx_inventories_total', 'Number of inventories')
PROJ_COUNT = Gauge('awx_projects_total', 'Number of projects')
JT_COUNT = Gauge('awx_job_templates_total', 'Number of job templates')
WFJT_COUNT = Gauge('awx_workflow_job_templates_total',
                   'Number of workflow job templates')
HOST_COUNT = Gauge('awx_hosts_total', 'Number of hosts', [
    'type',
])
SCHEDULE_COUNT = Gauge('awx_schedules_total', 'Number of schedules')
INV_SCRIPT_COUNT = Gauge('awx_inventory_scripts_total',
                         'Number of invetory scripts')
USER_SESSIONS = Gauge('awx_sessions_total', 'Number of sessions', [
    'type',
示例#43
0
from celery import Celery
from celery.events.receiver import EventReceiver
from celery.utils.objects import FallbackContext
import amqp.exceptions
import httpx

logging.basicConfig(level=logging.INFO)

app = Celery("overseer", broker=os.environ["BROKER_URL"])

# Monitoring metrics (these are updated by `Receiver` and `Collector` below)

event_processing = Summary("overseer_event_processing",
                           "Summary of event processing duration")

queue_length = Gauge("overseer_queue_length", "Number of jobs in the queue.",
                     ["queue"])

workers_count = Gauge("overseer_workers_count",
                      "Number of workers listening to the queue.", ["queue"])

queue_length_worker_ratio = Gauge(
    "overseer_queue_length_worker_ratio",
    "Ratio of the number of jobs to the number of workers for each queue.",
    ["queue"],
)

# Setup API client
api = httpx.Client(
    base_url=os.path.join(os.environ["DIRECTOR_URL"], "api/"),
    headers={
        "content-type": "application/json",
示例#44
0
文件: prometheus.py 项目: 20c/vaping
import vaping
import vaping.plugins

min_latency = Summary(
    "minimum_latency_milliseconds", "Minimum latency in milliseconds.", ["host"]
)  # NOQA
max_latency = Summary(
    "maximum_latency_milliseconds", "Maximum latency in milliseconds.", ["host"]
)  # NOQA
avg_latency = Summary(
    "average_latency_milliseconds", "Average latency in milliseconds.", ["host"]
)  # NOQA
sent_packets = Counter(
    "number_of_packets_sent", "Number of pings sent to host.", ["host"]
)  # NOQA
packet_loss = Gauge("packet_loss", "% packet loss to host (0-100)", ["host"])  # NOQA


@vaping.plugin.register("prometheus")
class Prometheus(vaping.plugins.EmitBase):
    def init(self):
        self.log.debug("init prometheus plugin")
        port = self.pluginmgr_config.get("port", 9099)
        start_http_server(port)

    def emit(self, data):
        raw_data = data.get("data")

        self.log.debug("data: " + str(raw_data))
        for host_data in raw_data:
示例#45
0
 def initialize(self, artifacts):
     self._req_count = Counter("my_req_count", "Number of incoming request")
     self._temp = Gauge("my_gauge", "Number of incoming request")
示例#46
0
import logging
from prometheus_client import Gauge

eth_block_number = Gauge('eth_block_number',
                         'The number of most recent block.')
net_peers = Gauge('net_peers',
                  'The number of peers currently connected to the client.')
parity_net_active_peers = Gauge('parity_net_active_peers',
                                'The number of active peers.')
parity_net_connected_peers = Gauge(
    'parity_net_connected_peers',
    'The number of peers currently connected to the client. Available only for Parity'
)


def update_metrics(parity):
    total_peers, active_peers, connected_peers = parity.parity_net_peers()
    net_peers.set(total_peers)
    parity_net_active_peers.set(active_peers)
    parity_net_connected_peers.set(connected_peers)

    eth_block_number.set(parity.eth_blockNumber())

    logging.info('Metric updated')
示例#47
0
class PrometheusGaugeMetrics(object):
    def __init__(self, metrics_name, points):
        self.metrics = Gauge(metrics_name, '...', points)

    def update(self, labels, value):
        return self.metrics.labels(**labels).set(value)
    metric_init = pc.get_current_metric_value(metric_name=metric)
    for unique_metric in metric_init:
        PREDICTOR_MODEL_LIST.append(
            model.MetricPredictor(unique_metric,
                                  Configuration.rolling_data_window_size))

# A gauge set for the predicted values
GAUGE_DICT = dict()
for predictor in PREDICTOR_MODEL_LIST:
    unique_metric = predictor.metric
    label_list = list(unique_metric.label_config.keys())
    label_list.append("value_type")
    if unique_metric.metric_name not in GAUGE_DICT:
        GAUGE_DICT[unique_metric.metric_name] = Gauge(
            unique_metric.metric_name + "_" + predictor.model_name,
            predictor.model_description,
            label_list,
        )


class MainHandler(tornado.web.RequestHandler):
    async def get(self):
        # update metric value on every request and publish the metric
        for predictor_model in PREDICTOR_MODEL_LIST:
            # get the current metric value so that it can be compared with the
            # predicted values
            current_metric_value = Metric(
                pc.get_current_metric_value(
                    metric_name=predictor_model.metric.metric_name,
                    label_config=predictor_model.metric.label_config,
                )[0])
示例#49
0
    'subscriptionId',
    'clientState',
    'changeType',
    'resource',
    'dataType',
    'url',
    'id',
])

if PROMETHEUS:
    SUBSCR_COUNT = Counter('kopano_mfr_kopano_total_subscriptions',
                           'Total number of subscriptions')
    SUBSCR_EXPIRED = Counter('kopano_mfr_kopano_total_expired_subscriptions',
                             'Total number of subscriptions which expired')
    SUBSCR_ACTIVE = Gauge('kopano_mfr_kopano_active_subscriptions',
                          'Number of active subscriptions',
                          multiprocess_mode='liveall')
    PROCESSOR_BATCH_HIST = Histogram(
        'kopano_mfr_kopano_webhook_batch_size',
        'Number of webhook posts processed in one batch')
    POST_COUNT = Counter('kopano_mfr_kopano_total_webhook_posts',
                         'Total number of webhook posts')
    POST_ERRORS = Counter('kopano_mfr_kopano_total_webhook_post_errors',
                          'Total number of webhook post errors')
    POST_HIST = Histogram('kopano_mfr_kopano_webhook_post_duration_seconds',
                          'Duration of webhook post requests in seconds')
    DANGLING_COUNT = Counter(
        'kopano_mfr_kopano_total_broken_subscription_conns',
        'Total number of broken subscription connections')
    QUEUE_SIZE_GAUGE = Gauge('kopano_mfr_kopano_subscription_queue_size',
                             'Current size of subscriptions processor queue',
示例#50
0
文件: http.py 项目: hannojg/sygnal
PUSHGATEWAY_HTTP_RESPONSES_COUNTER = Counter(
    "sygnal_pushgateway_status_codes",
    "HTTP Response Codes given on the Push Gateway API",
    labelnames=["code"],
)

NOTIFY_HANDLE_HISTOGRAM = Histogram(
    "sygnal_notify_time",
    "Time taken to handle /notify push gateway request",
    labelnames=["code"],
)

REQUESTS_IN_FLIGHT_GUAGE = Gauge(
    "sygnal_requests_in_flight",
    "Number of HTTP requests in flight",
    labelnames=["resource"],
)


class V1NotifyHandler(Resource):
    def __init__(self, sygnal):
        super().__init__()
        self.sygnal = sygnal

    isLeaf = True

    def _make_request_id(self):
        """
        Generates a request ID, intended to be unique, for a request so it can
        be followed through logging.
import json
import os
import time
import urllib.parse
import re

from prometheus_client import Gauge

from tornado import gen
from tornado.httpclient import AsyncHTTPClient, HTTPError
from tornado.httputil import url_concat

from traitlets import Dict, Unicode, Bool, default, List
from traitlets.config import LoggingConfigurable

GITHUB_RATE_LIMIT = Gauge('binderhub_github_rate_limit_remaining', 'GitHub rate limit remaining')
SHA1_PATTERN = re.compile(r'[0-9a-f]{40}')


def tokenize_spec(spec):
    """Tokenize a GitHub-style spec into parts, error if spec invalid."""

    spec_parts = spec.split('/', 2)  # allow ref to contain "/"
    if len(spec_parts) != 3:
        msg = 'Spec is not of the form "user/repo/ref", provided: "{spec}".'.format(spec=spec)
        if len(spec_parts) == 2 and spec_parts[-1] != 'master':
            msg += ' Did you mean "{spec}/master"?'.format(spec=spec)
        raise ValueError(msg)

    return spec_parts
示例#52
0
import requests
import os
import time
from prometheus_client import start_http_server, Gauge, Info

TOKEN = os.environ["AQICN_TOKEN"]
CITIES = os.environ["CITIES"].lower().split(",")

aqi = Gauge('aqi_external', 'AQI from waqi', ['name'])
pm25 = Gauge('pm25_external', 'PM25 from waqi', ['name'])
temp = Gauge('temp_external', 'Temperature from waqi', ['name'])
humidity = Gauge('humidity_external', 'humidity from waqi', ['name'])


def exit_with_error(error):
    sys.exit(error)


if __name__ == '__main__':
    port_number = 8000


def metrics_by_city(city, token):
    print("Scraping %s" % city)
    response = requests.get('https://api.waqi.info/feed/%s/?token=%s' %
                            (city, token))

    js_data = response.json()["data"]
    if isinstance(js_data, str):
        print("Error with %s: %s" % (city, js_data))
        return
示例#53
0
def gather_data(namespace, run_event):

    g_cpu_usage = Gauge("cpu_cumulative_usage", "CPU Cumulative Usage", ["service", "instance"])
    g_cpu_utilization = Gauge('cpu_utilization', "CPU utilization", ["service", "instance"])
    g_memory_usage = Gauge('memory_usage', "Memory Usage", ["servie", "instance"])
    g_memory_utilization = Gauge('memory_utilization', "Memory Utilization", ["service", "instance"])

    while run_event.is_set():
	
	service_list = alauda_service_list(namespace)
        for service_inst in service_list:
            service_name = service_inst.name
            instance_list = alauda_instance_list(namespace, service_name)
            for instance in instance_list:
                end_time = int(time.time()) - 30
                start_time = str(end_time - 100) #gather data every 1 minute, ensure we can get at least one metric
		end_time = str(end_time)
                data = alauda_get_instance_metrics(namespace, service_name, instance['uuid'], start_time, end_time, "1m")
                if data:
		    g_cpu_usage.labels(service_name, instance['instance_name']).set(data['points'][0][1])
                    g_cpu_utilization.labels(service_name, instance['instance_name']).set(data['points'][0][2])
                    g_memory_usage.labels(service_name, instance['instance_name']).set(data['points'][0][3])
                    g_memory_utilization.labels(service_name, instance['instance_name']).set(data['points'][0][4])

        time.sleep(20)
示例#54
0
from prometheus_client import (
    CollectorRegistry,
    Counter,
    Gauge,
    Summary,
    push_to_gateway,
)

# A separate registry is used, as the default registry may contain other
# metrics such as those from the Process Collector.
REGISTRY = CollectorRegistry()

JOB_DURATION = Summary('my_batch_job_duration_seconds',
                       'Duration of my batch job in seconds.',
                       registry=REGISTRY)
RESULT = Gauge('my_batch_job_result', 'This is a test', registry=REGISTRY)
LAST_SUCCESS = Gauge('my_batch_job_last_success_unixtime',
                     'Last time my batch job succeeded, in unixtime.',
                     registry=REGISTRY)


@JOB_DURATION.time()
def main():
    if len(sys.argv) < 2:
        print("Usage: {} <Prometheus Pushgateway:port>".format(sys.argv[0]))
        return
    # Simulate some work
    time.sleep(random.random())
    # Update metrics
    RESULT.set(random.random())
    # Update success timestamp
示例#55
0
    SCMPTooManyHopByHop,
    SCMPUnspecified,
)
from lib.packet.scmp.types import SCMPClass
from lib.packet.scmp.util import scmp_type_name
from lib.socket import ReliableSocket, SocketMgr, TCPSocketWrapper
from lib.tcp.socket import SCIONTCPSocket, SockOpt
from lib.thread import thread_safety_net, kill_self
from lib.trust_store import TrustStore
from lib.types import AddrType, L4Proto, PayloadClass
from lib.topology import Topology
from lib.util import hex_str, sleep_interval


# Exported metrics.
PKT_BUF_TOTAL = Gauge("se_pkt_buf_total", "Total packets in input buffer",
                      ["server_id", "isd_as"])
PKT_BUF_BYTES = Gauge("se_pkt_buf_bytes", "Memory usage of input buffer",
                      ["server_id", "isd_as"])
PKTS_DROPPED_TOTAL = Counter("se_packets_dropped_total", "Total packets dropped",
                             ["server_id", "isd_as"])
UNV_SEGS_TOTAL = Gauge("se_unverified_segs_total", "# of unverified segments",
                       ["server_id", "isd_as"])
PENDING_TRC_REQS_TOTAL = Gauge("se_pending_trc_reqs", "# of pending TRC requests",
                               ["server_id", "isd_as"])
PENDING_CERT_REQS_TOTAL = Gauge("se_pending_cert_reqs", "# of pending CERT requests",
                                ["server_id", "isd_as"])
CONNECTED_TO_DISPATCHER = Gauge(
    "se_connected_to_dispatcher",
    "Is the element successfully registered with the dispatcher.",
    ["server_id", "isd_as"])
示例#56
0
import re
import os

from django.conf import settings
from django.http.response import HttpResponse
from django.views import View
from prometheus_client import Gauge
from prometheus_client.exposition import generate_latest
from grantnav.index import get_index

from grantnav.frontend.views import totals_query

NUM_ERRORS_LOGGED = Gauge(
    "total_import_errors_logged", "Total number of errors logged by last import"
)

TOTAL_GRANTS = Gauge(
    "total_grants", "Total number of grants in the system"
)


class ServiceMetrics(View):
    def _num_errors_log(self):
        errors = 0

        log_dir = getattr(settings, "GRANTNAV_LOG_DIR")
        index = get_index()

        search_term = re.compile("failure|failed|exception|error", re.IGNORECASE)

        log_file = os.path.join(log_dir, "load_%s.log" % index)
示例#57
0
    if len(lines) != 2:
        return False, 0

    if lines[0].find('YES') == -1:
        return False, 0

    d = lines[1].strip().split('=')

    if len(d) != 2:
        return False, 0

    return True, int(d[1])


if __name__ == '__main__':
    gf = Gauge('backyard_temperature_f',
               'Temperature of backyard in degrees F')
    gc = Gauge('backyard_temperature_c',
               'Temperature of backyard in degrees C')
    devices = find_devices()

    start_http_server(8000)

    while True:
        for device in devices:
            valid, raw = read_temp(device)

            if valid:
                c = raw / 1000.0
                f = celsius_to_fahrenheit(c)
                #print('{:0.2f} F'.format(f))
                #print('{:0.2f} C'.format(c))
示例#58
0
    121726070319: 'east',
    121726070375: 'west',
    121727000255: 'south',
    121726070274: 'west',
    121726070045: 'east',
    121726069685: 'south',
    121726070431: 'south',
    121727000392: 'south',
    121726070213: 'south',
    121726069957: 'west',
    121726069138: 'south',
}


stream_gauges = {
    'p': Gauge('meter_active_power_watts', 'Active Power', ['type', 'phase']),
    'q': Gauge('meter_reactive_power_watts', 'Reactive Power', ['type', 'phase']),
    's': Gauge('meter_apparent_power_watts', 'Apparent Power', ['type', 'phase']),
    'v': Gauge('meter_voltage_volts', 'Voltage', ['type', 'phase']),
    'i': Gauge('meter_current_amps', 'Current', ['type', 'phase']),
    'f': Gauge('meter_frequency_hertz', 'Frequency', ['type', 'phase']),
    'pf': Gauge('meter_power_factor_ratio', 'Power Factor', ['type', 'phase']),
}

production_gauges = {
    'activeCount': Gauge('production_active_count', 'Active Count', ['type']),
    'wNow': Gauge('power_now_watts', 'Active Count', ['type']),
    'whToday': Gauge('production_today_watthours', 'Total production today', ['type']),
    'whLastSevenDays': Gauge('production_7days_watthours', 'Total production last seven days', ['type']),
    'whLifetime': Gauge('production_lifetime_watthours', 'Total production lifetime', ['type']),
}
示例#59
0
import socket
import sys
import threading
import time
from collections import namedtuple
import urllib.request, urllib.error, urllib.parse

from cachetools.func import lru_cache

from flask import g, request
from prometheus_client import push_to_gateway, REGISTRY, Histogram, Gauge, Counter

logger = logging.getLogger(__name__)

# DB connections
db_pooled_connections_in_use = Gauge("quay_db_pooled_connections_in_use",
                                     "number of pooled db connections in use")
db_pooled_connections_available = Gauge(
    "quay_db_pooled_connections_available",
    "number of pooled db connections available")
db_connect_calls = Counter(
    "quay_db_connect_calls",
    "number of connect() calls made to db",
)
db_close_calls = Counter(
    "quay_db_close_calls",
    "number of close() calls made to db",
)

request_duration = Histogram(
    "quay_request_duration_seconds",
    "seconds taken to process a request",
示例#60
0
 password = environ["TADO_PASSWORD"]
 client_secret = environ["TADO_CLIENT_SECRET"]
 # 3 minutes seems the default tado app value
 refresh_rate = int(environ.get("TADO_EXPORTER_REFRESH_RATE", 180))
 print("Starting tado exporter")
 start_http_server(8000)
 print("Connecting to tado API using account " + username)
 try:
     tado = Tado(username, password, client_secret)
 except KeyError:
     print(
         "Authentication failed. Check your username, password or client secret."
     )
     exit(1)
 temp = Gauge('tado_temperature',
              'Temperature as read by the sensor',
              labelnames=['zone_name'],
              unit='celsius')
 humi = Gauge('tado_humidity',
              'Humidity as read by the sensor',
              labelnames=['zone_name'],
              unit='percentage')
 heat = Gauge('tado_heating',
              'Heating power',
              labelnames=['zone_name'],
              unit='percentage')
 print("Exporter ready")
 while True:
     try:
         for zone in tado.get_zones():
             temp.labels('zone_' + str(zone['id'])).set(
                 tado.get_state(zone['id'])['sensorDataPoints']