errorHandling.md•5.04 kB
# ErrorHandling
## Purpose and Overview
The error handling system in the MCP Logic server is designed to provide robust, informative, and recoverable error management. Key aspects include:
1. Error Categories:
- Syntax errors in logical formulas
- Proof execution errors
- Resource management issues
- Integration failures
- System-level errors
2. Error Management Goals:
- Clear error identification
- Detailed error context
- Recovery mechanisms
- Debugging support
- Performance impact tracking
3. Error Handling Strategy:
- Hierarchical error classification
- Contextual error information
- Graceful degradation
- Automatic recovery attempts
- Comprehensive logging
[Why this domain is critical to the project]
## Step-by-Step Explanations
### Error Hierarchy Implementation
1. Base Error Classes:
```python
class LogicError(Exception):
"""Base class for all MCP Logic errors"""
def __init__(
self,
message: str,
details: Optional[dict] = None
):
super().__init__(message)
self.details = details or {}
self.timestamp = datetime.now()
class ProverError(LogicError):
"""Errors from the Prover9/Mace4 system"""
pass
class SyntaxError(LogicError):
"""Formula syntax errors"""
pass
class ResourceError(LogicError):
"""Resource management errors"""
pass
class IntegrationError(LogicError):
"""External system integration errors"""
pass
```
2. Error Context Management:
```python
class ErrorContext:
def __init__(self):
self.error_stack = []
self.context_data = {}
def add_context(self, key: str, value: Any):
self.context_data[key] = value
def push_error(self, error: Exception):
self.error_stack.append({
'error': error,
'context': self.context_data.copy(),
'timestamp': datetime.now()
})
def get_error_history(self) -> List[dict]:
return self.error_stack
```
3. Error Recovery Implementation:
```python
class ErrorRecovery:
def __init__(self, max_retries: int = 3):
self.max_retries = max_retries
self.current_retries = 0
async def with_recovery(
self,
operation: Callable,
*args,
**kwargs
) -> Any:
while self.current_retries < self.max_retries:
try:
return await operation(*args, **kwargs)
except Exception as e:
self.current_retries += 1
if self.current_retries >= self.max_retries:
raise
await self.handle_error(e)
async def handle_error(self, error: Exception):
if isinstance(error, ResourceError):
await self.cleanup_resources()
elif isinstance(error, IntegrationError):
await self.reconnect()
await asyncio.sleep(self.current_retries)
```
### Error Logging Implementation
1. Structured Logging:
```python
class LogicLogger:
def __init__(self):
self.logger = logging.getLogger('mcp_logic')
self.setup_logging()
def setup_logging(self):
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
handler = RotatingFileHandler(
'mcp_logic.log',
maxBytes=10000000,
backupCount=5
)
handler.setFormatter(formatter)
self.logger.addHandler(handler)
def log_error(
self,
error: LogicError,
level: int = logging.ERROR
):
self.logger.log(level, str(error), extra={
'error_type': type(error).__name__,
'details': error.details,
'timestamp': error.timestamp
})
```
### Error Monitoring Implementation
1. Error Metrics Collection:
```python
class ErrorMetrics:
def __init__(self):
self.error_counts = defaultdict(int)
self.error_durations = defaultdict(list)
def record_error(
self,
error: LogicError,
duration: float
):
error_type = type(error).__name__
self.error_counts[error_type] += 1
self.error_durations[error_type].append(duration)
def get_error_stats(self) -> dict:
stats = {}
for error_type in self.error_counts:
stats[error_type] = {
'count': self.error_counts[error_type],
'avg_duration': (
sum(self.error_durations[error_type]) /
len(self.error_durations[error_type])
),
'max_duration': max(self.error_durations[error_type])
}
return stats
```
[Concrete, detailed steps for implementation and maintenance]
## Annotated Examples
[Code snippets, diagrams, or flowcharts for clarity]
## Contextual Notes
[Historical decisions, trade-offs, and anticipated challenges]
## Actionable Advice
[Gotchas, edge cases, and common pitfalls to avoid]