repo init

Signed-off-by: Zen <[email protected]>

Author: desultory

.gitignore

@@ -0,0 +1,7 @@
+*.swp
+*.swo
+__pycache__/*
+*.pyc
+build/*
+dist/*
+*.egg-info/

LICENSE

@@ -0,0 +1,19 @@
+
+listen_ip = '0.0.0.0'
+listen_port = 9999
+
+[metrics.test]
+type = "counter"
+value = 1
+help = "test counter"
+
+[metrics.test.labels]
+asdf = "1234"
+
+[metrics.abcd]
+type = "gauge"
+value = 2
+help = "test gauge"
+
+[labels]
+test = "test"

config.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "prometheus_exporter"
+version = "0.3.0"
+authors = [
+  { name="Desultory", email="[email protected]" },
+]
+description = "A Python library for exporting data as metrics for Prometheus"
+readme = "readme.md"
+requires-python = ">=3.11"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: GNU General Public License v2 (GPLv2)",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "zenlib >= 1.1.1"
+]
+
+[project.scripts]
+prometheus_exporter = "prometheus_exporter.main:main"

pyproject.toml

@@ -0,0 +1,3 @@
+from .exporter import Exporter
+
+__all__ = ['Exporter']

src/prometheus_exporter/__init__.py

@@ -0,0 +1,106 @@
+"""
+Basic exporter class for prometheus metrics.
+Runs a ThreadingHTTPServer with a PrometheusRequest handler.
+The PrometheusRequest handler processes requests from Promotheus, by default returns server.export().
+The server.export() method goes through all defined metrics and returns them as a string.
+If a dict is passed to the export method, it will be used to filter by that label.
+"""
+
+from http.server import ThreadingHTTPServer
+from pathlib import Path
+
+from zenlib.logging import loggify
+
+from .labels import Labels
+from .metric import Metric
+from .prometheus_request import PrometheusRequest
+
+DEFAULT_IP = '127.0.0.1'
+DEFAULT_PORT = 9809
+
+
+@loggify
+class Exporter(ThreadingHTTPServer):
+    """
+    Basic prometheus metric exporter class.
+    Extends the ThreadingHTTPServer class.
+    Forces use of the PrometheusRequest RequestHandlerClass.
+    Reads a config.toml file to read the server port and ip.
+    If 'ip' and 'port' are passed as kwargs, they will override the config file.
+    """
+    def __init__(self, config_file='config.toml', labels=Labels(), *args, **kwargs):
+        self.labels = Labels(dict_items=labels, logger=self.logger, _log_init=False)
+        self.metrics = []
+        self.config_file = Path(config_file)
+        self.read_config()
+
+        kwargs['RequestHandlerClass'] = PrometheusRequest
+        ip = self.config['listen_ip'] if 'ip' not in kwargs else kwargs.pop('ip', DEFAULT_IP)
+        port = self.config['listen_port'] if 'port' not in kwargs else kwargs.pop('port', DEFAULT_PORT)
+        kwargs['server_address'] = (ip, port)
+
+        super().__init__(*args, **kwargs)
+
+    def __setattr__(self, name, value):
+        if name == 'labels' and not isinstance(value, Labels):
+            raise ValueError("Labels must be a dict.")
+        super().__setattr__(name, value)
+
+    def read_config(self):
+        """ Reads the config file defined in self.config_file """
+        from tomllib import load
+        with open(self.config_file, 'rb') as config:
+            self.config = load(config)
+
+        self.logger.info("Read config file: %s", self.config_file)
+        self.labels.update(self.config.get('labels', {}))
+
+        self.add_metrics()
+
+    def add_metrics(self):
+        """ Adds all defined metrics to the exporter. """
+        for name, values in self.config.get('metrics', {}).items():
+            kwargs = {'metric_type': values.pop('type'), 'labels': self.labels.copy(),
+                      'logger': self.logger, '_log_init': False}
+
+            # Add labels specified under the metric to ones in the exporter
+            if labels := values.pop('labels', None):
+                kwargs['labels'].update(labels)
+
+            self.logger.info("Adding metric: %s", name)
+            self.metrics.append(Metric(name=name, **kwargs, **values))
+
+    def get_metrics(self):
+        """
+        Gets all defined metrics.
+        """
+        return [metric for metric in Metric.metrics]
+
+    def _filter_metrics(self, metrics, label_filter):
+        """
+        Filters a list of metrics by a label_filter.
+        """
+        for label_name, label_value in label_filter.items():
+            if label_name not in self.labels.global_labels:
+                raise ValueError("label_filter contains unknown label: %s", label_name)
+            if label_value not in self.labels.global_labels[label_name]:
+                raise ValueError("[%s] label_filter contains unknown label value: %s" % (label_name, label_value))
+            return [metric for metric in metrics if metric.labels[label_name] == label_value]
+
+    def export(self, label_filter=None):
+        """
+        Go through ALL DEFINED metrics, turn them into a metric string for prometheus.
+        If a label_filter is passed, only return metrics that match the label_filter.
+        """
+        metrics = self.get_metrics()
+        if label_filter:
+            metrics = self._filter_metrics(metrics, label_filter)
+        return "\n".join([str(metric) for metric in metrics])
+
+    def handle_error(self, request, client_address):
+        """ Handle errors in the request handler. """
+        from sys import exc_info
+        from traceback import format_exception
+        self.logger.warning("[%s:%d] Error in request: %s" % (*client_address, exc_info()[1]))
+        exc = format_exception(*exc_info())
+        self.logger.debug(''.join(exc).replace(r'\n', '\n'))

src/prometheus_exporter/exporter.py

@@ -0,0 +1,56 @@
+"""
+Labels dictionary, used by both Metrics and Exporters.
+
+Each Labels dictionary only allows a label name to be set once.
+Labels are added to the global labels dictionary, which is used by
+the filter function in exporters.
+"""
+
+from zenlib.logging import loggify
+
+
+@loggify
+class Labels(dict):
+    """ A dictionary of labels, used by both Metrics and Exporters """
+    global_labels = {}
+
+    def __init__(self, dict_items={}, **kwargs):
+        """ Create a new Labels object from a dictionary """
+        self.update(dict_items)
+
+    def __setitem__(self, key, value):
+        self._check_label(key, value)
+        super().__setitem__(key, value)
+        self._update_global_labels(key, value)
+
+    def _update_global_labels(self, key, value):
+        """ Update the global labels with the labels in this dictionary """
+        if key not in Labels.global_labels:
+            Labels.global_labels[key] = [value]
+        else:
+            Labels.global_labels[key].append(value)
+
+    def update(self, new_labels):
+        """ Updates the labels with the new labels """
+        for key, value in new_labels.items():
+            self[key] = value
+            self.logger.debug("Added label %s=%s", key, value)
+
+    def _check_label(self, name: str, value: str):
+        """ Check that the label name and value are valid """
+        # Check that the label name is a string
+        if not isinstance(name, str):
+            raise TypeError('Label names must be strings')
+
+        # Check that the label name is not already defined
+        if name in self:
+            raise ValueError("Label is already defined: %s" % name)
+        # Check that the label value is a string
+        if not isinstance(value, str):
+            raise TypeError('Label values must be strings')
+
+    def __str__(self):
+        return ','.join(['%s="%s"' % (name, value) for name, value in self.items()])
+
+
+

src/prometheus_exporter/labels.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+
+from logging import getLogger, StreamHandler
+from argparse import ArgumentParser
+from signal import signal
+
+from .exporter import Exporter
+
+from zenlib.logging import ColorLognameFormatter
+
+
+def main():
+    argparser = ArgumentParser(prog='json_exporter', description='JSON Exporter for Prometheus')
+
+    argparser.add_argument('-d', '--debug', action='store_true', help='Debug mode.')
+    argparser.add_argument('-dd', '--verbose', action='store_true', help='Verbose debug mode.')
+
+    argparser.add_argument('-v', '--version', action='store_true', help='Print the version and exit.')
+
+    argparser.add_argument('-p', '--port', type=int, nargs='?', help='Port to listen on.')
+    argparser.add_argument('-a', '--address', type=str, nargs='?', help='Address to listen on.')
+
+    args = argparser.parse_args()
+
+    if args.version:
+        from importlib.metadata import version
+        print(f"{__package__} {version(__package__)}")
+        exit(0)
+
+    logger = getLogger(__package__)
+
+    if args.verbose:
+        logger.setLevel(5)
+        formatter = ColorLognameFormatter('%(levelname)s | %(name)-42s | %(message)s')
+    elif args.debug:
+        logger.setLevel(10)
+        formatter = ColorLognameFormatter('%(levelname)s | %(name)-42s | %(message)s')
+    else:
+        logger.setLevel(20)
+        formatter = ColorLognameFormatter()
+
+    handler = StreamHandler()
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+
+    kwargs = {'logger': logger}
+
+    if args.port:
+        kwargs['port'] = args.port
+    if args.address:
+        kwargs['ip'] = args.address
+
+    exporter = Exporter(**kwargs)
+
+    def handle_shutdown_signal(sig, frame):
+        logger.info(f"Received signal: {sig}. Shutting down...")
+        if hasattr(exporter, '__is_shut_down') and not exporter.__is_shut_down.is_set():
+            exporter.shutdown()
+        exit(0)
+
+    # Handle SIGINT, SIGTERM, SIGQUIT, SIGABRT
+    for sig in [2, 15, 3, 6]:
+        signal(sig, handle_shutdown_signal)
+
+    exporter.serve_forever()
+
+
+if __name__ == '__main__':
+    main()

src/prometheus_exporter/main.py

@@ -0,0 +1,80 @@
+"""
+Basic prometheus metric class
+"""
+
+from enum import Enum
+
+from zenlib.logging import loggify
+
+from .labels import Labels
+
+
+class MetricTypes(Enum):
+    """
+    Prometheus metric types
+    """
+    COUNTER = 'counter'
+    GAUGE = 'gauge'
+    UNTYPED = 'untyped'
+
+
+@loggify
+class Metric:
+    """
+    A class used to represent a prometheus metric.
+    Labels can be added to the metric by passing a dictionary as the labels argument.
+    The value defaults to 0.
+    """
+    metrics = []
+
+    def __init__(self, name, value=0, metric_type='untyped', help=None, labels=Labels(), *args, **kwargs):
+        """
+        Initialize the metric
+        """
+        if name in self.metrics:
+            raise ValueError("Metric name already exists: %s" % name)
+
+        self.name = name
+        self.type = metric_type
+        self.help = help
+        self.labels = Labels(labels, logger=self.logger, _log_init=False)
+        self.value = value
+        Metric.metrics.append(self)
+
+    def __del__(self):
+        """
+        Delete the metric from the metrics dictionary
+        """
+        Metric.metrics.remove(self)
+
+    def __setattr__(self, name, value):
+        """
+        Turn spaces in the name into underscores.
+        Set the metric type based on the MetricTypes enum.
+        """
+        if name == 'name':
+            value = value.replace(' ', '_')
+        if name == 'type':
+            value = MetricTypes[value.upper()]
+        if name == 'value':
+            if not isinstance(value, (int, float)):
+                raise TypeError('Value must be an integer or float')
+
+        super().__setattr__(name, value)
+
+    def __str__(self):
+        """
+        String representation of the metric
+        """
+        if self.help:
+            out_str = f'# HELP {self.name} {self.help}\n'
+        else:
+            out_str = ''
+
+        out_str += f'# TYPE {self.name} {self.type.value}\n{self.name}'
+
+        if self.labels:
+            out_str = f"{out_str}{{{self.labels}}}"
+
+        out_str += f' {self.value}'
+        return out_str