File size: 4,172 Bytes
264e00c |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 |
import logging
import os
import time
from typing import Optional
class Logger(logging.Logger):
def __init__(self, log_file: Optional[str] = None, name: Optional[str] = "Script", max_msg_length: int = 5000):
super().__init__(name=name)
self.start_time = time.time()
self.api_calls = []
self.total_cost = 0.0 # Track cumulative cost
self.cost_tracking_enabled = True # Flag to indicate if cost tracking is possible
self.max_msg_length = max_msg_length # Set this before any logging calls
# Add timestamp to log file name if provided
if log_file:
base, ext = os.path.splitext(log_file)
timestamp = time.strftime("%Y%m%d_%H%M%S")
self.log_file = f"{base}_{timestamp}{ext}"
else:
self.log_file = None
# Set up handler based on whether log_file is provided
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
if self.log_file:
log_dir = os.path.dirname(self.log_file)
if log_dir:
os.makedirs(log_dir, exist_ok=True)
handler = logging.FileHandler(self.log_file, mode='w')
else:
handler = logging.StreamHandler()
handler.setFormatter(formatter)
self.addHandler(handler)
# Initialize the log with a header
self.info("=== Log started ===")
self.max_msg_length = max_msg_length
def _truncate_message(self, message: str) -> str:
"""Truncate message if it exceeds max_msg_length"""
msg = str(message)
if len(msg) > self.max_msg_length:
return msg[:self.max_msg_length] + "... [truncated]"
return msg
def debug(self, msg, *args, **kwargs):
super().debug(self._truncate_message(msg), *args, **kwargs)
def info(self, msg, *args, **kwargs):
super().info(self._truncate_message(msg), *args, **kwargs)
def warning(self, msg, *args, **kwargs):
super().warning(self._truncate_message(msg), *args, **kwargs)
def error(self, msg, *args, **kwargs):
super().error(self._truncate_message(msg), *args, **kwargs)
def critical(self, msg, *args, **kwargs):
super().critical(self._truncate_message(msg), *args, **kwargs)
def log_api_call(self, duration: float, input_tokens: int, output_tokens: int, cost: float):
call_data = {
'timestamp': time.time(),
'duration': duration,
'input_tokens': input_tokens,
'output_tokens': output_tokens,
'cost': cost
}
self.api_calls.append(call_data)
# If we get a negative cost, disable cost tracking for the entire session
if cost < 0:
self.cost_tracking_enabled = False
self.total_cost = -1.0
elif self.cost_tracking_enabled:
self.total_cost += cost
# Log API call
base_log = f"API Call - Duration: {call_data['duration']:.2f}s, " \
f"Input Tokens: {call_data['input_tokens']}, Output Tokens: {call_data['output_tokens']}"
if self.cost_tracking_enabled:
base_log += f", Cost: ${cost:.2f}, Cumulative Cost: ${self.total_cost:.2f}"
self.info(base_log)
def summarize(self):
"""Write final summary statistics to the log file"""
end_time = time.time()
total_duration = end_time - self.start_time
total_api_duration = sum(call['duration'] for call in self.api_calls)
total_input_tokens = sum(call['input_tokens'] for call in self.api_calls)
total_output_tokens = sum(call['output_tokens'] for call in self.api_calls)
self.info("\n=== Summary Statistics ===")
self.info(f"Total Duration: {total_duration:.2f} seconds")
self.info(f"Total API Call Duration: {total_api_duration:.2f} seconds")
self.info(f"Total Input Tokens: {total_input_tokens}")
self.info(f"Total Output Tokens: {total_output_tokens}")
if self.cost_tracking_enabled:
self.info(f"Total API Cost: ${self.total_cost:.2f}")
self.info("=== Log ended ===")
|