askrobots / dbbasic-object-primitive
Public
Python functions as REST objects, with clustering, load balancing and state replication; no containers or orchestration.
self_logger.py · 6.1 KB · 208 lines
| 1 | """ |
| 2 | Self-Logger |
| 3 | |
| 4 | Each object logs to itself (not to external logging system). |
| 5 | |
| 6 | Design: |
| 7 | - Logs stored in TSV files (human-readable, grep-able) |
| 8 | - Append-only (immutable history) |
| 9 | - Each object has its own log directory: logs/{object_id}/log.tsv |
| 10 | - Log rotation when file exceeds size limit |
| 11 | - Query logs with filters (level, time range, custom fields) |
| 12 | |
| 13 | Philosophy: |
| 14 | Objects are self-contained. They know their own state, log their own |
| 15 | events, and can be queried independently. No central logging system. |
| 16 | """ |
| 17 | |
| 18 | import csv |
| 19 | from pathlib import Path |
| 20 | from datetime import datetime |
| 21 | from typing import Optional, List, Dict, Any, Union |
| 22 | import os |
| 23 | |
| 24 | |
| 25 | class SelfLogger: |
| 26 | """ |
| 27 | Self-logging for objects. |
| 28 | |
| 29 | Each object has its own log file stored in: |
| 30 | logs/{object_id}/log.tsv |
| 31 | |
| 32 | Logs are TSV format (human-readable, grep-able). |
| 33 | """ |
| 34 | |
| 35 | def __init__( |
| 36 | self, |
| 37 | object_id: str, |
| 38 | base_dir: Path | str, |
| 39 | max_log_size: Optional[int] = None, |
| 40 | ): |
| 41 | """ |
| 42 | Initialize self-logger. |
| 43 | |
| 44 | Args: |
| 45 | object_id: ID of the object (e.g., 'hello', 'calculator') |
| 46 | base_dir: Base directory for log storage |
| 47 | max_log_size: Maximum log file size in bytes before rotation |
| 48 | (default: 10MB) |
| 49 | """ |
| 50 | self.object_id = object_id |
| 51 | self.base_dir = Path(base_dir) |
| 52 | self.max_log_size = max_log_size or (10 * 1024 * 1024) # 10MB default |
| 53 | |
| 54 | # Create log directory |
| 55 | self.log_dir = self.base_dir / 'logs' / object_id |
| 56 | self.log_dir.mkdir(parents=True, exist_ok=True) |
| 57 | |
| 58 | # Current log file |
| 59 | self.log_file = self.log_dir / 'log.tsv' |
| 60 | |
| 61 | def log( |
| 62 | self, |
| 63 | level: str, |
| 64 | message: str, |
| 65 | **kwargs, |
| 66 | ) -> None: |
| 67 | """ |
| 68 | Log an entry. |
| 69 | |
| 70 | Args: |
| 71 | level: Log level (DEBUG, INFO, WARNING, ERROR, CRITICAL) |
| 72 | message: Log message |
| 73 | **kwargs: Additional fields to log (method, user_id, etc.) |
| 74 | """ |
| 75 | # Check if rotation needed |
| 76 | self._rotate_if_needed() |
| 77 | |
| 78 | # Prepare entry |
| 79 | entry = { |
| 80 | 'timestamp': datetime.now().isoformat(), |
| 81 | 'level': level, |
| 82 | 'message': message, |
| 83 | **kwargs, |
| 84 | } |
| 85 | |
| 86 | # Remove None values (don't log empty fields) |
| 87 | entry = {k: v for k, v in entry.items() if v is not None} |
| 88 | |
| 89 | # Get all possible fieldnames (existing + new) |
| 90 | fieldnames = self._get_fieldnames() |
| 91 | for key in entry.keys(): |
| 92 | if key not in fieldnames: |
| 93 | fieldnames.append(key) |
| 94 | |
| 95 | # Write to file |
| 96 | is_new_file = not self.log_file.exists() |
| 97 | |
| 98 | with open(self.log_file, 'a', newline='') as f: |
| 99 | writer = csv.DictWriter(f, fieldnames=fieldnames, delimiter='\t') |
| 100 | |
| 101 | if is_new_file: |
| 102 | writer.writeheader() |
| 103 | |
| 104 | writer.writerow(entry) |
| 105 | |
| 106 | def debug(self, message: str, **kwargs) -> None: |
| 107 | """Log DEBUG level message""" |
| 108 | self.log('DEBUG', message, **kwargs) |
| 109 | |
| 110 | def info(self, message: str, **kwargs) -> None: |
| 111 | """Log INFO level message""" |
| 112 | self.log('INFO', message, **kwargs) |
| 113 | |
| 114 | def warning(self, message: str, **kwargs) -> None: |
| 115 | """Log WARNING level message""" |
| 116 | self.log('WARNING', message, **kwargs) |
| 117 | |
| 118 | def error(self, message: str, **kwargs) -> None: |
| 119 | """Log ERROR level message""" |
| 120 | self.log('ERROR', message, **kwargs) |
| 121 | |
| 122 | def critical(self, message: str, **kwargs) -> None: |
| 123 | """Log CRITICAL level message""" |
| 124 | self.log('CRITICAL', message, **kwargs) |
| 125 | |
| 126 | def get_logs( |
| 127 | self, |
| 128 | level: Optional[Union[str, List[str]]] = None, |
| 129 | limit: Optional[int] = None, |
| 130 | offset: int = 0, |
| 131 | **filters, |
| 132 | ) -> List[Dict[str, Any]]: |
| 133 | """ |
| 134 | Get log entries. |
| 135 | |
| 136 | Args: |
| 137 | level: Filter by level (string or list of strings) |
| 138 | limit: Maximum number of entries to return |
| 139 | offset: Number of entries to skip |
| 140 | **filters: Additional filters (e.g., user_id='user-123') |
| 141 | |
| 142 | Returns: |
| 143 | List of log entries (dictionaries) |
| 144 | """ |
| 145 | if not self.log_file.exists(): |
| 146 | return [] |
| 147 | |
| 148 | # Read all entries from current log file |
| 149 | entries = [] |
| 150 | with open(self.log_file, 'r', newline='') as f: |
| 151 | reader = csv.DictReader(f, delimiter='\t') |
| 152 | for row in reader: |
| 153 | entries.append(row) |
| 154 | |
| 155 | # Also read from rotated log files |
| 156 | rotated_files = sorted(self.log_dir.glob('log-*.tsv')) |
| 157 | for rotated_file in rotated_files: |
| 158 | with open(rotated_file, 'r', newline='') as f: |
| 159 | reader = csv.DictReader(f, delimiter='\t') |
| 160 | for row in reader: |
| 161 | entries.append(row) |
| 162 | |
| 163 | # Filter by level |
| 164 | if level is not None: |
| 165 | if isinstance(level, str): |
| 166 | level = [level] |
| 167 | entries = [e for e in entries if e.get('level') in level] |
| 168 | |
| 169 | # Filter by custom fields |
| 170 | for key, value in filters.items(): |
| 171 | entries = [e for e in entries if e.get(key) == value] |
| 172 | |
| 173 | # Apply offset and limit |
| 174 | if offset > 0: |
| 175 | entries = entries[offset:] |
| 176 | |
| 177 | if limit is not None: |
| 178 | entries = entries[:limit] |
| 179 | |
| 180 | return entries |
| 181 | |
| 182 | def _get_fieldnames(self) -> List[str]: |
| 183 | """Get existing fieldnames from log file""" |
| 184 | if not self.log_file.exists(): |
| 185 | return ['timestamp', 'level', 'message'] |
| 186 | |
| 187 | with open(self.log_file, 'r', newline='') as f: |
| 188 | reader = csv.DictReader(f, delimiter='\t') |
| 189 | return reader.fieldnames or ['timestamp', 'level', 'message'] |
| 190 | |
| 191 | def _rotate_if_needed(self) -> None: |
| 192 | """Rotate log file if it exceeds max size""" |
| 193 | if not self.log_file.exists(): |
| 194 | return |
| 195 | |
| 196 | # Check size |
| 197 | size = self.log_file.stat().st_size |
| 198 | if size < self.max_log_size: |
| 199 | return |
| 200 | |
| 201 | # Rotate: rename current log to log-TIMESTAMP.tsv |
| 202 | timestamp = datetime.now().strftime('%Y%m%d-%H%M%S') |
| 203 | rotated_name = self.log_dir / f'log-{timestamp}.tsv' |
| 204 | |
| 205 | # Rename current log |
| 206 | self.log_file.rename(rotated_name) |
| 207 | |
| 208 | # Next log() call will create new log.tsv with header |