Log-Level-Aware-Path-Optimization

The problem

Finding the most efficient way to complete a sequence of system tasks can be complex and costly. It is difficult to balance multiple steps while keeping track of which actions are most important.

What it does

It analyzes a list of tasks and calculates the most cost-effective path to complete them. It uses a structured logging system to track these steps as it finds the best route.

Why it matters

It provides a way to streamline system workflows by identifying the most efficient path through a series of tasks.

Validation

It was run in the sandbox and it failed. run output shows an error/traceback — the artifact does NOT run clean.

$ python3 log_level_aware_path_optimizer.py
Traceback (most recent call last):
  File "/work/log_level_aware_path_optimizer.py", line 70, in <module>
    optimizer.log_event('Path-A', 'INFO', 'Initialization completed', cost_factor=0.8)
  File "/work/log_level_aware_path_optimizer.py", line 38, in log_event
    self.logger.log(getattr(logging, level.lower()), json.dumps(entry))
  File "/usr/local/lib/python3.12/logging/__init__.py", line 1605, in log
    raise TypeError("level must be an integer")
TypeError: level must be an integer

No screenshot — there is nothing working to show. This is recorded as an unfinished sketch so the attempt stays visible instead of being quietly dropped.

The code

All of it — 82 lines, one file, standard library only.

# Log-Level-Aware Path Optimization Script

import logging
import json

class PathOptimizer:
    def __init__(self):
        self.log_data = []
        self.log_levels = {
            'DEBUG': 0.1,
            'INFO': 0.5,
            'WARNING': 1.0,
            'ERROR': 5.0
        }
        logging.basicConfig(
            format='%(levelname)s: %(message)s',
            level=logging.DEBUG
        )
        self.logger = logging.getLogger('PathOptimizer')

    def log_event(self, path_id, level, message, cost_factor=1.0):
        """
        Records a logging event with associated cost
        """
        if level not in self.log_levels:
            self.logger.warning(f'Unknown log level {level} - using default cost')
            level = 'INFO'

        base_cost = self.log_levels[level]
        entry = {
            'path': path_id,
            'level': level,
            'message': message,
            'cost': base_cost * cost_factor,
            'timestamp': '2023-09-20T12:00:00'
        }
        self.log_data.append(entry)
        self.logger.log(getattr(logging, level.lower()), json.dumps(entry))

    def optimize_path(self):
        """
        Calculate cost-efficient path using log data
        Returns:
            (str: optimal path id, float: total cost)
        """
        path_costs = {}  # {path_id: total_cost}
        path_entry_count = {}

        for entry in self.log_data:
            path_id = entry['path']
            if path_id not in path_costs:
                path_costs[path_id] = 0
                path_entry_count[path_id] = 0

            path_costs[path_id] += entry['cost']
            path_entry_count[path_id] += 1

        if not path_costs:
            return None, 0.0

        optimal_path = min(path_costs, key=lambda k: path_costs[k])
        avg_cost_per_entry = path_costs[optimal_path] / path_entry_count[optimal_path]
        return optimal_path, avg_cost_per_entry

# Example usage
if __name__ == '__main__':
    optimizer = PathOptimizer()
    
    # Simulate logging data for different paths
    optimizer.log_event('Path-A', 'INFO', 'Initialization completed', cost_factor=0.8)
    optimizer.log_event('Path-A', 'DEBUG', 'Processing step 1', cost_factor=1.2)
    optimizer.log_event('Path-A', 'WARNING', 'High memory usage', cost_factor=0.9)

    optimizer.log_event('Path-B', 'INFO', 'Initialization completed', cost_factor=1.0)
    optimizer.log_event('Path-B', 'ERROR', 'Critical failure in step 2', cost_factor=1.5)
    optimizer.log_event('Path-B', 'DEBUG', 'Finalizing process', cost_factor=0.7)

    best_path, avg_cost = optimizer.optimize_path()
    print(f"Optimal path: {best_path} (Average cost per entry: ${avg_cost:.2f})")