flexmetric 0.3.3__py3-none-any.whl → 0.4.1__py3-none-any.whl

flexmetric/metric_process/database_processing.py

@@ -60,8 +60,10 @@ def process_database_queries(queries_file, databases_file):
 
             db_path = db_conf["db_connection"]
             query = cmd["query"]
-            label = cmd["label"]
-            label_value = cmd["label_value"]
+            labels = cmd.get('labels', [])
+            label_values = cmd.get('label_values', [])
+            main_label = cmd.get('main_label', 'default_db_metric')
+
             # check if query is safe
             if is_safe_query(query):
                 value = execute_sqlite_query(db_path, query)
@@ -69,20 +71,20 @@ def process_database_queries(queries_file, databases_file):
                 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']}'"
-                )
-
+            if not isinstance(label_values, list):
+                label_values = [label_values]
+
+            result = {
+                'result': [{
+                    'label': label_values,
+                    'value': value
+                }],
+                'labels': labels,
+                'main_label': main_label
+            }
+            all_results.append(result)
         except Exception as e:
             print(
                 f"[ERROR] Processing command '{cmd.get('name', 'unknown')}' failed: {e}"
             )
-
     return all_results

flexmetric/metric_process/process_commands.py

@@ -55,24 +55,40 @@ def parse_command_output(raw_output, label_column, value_column, fixed_label_val
 
 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)
+    labels = cmd_info.get('labels', [])
+    label_columns = cmd_info.get('label_columns', [])
     value_column = cmd_info.get('value_column', 0)
-    fixed_label_value = cmd_info.get('label_value')
+    main_label = cmd_info.get('main_label', 'default_metric')
 
     raw_output = execute_command_with_timeout(command, timeout)
-    if raw_output == '':
+    if not 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)
-
+    lines = raw_output.strip().split('\n')
+    if not lines:
+        logger.error(f"No valid lines returned from command: {command}")
+        return None
+    result_list = []
+    for line in lines:
+        parts = line.split()
+        try:
+            label_columns_value = []
+            for value in label_columns:
+                label_columns_value.append(parts[value])
+            result_list.append({ "label": label_columns_value, "value": parts[value_column] })
+        except Exception as e:
+            logger.error(f"Error parsing line: '{line}' → {e}")
+            continue
     return {
         'result': result_list,
-        'labels': [label_name]
+        'labels': labels,
+        'main_label': main_label
     }
 
+
+
 def is_command_safe(command):
     blacklist = ['rm', 'reboot', 'shutdown', 'halt', 'poweroff', 'mkfs', 'dd']
     for dangerous_cmd in blacklist:

flexmetric/metric_process/prometheus_agent.py

@@ -190,27 +190,37 @@ def measure(args):
         if cmd_results != None:
             exec_result.extend(cmd_results)
     global gauges
+
     for data in exec_result:
         results = data["result"]
         labels = data["labels"]
-        gauge_name = "_".join(labels).lower() + "_gauge"
-        # print(labels)
+        main_label_value = data.get("main_label", "default_main")
+        gauge_name = main_label_value.lower() + "_gauge"
+
         if gauge_name not in gauges:
             gauge = Gauge(gauge_name, f"{gauge_name} for different metrics", labels)
             gauges[gauge_name] = gauge
         else:
             gauge = gauges[gauge_name]
+
         for result in results:
-            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"]))
+            label_values = result["label"]
+
+            if not isinstance(label_values, list):
+                # Automatically wrap single label into list for consistency
+                label_values = [label_values]
+
+            if len(label_values) != len(labels):
+                logger.error(f"Label mismatch: expected {len(labels)} values but got {len(label_values)}")
+                continue
+
+            label_dict = dict(zip(labels, label_values))
+            # print(label_dict)
+
+            try:
                 gauge.labels(**label_dict).set(convert_to_data_type(result["value"]))
+            except Exception as ex:
+                logger.error(f"Failed to set gauge for labels {label_dict}: {ex}")
 
 
 def scheduled_measure(args):
@@ -244,5 +254,6 @@ def main():
         secure_flask_run(args)
     else:
         run_flask(args.host, args.port)
-
-main()
+# # args = arguments()
+# # measure(args)
+# main()

flexmetric/metric_process/views.py

@@ -15,21 +15,59 @@ def add_update_metric_route():
     @app.route("/update_metric", methods=["POST"])
     def update_metric():
         try:
-            data = request.get_json()
+            data = request.get_json(force=True)
 
-            if not data or "result" not in data or not isinstance(data["result"], list):
-                return jsonify({"status": "no"}), 400
+            # Top-level validation
+            if not isinstance(data, dict):
+                return jsonify({"status": "invalid structure", "error": "Top-level JSON must be an object"}), 400
 
-            for item in data["result"]:
+            required_keys = {"result", "labels", "main_label"}
+            if not required_keys.issubset(data):
+                return jsonify({"status": "invalid structure", "error": f"Missing keys: {required_keys - set(data)}"}), 400
+
+            result = data.get("result")
+            labels = data.get("labels")
+            main_label = data.get("main_label")
+
+            # Type validation
+            if not isinstance(result, list) or not all(isinstance(item, dict) for item in result):
+                return jsonify({"status": "invalid result", "error": "Result must be a list of dictionaries"}), 400
+
+            if not isinstance(labels, list) or not all(isinstance(label, str) for label in labels):
+                return jsonify({"status": "invalid labels", "error": "Labels must be a list of strings"}), 400
+
+            if not isinstance(main_label, str) or not main_label.strip():
+                return jsonify({"status": "invalid main_label", "error": "main_label must be a non-empty string"}), 400
+
+            for idx, item in enumerate(result):
                 if "label" not in item or "value" not in item:
-                    return jsonify({"status": "no"}), 400
+                    return jsonify({"status": "invalid result item", "error": f"Item {idx} missing 'label' or 'value'"}), 400
 
+                label_values = item["label"]
+                value = item["value"]
+
+                if not isinstance(label_values, list) or not all(isinstance(lv, str) for lv in label_values):
+                    return jsonify({"status": "invalid label", "error": f"Item {idx} 'label' must be list of strings"}), 400
+
+                if len(label_values) != len(labels):
+                    return jsonify({
+                        "status": "label count mismatch",
+                        "error": f"Item {idx} label count ({len(label_values)}) does not match labels length ({len(labels)})"
+                    }), 400
+
+                try:
+                    float(value)  # Validate numeric value
+                except (ValueError, TypeError):
+                    return jsonify({"status": "invalid value", "error": f"Item {idx} value must be numeric"}), 400
+
+            # If all checks pass, queue the metric
             metric_queue.put(data)
-            print(metric_queue)
+            print("Queued:", data)
+
             return jsonify({"status": "success"}), 200
 
-        except Exception:
-            return jsonify({"status": "no"}), 500
+        except Exception as e:
+            return jsonify({"status": "error", "message": str(e)}), 500
 
 
 def run_flask(host, port):

{flexmetric-0.3.3.dist-info → flexmetric-0.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flexmetric
-Version: 0.3.3
+Version: 0.4.1
 Summary: A secure flexible Prometheus exporter for commands, databases, functions, and scripts.
 Home-page: https://github.com/nikhillingadhal1999/flexmetric
 Author: Nikhil Lingadhal
@@ -138,15 +138,18 @@ https://localhost:5000/update_metric
 
 ### Submitting a Metric to the Flask API
 ```bash
-curl -k -X POST https://localhost:5000/update_metric \
+curl -X POST http://localhost:5000/update_metric \
 -H "Content-Type: application/json" \
 -d '{
   "result": [
-    { "label": "cpu_usage", "value": 42.5 }
+    { 
+      "label": ["cpu", "core_1"], 
+      "value": 42.5 
+    }
   ],
-  "labels": ["cpu"]
+  "labels": ["metric_type", "core"],
+  "main_label": "cpu_usage_metric"
 }'
-
 ```
 
 ### commands.yaml
@@ -155,8 +158,9 @@ curl -k -X POST https://localhost:5000/update_metric \
 commands:
   - name: disk_usage
     command: df -h
-    label: path
-    label_column: -1
+    main_label: disk_usage_filesystem_mount_point
+    labels: ["filesystem", "mounted"]
+    label_columns: [0, -1]
     value_column: 4
     timeout_seconds: 60
 ```
@@ -169,15 +173,15 @@ Filesystem      Size  Used Avail Use% Mounted on
 ```
 ## Fields description
 
-
-| Field            | Description                                                                 |
-|------------------|-----------------------------------------------------------------------------|
-| `name`           | The **name** of the metric (`disk_usage`). This is the metric name seen in Prometheus. |
-| `command`        | The **shell command** to execute (`df -h` in this case).                    |
-| `label`          | The **label name** to attach to the metric (`path`).                        |
-| `label_column`   | The **column index** from the command's output to use as the label. Here `-1` means the **last column** (typically the mount path in `df -h`). |
-| `value_column`   | The **column index** from the command's output to extract the **numeric value**. Here `4` refers to the fifth column, which is usually the **Use%** in `df -h`. |
-| `timeout_seconds`| How long (in seconds) to wait for the command before timing out. Here it's set to `60` seconds. |
+| Field             | Description                                                                                                                |
+|-------------------|----------------------------------------------------------------------------------------------------------------------------|
+| `name`            | A **nickname** you give to this check. It's just for your reference to know what this command is doing (e.g., `"disk_usage"`). |
+| `command`         | The **actual shell command** to run (e.g., `"df -h"`). It fetches the data you want to monitor.                             |
+| `main_label`      | The **metric name** that will appear in Prometheus. This is what you will query to see the metric values.                  |
+| `labels`          | A list of **label names** used to describe different dimensions of the metric (e.g., `["filesystem", "mounted"]`).         |
+| `label_columns`   | A list of **column indexes** from the command’s output to extract the label values (e.g., `[0, -1]` for first and last column). |
+| `value_column`    | The **column index** from the command's output to extract the **numeric value** (the actual metric value, e.g., disk usage). |
+| `timeout_seconds` | Maximum time (in seconds) to wait for the command to complete. If it exceeds this time, the command is aborted.             |
 
 ## Database mode
 
@@ -188,13 +192,13 @@ databases:
     db_connection: /path/to/my.db
 ````
 ```yaml
-queries:
+commands:
   - name: user_count
-    db_type: sqlite
-    db_name: mydb
+    database: userdb
     query: "SELECT COUNT(*) FROM users;"
-    label: table
-    label_value: users
+    main_label: database_user_count
+    labels: ["database_name", "table_name"]
+    label_values: ["userdb", "users"]
 ```
 ## Functions mode
 
@@ -211,9 +215,10 @@ When using the `--functions` mode, each Python function you define is expected t
 ```python
 {
     'result': [
-        {'label': <label_or_labels>, 'value': <numeric_value>}
+        { 'label': [label_value1, label_value2, ...], 'value': numeric_value }
     ],
-    'labels': [<label_name_1>]
+    'labels': [label_name1, label_name2, ...],
+    'main_label': 'your_main_metric_name'
 }
 ```
 

{flexmetric-0.3.3.dist-info → flexmetric-0.4.1.dist-info}/RECORD

@@ -6,13 +6,13 @@ flexmetric/file_recognition/exec_file.py,sha256=9wBbnqPConxtLhqWTgigEr8VQG-fa9K_
 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/database_processing.py,sha256=hbVbzIdO21NF0F3nILJ4d1x8fkks9P8s-wtn8qZ91qw,2739
 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.3.dist-info/METADATA,sha256=C6LEjLX8FxXysm4SvZ016r8m1IvxKEHllgeJrWtTcp8,9921
-flexmetric-0.3.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-flexmetric-0.3.3.dist-info/entry_points.txt,sha256=urVePn5EWr3JqNvkYP7OsB_h2_Bqvv-Wq1MJRBexm8A,79
-flexmetric-0.3.3.dist-info/top_level.txt,sha256=zBlrNwKhXUNhgu9RRZnXxYwYnmE-eocRe6wKSmQROA4,11
-flexmetric-0.3.3.dist-info/RECORD,,
+flexmetric/metric_process/process_commands.py,sha256=clGMQhLNcuJUO1gElpAS9Dyk0KU5w41DIguczjo7ceA,4089
+flexmetric/metric_process/prometheus_agent.py,sha256=rZ9pQrqA3J_-sJtl48qkFIHIUH01iert05u4SmGN4Yc,7714
+flexmetric/metric_process/views.py,sha256=BY695dCpTkJRc1KLC9RNpFTieFdHeHvyqyefmHhMauE,3297
+flexmetric-0.4.1.dist-info/METADATA,sha256=kHQheeo9qUgtJD6Zyb8O7q6eZR8RTCs7DJXHDJ8Yfrc,10570
+flexmetric-0.4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+flexmetric-0.4.1.dist-info/entry_points.txt,sha256=urVePn5EWr3JqNvkYP7OsB_h2_Bqvv-Wq1MJRBexm8A,79
+flexmetric-0.4.1.dist-info/top_level.txt,sha256=zBlrNwKhXUNhgu9RRZnXxYwYnmE-eocRe6wKSmQROA4,11
+flexmetric-0.4.1.dist-info/RECORD,,