flexmetric 0.1.4__py3-none-any.whl → 0.3.0__py3-none-any.whl

flexmetric/metric_process/database_processing.py

@@ -2,15 +2,20 @@ import yaml
 import sqlite3
 import re
 
+
 def read_yaml_file(file_path):
-    with open(file_path, 'r') as f:
+    with open(file_path, "r") as f:
         return yaml.safe_load(f)
 
+
 def get_database_config(databases, db_name):
     for db in databases:
-        if db['name'] == db_name:
+        if db["name"] == db_name:
             return db
-    raise ValueError(f"[ERROR] Database config for '{db_name}' not found in database.yaml.")
+    raise ValueError(
+        f"[ERROR] Database config for '{db_name}' not found in database.yaml."
+    )
+
 
 def execute_sqlite_query(db_path, query):
     try:
@@ -24,11 +29,13 @@ def execute_sqlite_query(db_path, query):
         print(f"[ERROR] SQLite query failed on {db_path}: {e}")
         return None
 
+
 def is_safe_query(query):
     # Remove leading spaces and brackets
     cleaned_query = query.strip().lower()
     # Match only queries that start with "select"
-    return re.match(r'^\(*\s*select', cleaned_query) is not None
+    return re.match(r"^\(*\s*select", cleaned_query) is not None
+
 
 def process_database_queries(queries_file, databases_file):
     # Get queries from queries file
@@ -36,24 +43,26 @@ def process_database_queries(queries_file, databases_file):
     # Get database from database file
     databases_config = read_yaml_file(databases_file)
 
-    commands = queries_config.get('commands', [])
-    databases = databases_config.get('databases', [])
+    commands = queries_config.get("commands", [])
+    databases = databases_config.get("databases", [])
 
     all_results = []
 
     for cmd in commands:
         try:
-            db_conf = get_database_config(databases, cmd['database'])
+            db_conf = get_database_config(databases, cmd["database"])
 
-            if db_conf['db_type'] != 'sqlite':
-                print(f"[WARN] Unsupported database type: {db_conf['db_type']} in command {cmd['name']}")
+            if db_conf["db_type"] != "sqlite":
+                print(
+                    f"[WARN] Unsupported database type: {db_conf['db_type']} in command {cmd['name']}"
+                )
                 continue
 
-            db_path = db_conf['db_connection']
-            query = cmd['query']
-            label = cmd['label']
-            label_value = cmd['label_value']
-            # check if query is safe 
+            db_path = db_conf["db_connection"]
+            query = cmd["query"]
+            label = cmd["label"]
+            label_value = cmd["label_value"]
+            # check if query is safe
             if is_safe_query(query):
                 value = execute_sqlite_query(db_path, query)
             else:
@@ -62,14 +71,18 @@ def process_database_queries(queries_file, databases_file):
 
             if value is not None:
                 result = {
-                    'result': [{'label': label_value, 'value': value}],
-                    'labels': [label]
+                    "result": [{"label": label_value, "value": value}],
+                    "labels": [label],
                 }
                 all_results.append(result)
             else:
-                print(f"[INFO] No result for command '{cmd['name']}' on database '{cmd['database']}'")
+                print(
+                    f"[INFO] No result for command '{cmd['name']}' on database '{cmd['database']}'"
+                )
 
         except Exception as e:
-            print(f"[ERROR] Processing command '{cmd.get('name', 'unknown')}' failed: {e}")
+            print(
+                f"[ERROR] Processing command '{cmd.get('name', 'unknown')}' failed: {e}"
+            )
 
-    return all_results
+    return all_results

flexmetric/metric_process/expiring_queue.py

@@ -0,0 +1,56 @@
+from collections import deque
+import threading
+import time
+import sched
+
+class ExpiringMetricQueue:
+    def __init__(self, expiry_seconds=60, cleanup_interval=5):
+        self.queue = deque()
+        self.expiry_seconds = expiry_seconds
+        self.cleanup_interval = cleanup_interval
+        self.lock = threading.Lock()
+        self.scheduler = sched.scheduler(time.time, time.sleep)
+        self._start_cleanup()
+    
+    def put(self, metric):
+        metric['timestamp'] = time.time()
+        with self.lock:
+            self.queue.append(metric)
+    
+    def pop_all(self):
+        with self.lock:
+            items = list(self.queue)
+            self.queue.clear()
+            cleaned_items = []
+            for item in items:
+                cleaned_item = {k: v for k, v in item.items() if k != 'timestamp'}
+                cleaned_items.append(cleaned_item)
+
+            return cleaned_items
+    
+    def _start_cleanup_thread(self):
+        thread = threading.Thread(target=self._cleanup, daemon=True)
+        thread.start()
+    
+    def _start_cleanup(self):
+        def scheduled_cleanup():
+            self._cleanup()
+            # Schedule next run
+            self.scheduler.enter(self.cleanup_interval, 1, scheduled_cleanup)
+
+        # Schedule first run immediately
+        self.scheduler.enter(0, 1, scheduled_cleanup)
+        threading.Thread(target=self.scheduler.run, daemon=True).start()
+
+    def _cleanup(self):
+        current_time = time.time()
+        with self.lock:
+            original_len = len(self.queue)
+            self.queue = deque(
+                [item for item in self.queue if current_time - item['timestamp'] <= self.expiry_seconds]
+            )
+            cleaned = original_len - len(self.queue)
+            if cleaned > 0:
+                print(f"[MetricQueue] Cleaned {cleaned} expired metrics")
+
+metric_queue = ExpiringMetricQueue(expiry_seconds=60, cleanup_interval=60)

flexmetric/metric_process/process_commands.py

@@ -0,0 +1,111 @@
+import subprocess
+import yaml
+import re
+from flexmetric.logging_module.logger import get_logger
+
+logger = get_logger(__name__)
+
+logger.info("prometheus is running") 
+
+def read_commands_from_yaml(file_path):
+    with open(file_path, 'r') as f:
+        config = yaml.safe_load(f)
+    return config.get('commands', [])
+
+def execute_command_with_timeout(command, timeout):
+    try:
+        result = subprocess.run(command, shell=True, capture_output=True, text=True, timeout=timeout)
+        if result.returncode != 0:
+            logger.info(f"Exception in running the command {command}")
+            return ''
+        return result.stdout.strip()
+    except subprocess.TimeoutExpired:
+        return ''
+    except Exception as ex:
+        logger.error(f"Exception : {ex}")
+        return ''
+
+def parse_command_output(raw_output, label_column, value_column, fixed_label_value):
+    result_list = []
+    lines = raw_output.strip().splitlines()
+
+    for line in lines:
+        parts = line.strip().split()
+        if not parts:
+            continue
+
+        if label_column == 'fixed':
+            label = fixed_label_value or 'label'
+        else:
+            try:
+                label = parts[label_column]
+            except IndexError:
+                label = 'unknown'
+
+        try:
+            raw_value = parts[value_column]
+            cleaned_value = re.sub(r'[^\d\.\-]', '', raw_value)
+            value = float(cleaned_value) if cleaned_value else 1
+        except (IndexError, ValueError):
+            value = 1
+
+        result_list.append({'label': label, 'value': value})
+
+    return result_list
+
+def process_single_command(cmd_info):
+    command = cmd_info['command']
+    label_name = cmd_info['label']
+    timeout = cmd_info.get('timeout_seconds', 30)
+    label_column = cmd_info.get('label_column', -1)
+    value_column = cmd_info.get('value_column', 0)
+    fixed_label_value = cmd_info.get('label_value')
+
+    raw_output = execute_command_with_timeout(command, timeout)
+    if raw_output == '':
+        logger.warning(f"No results for command {command}")
+        return None
+
+    result_list = parse_command_output(raw_output, label_column, value_column, fixed_label_value)
+
+    return {
+        'result': result_list,
+        'labels': [label_name]
+    }
+
+def is_command_safe(command):
+    blacklist = ['rm', 'reboot', 'shutdown', 'halt', 'poweroff', 'mkfs', 'dd']
+    for dangerous_cmd in blacklist:
+        if dangerous_cmd in command.split():
+            return False
+    return True
+
+def process_commands(config_file):
+    commands = read_commands_from_yaml(config_file)
+    all_results = []
+
+    for cmd_info in commands:
+        command = cmd_info.get('command', '')
+        if not command:
+            logger.error("Command is missing in the configuration.")
+            continue
+
+        if not is_command_safe(command):
+            logger.warning(f"Command '{command}' is not allowed and will not be executed.")
+            continue
+
+        try:
+            formatted_result = process_single_command(cmd_info)
+            if formatted_result:
+                all_results.append(formatted_result)
+        except KeyError as e:
+            logger.error(f"Missing key in command configuration: {e}. Command: {cmd_info}")
+        except Exception as e:
+            logger.error(f"An error occurred while processing command '{command}': {e}")
+
+    return all_results
+
+# # Example usage:
+# if __name__ == "__main__":
+#     results = process_commands('/Users/nlingadh/code/custom_prometheus_agent/src/commands.yaml')
+#     print(results)

flexmetric/metric_process/prometheus_agent.py

@@ -1,57 +1,137 @@
 from prometheus_client import Gauge, start_http_server
-import psutil 
+import psutil
 import time
 import sys
 import os
-
-from flexmetric.config.configuration import CA_PATH , CERT_PATH, KEY_PATH
+from flexmetric.config.configuration import CA_PATH, CERT_PATH, KEY_PATH
 from flexmetric.logging_module.logger import get_logger
 from flexmetric.file_recognition.exec_file import execute_functions
 from flexmetric.metric_process.process_commands import process_commands
 from flexmetric.metric_process.database_processing import process_database_queries
+from flexmetric.metric_process.expiring_queue import metric_queue
 import argparse
 import os
+from flexmetric.metric_process.views import (
+    run_flask,
+    add_update_metric_route,
+    secure_flask_run,
+)
+import sched
+import threading
+
+scheduler = sched.scheduler(time.time, time.sleep)
+
+
 def arguments():
     parser = argparse.ArgumentParser(
-        description='FlexMetric: A flexible Prometheus exporter for commands, databases, scripts, and Python functions.'
+        description="FlexMetric: A flexible Prometheus exporter for commands, databases, scripts, and Python functions."
     )
 
     # Input type flags
-    parser.add_argument('--database', action='store_true', help='Process database.yaml and queries.yaml to extract metrics from databases.')
-    parser.add_argument('--commands', action='store_true', help='Process commands.yaml to extract metrics from system commands.')
-    parser.add_argument('--functions', action='store_true', help='Process Python functions from the provided path to extract metrics.')
-    
+    parser.add_argument(
+        "--database",
+        action="store_true",
+        help="Process database.yaml and queries.yaml to extract metrics from databases.",
+    )
+    parser.add_argument(
+        "--commands",
+        action="store_true",
+        help="Process commands.yaml to extract metrics from system commands.",
+    )
+    parser.add_argument(
+        "--functions",
+        action="store_true",
+        help="Process Python functions from the provided path to extract metrics.",
+    )
+    parser.add_argument(
+        "--expose-api",
+        action="store_true",
+        help="Expose Flask API to receive external metric updates.",
+    )
 
     # Config file paths
-    parser.add_argument('--database-config', type=str, default=None, help='Path to the database configuration YAML file.')
-    parser.add_argument('--queries-config', type=str, default=None, help='Path to the database queries YAML file.')
-    parser.add_argument('--commands-config', type=str, default=None, help='Path to the commands configuration YAML file.')
-    parser.add_argument('--functions-dir', type=str, default=None, help='Path to the python files dir.')
-    parser.add_argument('--functions-file', type=str, default=None, help='Path to the file containing which function to execute')
-    parser.add_argument('--port', type=int, default=8000, help='port on which exportor runs')
+    parser.add_argument(
+        "--database-config",
+        type=str,
+        default=None,
+        help="Path to the database configuration YAML file.",
+    )
+    parser.add_argument(
+        "--queries-config",
+        type=str,
+        default=None,
+        help="Path to the database queries YAML file.",
+    )
+    parser.add_argument(
+        "--commands-config",
+        type=str,
+        default=None,
+        help="Path to the commands configuration YAML file.",
+    )
+    parser.add_argument(
+        "--functions-dir", type=str, default=None, help="Path to the python files dir."
+    )
+    parser.add_argument(
+        "--functions-file",
+        type=str,
+        default=None,
+        help="Path to the file containing which function to execute",
+    )
+    parser.add_argument(
+        "--port", type=int, default=8000, help="port on which exportor runs"
+    )
+    parser.add_argument(
+        "--host",
+        type=str,
+        default="0.0.0.0",
+        help="The hostname or IP address on which to run the Flask server (default: 0.0.0.0)",
+    )
+    parser.add_argument(
+        "--enable-https",
+        action="store_true",
+        help="Enable HTTPS for Flask API using SSL certificates.",
+    )
+    parser.add_argument(
+        "--ssl-cert",
+        type=str,
+        help="Path to the SSL certificate file (cert.pem) for HTTPS.",
+    )
+    parser.add_argument(
+        "--ssl-key",
+        type=str,
+        help="Path to the SSL private key file (key.pem) for HTTPS.",
+    )
 
     return parser.parse_args()
 
+
 logger = get_logger(__name__)
 
-logger.info("prometheus is running") 
+logger.info("prometheus is running")
+
 
 def convert_to_data_type(value):
-    if isinstance(value, str) and '%' in value:
-        return float(value.strip('%'))
-    elif isinstance(value, str) and ('GB' in value or 'MB' in value):
-        return float(value.split()[0].replace(',', ''))
+    if isinstance(value, str) and "%" in value:
+        return float(value.strip("%"))
+    elif isinstance(value, str) and ("GB" in value or "MB" in value):
+        return float(value.split()[0].replace(",", ""))
     return value
-gauges = []
+
+
+gauges = {}
+
 
 def validate_required_files(mode_name, required_files):
     missing = [desc for desc, path in required_files.items() if path == None]
     if missing:
-        print(f"Missing {', '.join(missing)} for '{mode_name}' mode. Skipping...")
+        logger.error(
+            f"Missing {', '.join(missing)} for '{mode_name}' mode. Skipping..."
+        )
         return False
 
     return True
 
+
 def validate_all_modes(args):
     """
     Validates all selected modes and their required files.
@@ -65,17 +145,25 @@ def validate_all_modes(args):
     has_valid_mode = False
 
     mode_validations = [
-        (args.database, 'database', {
-            'database-config': args.database_config,
-            'queries-config': args.queries_config
-        }),
-        (args.commands, 'commands', {
-            'commands-config': args.commands_config
-        }),
-        (args.functions, 'functions', {
-            'functions-dir': args.functions_dir,
-            'functions-file':args.functions_file
-        })
+        (
+            args.database,
+            "database",
+            {
+                "database-config": args.database_config,
+                "queries-config": args.queries_config,
+            },
+        ),
+        (args.commands, "commands", {"commands-config": args.commands_config}),
+        (
+            args.functions,
+            "functions",
+            {
+                "functions-dir": args.functions_dir,
+                "functions-file": args.functions_file,
+            },
+        ),
+        (args.expose_api, "expose-api", {}),
+        (args.enable_https,"enable-https",{"ssl-cert":args.ssl_cert,"ssl-key" :args.ssl_key})
     ]
 
     for is_enabled, mode_name, files in mode_validations:
@@ -86,58 +174,75 @@ def validate_all_modes(args):
     return has_valid_mode
 
 
-def measure(init_flag,args):
+def measure(args):
     exec_result = []
+    queue_items = metric_queue.pop_all()
+    if len(queue_items) != 0:
+        exec_result.extend(queue_items)
     if args.database:
         db_results = process_database_queries(args.queries_config, args.database_config)
         exec_result.extend(db_results)
     if args.functions:
-        function_results = execute_functions(args.functions_dir,args.functions_file)
+        function_results = execute_functions(args.functions_dir, args.functions_file)
         exec_result.extend(function_results)
     if args.commands:
         cmd_results = process_commands(args.commands_config)
         if cmd_results != None:
             exec_result.extend(cmd_results)
-    # exec_result = process_commands('commands.yaml')
-    # print(exec_result)
     global gauges
-    count = 0
     for data in exec_result:
-        results= data['result']
-        labels = data['labels']
-        gauge_name = '_'.join(labels).lower() + "_gauge"
-        print(labels)
-        if init_flag:
+        results = data["result"]
+        labels = data["labels"]
+        gauge_name = "_".join(labels).lower() + "_gauge"
+        # print(labels)
+        if gauge_name not in gauges:
             gauge = Gauge(gauge_name, f"{gauge_name} for different metrics", labels)
-            gauges.append(gauge)
+            gauges[gauge_name] = gauge
         else:
-            gauge = gauges[count]
-            count += 1
+            gauge = gauges[gauge_name]
         for result in results:
-            print(result,isinstance(result['label'],list))
-            if isinstance(result['label'],str):
+            if isinstance(result["label"], str):
                 try:
-                    gauge.labels(result['label']).set(convert_to_data_type(result['value']))
+                    gauge.labels(result["label"]).set(
+                        convert_to_data_type(result["value"])
+                    )
                 except Exception as ex:
                     logger.error("Cannot pass string")
-            elif isinstance(result['label'],list):
-                label_dict = dict(zip(labels, result['label']))
-                gauge.labels(**label_dict).set(convert_to_data_type(result['value']))
+            elif isinstance(result["label"], list):
+                label_dict = dict(zip(labels, result["label"]))
+                gauge.labels(**label_dict).set(convert_to_data_type(result["value"]))
+
+
+def scheduled_measure(args):
+    measure(args)
+    scheduler.enter(5, 1, scheduled_measure, (args,))
+
+
+def start_scheduler(args):
+    scheduler.enter(0, 1, scheduled_measure, (args,))
+    scheduler.run()
 
 
 def main():
     args = arguments()
-    print("Validating configuration...")
+    logger.info("Validating configuration...")
     if not validate_all_modes(args):
-        print("No valid modes with proper configuration found. Exiting.")
+        logger.error("No valid modes with proper configuration found. Exiting.")
         exit(1)
 
-    print(f"Starting Prometheus metrics server on port {args.port}...")
-    print("Starting server")
-    start_http_server(args.port)
-    flag = True
-    while True:
-        measure(flag,args)
-        flag = False
-        time.sleep(5)
-main()
+    logger.info(f"Starting Prometheus metrics server on port {args.port}...")
+    logger.info("Starting server")
+    # start_http_server(args.port)
+
+    scheduler_thread = threading.Thread(
+        target=start_scheduler, args=(args,), daemon=True
+    )
+    scheduler_thread.start()
+    if args.expose_api:
+        add_update_metric_route()
+    if args.enable_https:
+        secure_flask_run(args)
+    else:
+        run_flask(args.host, args.port)
+
+main()

flexmetric/metric_process/views.py

@@ -0,0 +1,38 @@
+from flask import Flask, request, jsonify, Response
+from flexmetric.metric_process.expiring_queue import metric_queue
+import argparse
+from prometheus_client import generate_latest, REGISTRY, CONTENT_TYPE_LATEST
+
+app = Flask(__name__)
+
+
+@app.route('/metrics')
+def metrics():
+    return Response(generate_latest(REGISTRY), mimetype=CONTENT_TYPE_LATEST)
+
+
+def add_update_metric_route():
+    @app.route("/update_metric", methods=["POST"])
+    def update_metric():
+        try:
+            data = request.get_json()
+
+            if not data or "result" not in data or not isinstance(data["result"], list):
+                return jsonify({"status": "no"}), 400
+
+            for item in data["result"]:
+                if "label" not in item or "value" not in item:
+                    return jsonify({"status": "no"}), 400
+
+            metric_queue.put(data)
+            print(metric_queue)
+            return jsonify({"status": "success"}), 200
+
+        except Exception:
+            return jsonify({"status": "no"}), 500
+
+
+def run_flask(host, port):
+    app.run(host=host, port=port)
+def secure_flask_run(args):
+    app.run(host=args.host, port=args.port, ssl_context=(args.ssl_cert, args.ssl_key))

flexmetric-0.3.0.dist-info/METADATA

@@ -0,0 +1,243 @@
+Metadata-Version: 2.4
+Name: flexmetric
+Version: 0.3.0
+Summary: A secure flexible Prometheus exporter for commands, databases, functions, and scripts.
+Home-page: https://github.com/nikhillingadhal1999/custom_prometheus_agent
+Author: Nikhil Lingadhal
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: prometheus_client
+Requires-Dist: PyYAML
+Requires-Dist: psutil
+Requires-Dist: setuptools
+Requires-Dist: wheel
+Requires-Dist: twine
+Requires-Dist: flask
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# FlexMetric
+
+FlexMetric is a lightweight, flexible, and extensible Prometheus exporter that allows you to securely expose system metrics, database query results, Python function outputs, and externally submitted metrics—via an optional Flask API with HTTPS support—as Prometheus-compatible metrics, all with minimal setup and maximum customization.
+
+---
+
+## Features
+
+- Run shell commands and expose the results as Prometheus metrics.  
+  ➔ **Harmful commands (e.g., file deletion, system shutdown) are blocked for safety.**
+- Execute SQL queries (e.g., SQLite) and monitor database statistics.  
+  ➔ **Potentially dangerous queries (e.g., `DROP`, `DELETE`, `TRUNCATE`) are not allowed.**
+- Automatically discover and expose Python function outputs as metrics.
+- Expose an optional **Flask API** (`/update_metric`) to receive external metrics dynamically.
+- Modular and easy to extend—add your own custom integrations.
+- Built-in Prometheus HTTP server (`/metrics`) with configurable port.
+- **Supports HTTPS** to securely expose both metrics and API endpoints.
+- **Input sanitization** is performed to ensure only safe commands and queries are executed.
+
+
+---
+
+## Installation
+
+Install from PyPI:
+
+```bash
+pip install flexmetric
+```
+## Usage
+
+Run FlexMetric from the command line:
+
+```bash
+flexmetric --commands --commands-config commands.yaml --port 8000
+```
+
+## Available Modes
+
+FlexMetric supports multiple modes that can be used individually or combined to expose metrics:
+
+| Mode            | Description                                                            | Required Configuration File(s)           |
+|-----------------|------------------------------------------------------------------------|------------------------------------------|
+| `--commands`     | Runs system commands and exports outputs as Prometheus metrics.         | `commands.yaml`                          |
+| `--database`     | Executes SQL queries on databases and exports results.                 | `database.yaml` and `queries.yaml`       |
+| `--functions`    | Discovers and runs user-defined Python functions and exports outputs.  | `executable_functions.txt`               |
+| `--expose-api`   | Exposes a Flask API (`/update_metric`) to receive external metrics.     | *No configuration file required*         |
+### Example of Using Multiple Modes Together
+
+```bash
+flexmetric --commands --commands-config commands.yaml --database --database-config database.yaml --queries-config queries.yaml
+```
+
+## Configuration File Examples
+
+Below are example configurations for each supported mode.
+
+## Using the Flask API in FlexMetric
+
+To use the Flask API for submitting external metrics, you need to start the agent with the `--expose-api` flag along with the Flask host and port.
+
+### Start FlexMetric with Flask API
+
+```bash
+flexmetric --expose-api --port <port> --host <host>
+```
+
+## Example: Running FlexMetric with Flask API
+
+To run FlexMetric with both Prometheus metrics and the Flask API enabled:
+
+```bash
+flexmetric --expose-api --port 5000 --host 0.0.0.0
+```
+
+Prometheus metrics exposed at:
+http://localhost:5000/metrics
+
+Flask API exposed at:
+http://localhost:5000/update_metric
+
+### Submitting a Metric to the Flask API
+```bash
+curl -X POST http://localhost:5000/update_metric \
+-H "Content-Type: application/json" \
+-d '{
+  "result": [
+    { "label": "cpu_usage", "value": 42.5 }
+  ],
+  "labels": ["cpu"]
+}'
+
+```
+
+### Using flex metrics in secure mode
+
+```bash
+flexmetric --port 5000 --host 0.0.0.0 --enable-https --ssl-cert=cert.pem --ssl-key=key.pem
+```
+Prometheus metrics exposed at:
+https://localhost:5000/metrics
+
+Flask API exposed at:
+https://localhost:5000/update_metric
+
+### Submitting a Metric to the Flask API
+```bash
+curl -k -X POST https://localhost:5000/update_metric \
+-H "Content-Type: application/json" \
+-d '{
+  "result": [
+    { "label": "cpu_usage", "value": 42.5 }
+  ],
+  "labels": ["cpu"]
+}'
+
+```
+
+### commands.yaml
+
+```yaml
+commands:
+  - name: disk_usage
+    command: df -h
+    label: path
+    timeout_seconds: 60
+```
+```yaml
+databases:
+  - name: mydb
+    db_type: sqlite
+    db_connection: /path/to/my.db
+````
+```yaml
+queries:
+  - name: user_count
+    db_type: sqlite
+    db_name: mydb
+    query: "SELECT COUNT(*) FROM users;"
+    label: table
+    label_value: users
+```
+executable_functions.txt 
+```
+function_name_1
+function_name_2
+```
+
+## Python Function Output Format
+
+When using the `--functions` mode, each Python function you define is expected to return a dictionary in the following format:
+
+```python
+{
+    'result': [
+        {'label': <label_or_labels>, 'value': <numeric_value>}
+    ],
+    'labels': [<label_name_1>]
+}
+```
+
+### Explanation:
+
+| Key     | Description                                                               |
+|--------|---------------------------------------------------------------------------|
+| `result` | A list of dictionaries, each containing a `label` and a corresponding numeric `value`. |
+| `labels` | A list of label names (used as Prometheus labels).                        |
+
+
+## Command-Line Options
+
+The following command-line options are available when running FlexMetric:
+
+| Option              | Description                                              | Default                    |
+|---------------------|----------------------------------------------------------|----------------------------|
+| `--port`             | Port for the Prometheus metrics server (`/metrics`)      | `8000`                     |
+| `--commands`         | Enable commands mode                                      |                            |
+| `--commands-config`  | Path to commands YAML file                                | `commands.yaml`            |
+| `--database`         | Enable database mode                                      |                            |
+| `--database-config`  | Path to database YAML file                                | `database.yaml`            |
+| `--queries-config`   | Path to queries YAML file                                 | `queries.yaml`             |
+| `--functions`        | Enable Python functions mode                              |                            |
+| `--functions-file`   | Path to functions file                                    | `executable_functions.txt` |
+| `--expose-api`       | Enable Flask API mode to receive external metrics         |                            |
+| `--flask-port`       | Port for the Flask API (`/update_metric`)                 | `5000`                     |
+| `--flask-host`       | Hostname for the Flask API                                | `0.0.0.0`                  |
+| `--enable-https`     | Enable HTTPS for the Flask API                            |                            |
+| `--ssl-cert`         | Path to SSL certificate file (`cert.pem`)                 |                            |
+| `--ssl-key`          | Path to SSL private key file (`key.pem`)                  |                            |
+
+### Example Command:
+
+```bash
+flexmetric --commands --commands-config commands.yaml --port 8000
+```
+## Example Prometheus Output
+
+Once FlexMetric is running, the `/metrics` endpoint will expose metrics in the Prometheus format.
+
+Example output:
+```bash
+disk_usage_gauge{path="/"} 45.0
+```
+
+Each metric includes labels and numeric values that Prometheus can scrape and visualize.
+
+---
+
+## Future Enhancements
+
+The following features are planned or under consideration to improve FlexMetric:
+
+- Support for additional databases such as PostgreSQL and MySQL.
+- Enhanced support for more complex scripts and richer label extraction.

flexmetric-0.3.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+flexmetric/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flexmetric/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flexmetric/config/configuration.py,sha256=rlcpvH-Pe8U1suI_hmkZ9Ky4csneoShZGpqPuQNSDSo,129
+flexmetric/file_recognition/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flexmetric/file_recognition/exec_file.py,sha256=9wBbnqPConxtLhqWTgigEr8VQG-fa9K_U9UOLjqF8Xw,4273
+flexmetric/logging_module/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flexmetric/logging_module/logger.py,sha256=hXj9m2Q_KxJVI5YRHRoK6PXV5tO6NmvuVjq2Ipx_1tE,447
+flexmetric/metric_process/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flexmetric/metric_process/database_processing.py,sha256=W06P7ybno_9gFtndUtEY6vI2gMQvtYn1Z14w8h4FYwU,2668
+flexmetric/metric_process/expiring_queue.py,sha256=1oC0MjloitPiRo7yDgVarz81ETEQavKI_W-GFUvp5_Y,1920
+flexmetric/metric_process/process_commands.py,sha256=QAsR5uXt6rku_lTrBCfslerpqW0hMLSffzUFmxPC-fw,3556
+flexmetric/metric_process/prometheus_agent.py,sha256=hjPmNhJiB-844CgIcaw5A-VLmJqyMwQ_j1e_GI-UPSo,7422
+flexmetric/metric_process/views.py,sha256=05UbGBrAkEn_aJq7qBb_1yphCfnXiTqmXFLznMMpkN8,1194
+flexmetric-0.3.0.dist-info/METADATA,sha256=aPtTf_ONN8rVkBpuRGscJZXv9sFF4DbSskEI09bAR-s,8430
+flexmetric-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+flexmetric-0.3.0.dist-info/entry_points.txt,sha256=urVePn5EWr3JqNvkYP7OsB_h2_Bqvv-Wq1MJRBexm8A,79
+flexmetric-0.3.0.dist-info/top_level.txt,sha256=zBlrNwKhXUNhgu9RRZnXxYwYnmE-eocRe6wKSmQROA4,11
+flexmetric-0.3.0.dist-info/RECORD,,

flexmetric-0.1.4.dist-info/METADATA

@@ -1,152 +0,0 @@
-Metadata-Version: 2.4
-Name: flexmetric
-Version: 0.1.4
-Summary: A flexible Prometheus exporter for commands, databases, functions, and scripts.
-Home-page: https://github.com/nikhillingadhal1999/custom_prometheus_agent
-Author: Nikhil Lingadhal
-License: MIT
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-Requires-Dist: prometheus_client
-Requires-Dist: PyYAML
-Requires-Dist: psutil
-Requires-Dist: setuptools
-Requires-Dist: wheel
-Requires-Dist: twine
-Dynamic: author
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-# FlexMetric
-
-FlexMetric is a lightweight, flexible, and extensible Prometheus exporter that allows you to expose system metrics, database query results, script outputs, and Python function outputs as Prometheus-compatible metrics with minimal setup and maximum customization.
-
----
-
-## Features
-
-- Run shell commands and expose the results as Prometheus metrics.
-- Execute SQL queries (e.g., SQLite) and monitor database statistics.
-- Automatically discover and expose Python function outputs.
-- Run custom shell scripts and monitor their outputs.
-- Modular and easy to extend—add your own integrations.
-- Built-in Prometheus HTTP server (`/metrics`) with configurable port.
-
----
-
-## Installation
-
-Install from PyPI:
-
-```bash
-pip install flexmetric
-```
-## Usage
-
-Run FlexMetric from the command line:
-
-```bash
-flexmetric --commands --commands-config commands.yaml --port 8000
-```
-
-## Available Modes
-
-FlexMetric supports multiple modes that can be used individually or combined to expose metrics:
-
-| Mode           | Description                                      | Required Configuration File(s)           |
-|---------------|--------------------------------------------------|------------------------------------------|
-| `--commands`   | Runs system commands and exports outputs as Prometheus metrics.         | `commands.yaml`                          |
-| `--database`   | Executes SQL queries on databases and exports results.                 | `database.yaml` and `queries.yaml`       |
-| `--functions`  | Discovers and runs user-defined Python functions and exports outputs.   | `executable_functions.txt`               |
-| `--scripts`    | Executes custom shell scripts and exports outputs.                     | `scripts.yaml`                           |
-
-### Example of Using Multiple Modes Together
-
-```bash
-flexmetric --commands --commands-config commands.yaml --database --database-config database.yaml --queries-config queries.yaml
-```
-
-## Configuration File Examples
-
-Below are example configurations for each supported mode.
-
-### commands.yaml
-
-```yaml
-commands:
-  - name: disk_usage
-    command: df -h
-    label: path
-    timeout_seconds: 60
-```
-```yaml
-databases:
-  - name: mydb
-    db_type: sqlite
-    db_connection: /path/to/my.db
-````
-```yaml
-queries:
-  - name: user_count
-    db_type: sqlite
-    db_name: mydb
-    query: "SELECT COUNT(*) FROM users;"
-    label: table
-    label_value: users
-```
-executable_functions.txt 
-```
-function_name_1
-function_name_2
-```
-
-## Command-Line Options
-
-The following command-line options are available when running FlexMetric:
-
-| Option              | Description                                              | Default                    |
-|---------------------|----------------------------------------------------------|----------------------------|
-| `--port`            | Port for the Prometheus metrics server                    | `8000`                     |
-| `--commands`        | Enable commands mode                                      |                            |
-| `--commands-config` | Path to commands YAML file                                | `commands.yaml`            |
-| `--database`        | Enable database mode                                      |                            |
-| `--database-config` | Path to database YAML file                                | `database.yaml`            |
-| `--queries-config`  | Path to queries YAML file                                 | `queries.yaml`             |
-| `--functions`       | Enable Python functions mode                              |                            |
-| `--functions-file`  | Path to functions file                                    | `executable_functions.txt` |
-| `--scripts`         | Enable shell scripts mode                                 |                            |
-| `--scripts-config`  | Path to scripts YAML file                                 | `scripts.yaml`             |
-
-### Example Command:
-
-```bash
-flexmetric --commands --commands-config commands.yaml --port 8000
-```
-## Example Prometheus Output
-
-Once FlexMetric is running, the `/metrics` endpoint will expose metrics in the Prometheus format.
-
-Example output:
-```bash
-disk_usage_gauge{path="/"} 45.0
-```
-
-Each metric includes labels and numeric values that Prometheus can scrape and visualize.
-
----
-
-## Future Enhancements
-
-The following features are planned or under consideration to improve FlexMetric:
-
-- Support for additional databases such as PostgreSQL and MySQL.
-- Enhanced support for more complex scripts and richer label extraction.

flexmetric-0.1.4.dist-info/RECORD

@@ -1,15 +0,0 @@
-flexmetric/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-flexmetric/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-flexmetric/config/configuration.py,sha256=rlcpvH-Pe8U1suI_hmkZ9Ky4csneoShZGpqPuQNSDSo,129
-flexmetric/file_recognition/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-flexmetric/file_recognition/exec_file.py,sha256=9wBbnqPConxtLhqWTgigEr8VQG-fa9K_U9UOLjqF8Xw,4273
-flexmetric/logging_module/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-flexmetric/logging_module/logger.py,sha256=hXj9m2Q_KxJVI5YRHRoK6PXV5tO6NmvuVjq2Ipx_1tE,447
-flexmetric/metric_process/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-flexmetric/metric_process/database_processing.py,sha256=OAJ0FbvjQLSqUh85KenuEQ5YG7ghWQYT-pzqogCOafk,2542
-flexmetric/metric_process/prometheus_agent.py,sha256=pZ0Czv1ZQvyH0JhuNac5rjP1PC0ixcXM3HsQ0J-WxaY,5402
-flexmetric-0.1.4.dist-info/METADATA,sha256=adZgMG3ZOx9mlJwhCy3GHdih68q4CJODNb0MxKCSt8Y,5373
-flexmetric-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-flexmetric-0.1.4.dist-info/entry_points.txt,sha256=urVePn5EWr3JqNvkYP7OsB_h2_Bqvv-Wq1MJRBexm8A,79
-flexmetric-0.1.4.dist-info/top_level.txt,sha256=zBlrNwKhXUNhgu9RRZnXxYwYnmE-eocRe6wKSmQROA4,11
-flexmetric-0.1.4.dist-info/RECORD,,