flexmetric 0.1.0__py3-none-any.whl

flexmetric/file_recognition/exec_file.py

@@ -0,0 +1,125 @@
+import os
+import ast
+import importlib.util
+from typing import Dict, List, Any
+
+
+def get_python_files(folder_path: str) -> List[str]:
+
+    return [ os.path.join(root,file) for root, _ , files  in os.walk(folder_path) for file in files if file.endswith('.py') ]
+
+def extract_functions_with_code(file_path: str) -> Dict[str, str]:
+    with open(file_path, "r") as file:
+        file_content = file.read()  # Read file content once
+
+    tree = ast.parse(file_content)
+
+    functions = {}
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef):
+            function_name = node.name
+            function_code = ast.get_source_segment(file_content, node)
+            functions[function_name] = function_code
+    return functions
+
+def analyze_dependencies(function_code: str) -> List[str]:
+    try:
+        tree = ast.parse(function_code)
+    except SyntaxError as e:
+        print(f"Syntax error in function code: {e}")
+        return []
+
+    dependencies = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Call):
+            if isinstance(node.func, ast.Name):
+                dependencies.append(node.func.id)
+            elif isinstance(node.func, ast.Attribute):
+                dependencies.append(node.func.attr)
+
+    return dependencies
+
+def find_function_dependencies(file_path: str) -> Dict[str, List[str]]:
+    functions_with_code = extract_functions_with_code(file_path)
+    function_dependencies = {}
+
+    for func_name, func_code in functions_with_code.items():
+        dependencies = analyze_dependencies(func_code)
+        function_dependencies[func_name] = dependencies
+
+    return function_dependencies
+
+def topological_sort(dependency_graph: Dict[str, List[str]]) -> List[str]:
+    visited = set()
+    stack = []
+
+    def visit(node):
+        if node not in visited:
+            visited.add(node)
+            for neighbor in dependency_graph.get(node, []):
+                visit(neighbor)
+            stack.append(node)
+
+    for node in dependency_graph:
+        visit(node)
+
+    return stack[::-1]
+
+def execute_function(file_path: str, function_name: str, attributes: Dict[str,Any]):
+    dependencies = find_function_dependencies(file_path)
+    sorted_functions = topological_sort(dependencies)
+
+    if function_name not in sorted_functions:
+        return
+
+    module_name = os.path.splitext(os.path.basename(file_path))[0]
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)   
+
+    for func in sorted_functions:
+        if hasattr(module, func):
+            func_to_call = getattr(module, func)
+            if callable(func_to_call):
+                try:
+                    args = attributes.get(func,())
+                    if not isinstance(args,tuple):
+                        args = (args,)
+                    result = func_to_call(*args)  
+                    if func == function_name:
+                        return result
+                except Exception as e:
+                    print(f"Error executing {func}: {e}")
+
+def main(folder_path: str, function_name: str, attributes: Dict[str,Any]):
+    python_files = get_python_files(folder_path)
+
+    for file_path in python_files:
+        return execute_function(file_path, function_name,attributes)
+
+
+def read_function_file(custom_path):    
+    with open(custom_path,'r') as file:
+        lines = file.readlines()
+    return lines
+
+def get_env_dir():
+    current_path = os.getcwd()
+    return os.path.abspath(os.path.join(current_path,'env/bin/activate'))
+
+def install_requirements(requirements_path):
+    env_dir = get_env_dir()
+    command = f"source {env_dir}; pip3 install -r {requirements_path}"
+    os.system(command)
+
+def load_variable_from_file(file_path, variable_name="ARGS"):
+    spec = importlib.util.spec_from_file_location("module_name", file_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return getattr(module, variable_name, None)
+
+def execute_functions(folder_path,file_path):
+    functions = read_function_file(file_path)
+    args= { 'collect_disk_metrics' : ()}
+    result = [ main(folder_path, function_name.strip('\n'), args) for function_name in functions ]
+    return result

flexmetric/logging_module/logger.py

@@ -0,0 +1,15 @@
+import logging 
+import sys
+
+
+def get_logger(name: str , level = logging.DEBUG) -> logging.Logger:
+    logger = logging.getLogger(__name__)
+    if not logger.hasHandlers():
+        logger.setLevel(level)
+        handler = logging.StreamHandler(sys.stdout)
+        handler.setFormatter(
+                logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+                )
+        logger.addHandler(handler)
+    return logger
+

flexmetric/metric_process/database_processing.py

@@ -0,0 +1,75 @@
+import yaml
+import sqlite3
+import re
+
+def read_yaml_file(file_path):
+    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:
+            return db
+    raise ValueError(f"[ERROR] Database config for '{db_name}' not found in database.yaml.")
+
+def execute_sqlite_query(db_path, query):
+    try:
+        conn = sqlite3.connect(db_path)
+        cursor = conn.cursor()
+        cursor.execute(query)
+        result = cursor.fetchone()
+        conn.close()
+        return float(result[0]) if result and result[0] is not None else None
+    except Exception as e:
+        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
+
+def process_database_queries(queries_file, databases_file):
+    # Get queries from queries file
+    queries_config = read_yaml_file(queries_file)
+    # Get database from database file
+    databases_config = read_yaml_file(databases_file)
+
+    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'])
+
+            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 
+            if is_safe_query(query):
+                value = execute_sqlite_query(db_path, query)
+            else:
+                print(f"[WARN] Unsupported query type: {query}")
+                return None
+
+            if value is not None:
+                result = {
+                    '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']}'")
+
+        except Exception as e:
+            print(f"[ERROR] Processing command '{cmd.get('name', 'unknown')}' failed: {e}")
+
+    return all_results

flexmetric/metric_process/process_commands.py

@@ -0,0 +1,73 @@
+import subprocess
+import yaml
+import re
+
+# 1. Read YAML commands
+def read_commands_from_yaml(file_path):
+    with open(file_path, 'r') as f:
+        config = yaml.safe_load(f)
+    return config.get('commands', [])
+
+# 2. Execute command with timeout
+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:
+            return ''
+        return result.stdout.strip()
+    except subprocess.TimeoutExpired:
+        return ''
+
+def process_commands(config_file):
+    commands = read_commands_from_yaml(config_file)
+    all_results = []
+
+    for cmd_info in commands:
+        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)
+        lines = raw_output.strip().splitlines()
+
+        result_list = []
+
+        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
+            })
+
+        formatted = {
+            'result': result_list,
+            'labels': [label_name]
+        }
+        all_results.append(formatted)
+
+    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

@@ -0,0 +1,140 @@
+from prometheus_client import Gauge, start_http_server
+import psutil 
+import time
+import sys
+import os
+
+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
+import argparse
+import os
+def arguments():
+    parser = argparse.ArgumentParser(
+        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.')
+    
+
+    # 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')
+
+    return parser.parse_args()
+
+logger = get_logger(__name__)
+
+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(',', ''))
+    return value
+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...")
+        return False
+
+    return True
+
+def validate_all_modes(args):
+    """
+    Validates all selected modes and their required files.
+
+    Args:
+        args: Parsed command-line arguments.
+
+    Returns:
+        bool: True if at least one valid mode is properly configured, False otherwise.
+    """
+    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
+        })
+    ]
+
+    for is_enabled, mode_name, files in mode_validations:
+        if is_enabled:
+            if validate_required_files(mode_name, files):
+                has_valid_mode = True
+
+    return has_valid_mode
+
+
+def measure(init_flag,args):
+    exec_result = []
+    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)
+        exec_result.extend(function_results)
+    if args.commands:
+        cmd_results = process_commands(args.commands_config)
+        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:
+            gauge = Gauge(gauge_name, f"{gauge_name} for different metrics", labels)
+            gauges.append(gauge)
+        else:
+            gauge = gauges[count]
+            count += 1
+        for result in results:
+            print(result,isinstance(result['label'],list))
+            if isinstance(result['label'],str):
+                try:
+                    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']))
+
+if __name__ == "__main__":
+    args = arguments()
+    print("Validating configuration...")
+    if not validate_all_modes(args):
+        print("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)

flexmetric-0.1.0.dist-info/METADATA

@@ -0,0 +1,152 @@
+Metadata-Version: 2.4
+Name: flexmetric
+Version: 0.1.0
+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.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+flexmetric/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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/process_commands.py,sha256=cHtoyzP0IgZOwoS_BgFZU0VHuOKQO0UVvGOCwWuByNM,2236
+flexmetric/metric_process/prometheus_agent.py,sha256=kb_egYolKh7Q6BufbvswuhPanBGzAjKMkUHPRE7nP4Y,5374
+flexmetric-0.1.0.dist-info/METADATA,sha256=ozCoaEh4TUeWSO9jAQsQkFZ8BsO6JykmImw0rBuseuU,5367
+flexmetric-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+flexmetric-0.1.0.dist-info/entry_points.txt,sha256=urVePn5EWr3JqNvkYP7OsB_h2_Bqvv-Wq1MJRBexm8A,79
+flexmetric-0.1.0.dist-info/top_level.txt,sha256=zBlrNwKhXUNhgu9RRZnXxYwYnmE-eocRe6wKSmQROA4,11
+flexmetric-0.1.0.dist-info/RECORD,,

flexmetric-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

flexmetric-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+flexmetric = flexmetric.metric_process.prometheus_agent:main

flexmetric-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+flexmetric