other fixes for redis

core/logger.py

@@ -1,10 +1,6 @@
-"""
+# dnsrecon/core/logger.py
-Forensic logging system for DNSRecon tool.
-Provides structured audit trail for all reconnaissance activities.
-"""
 
 import logging
-import threading
 from datetime import datetime
 from typing import Dict, Any, Optional, List
 from dataclasses import dataclass, asdict
@@ -53,7 +49,6 @@ class ForensicLogger:
             session_id: Unique identifier for this reconnaissance session
         """
         self.session_id = session_id or self._generate_session_id()
-        #self.lock = threading.Lock()
         
         # Initialize audit trail storage
         self.api_requests: List[APIRequest] = []
@@ -83,6 +78,26 @@ class ForensicLogger:
             console_handler.setFormatter(formatter)
             self.logger.addHandler(console_handler)
             
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        # Exclude the unpickleable 'logger' attribute
+        if 'logger' in state:
+            del state['logger']
+        return state
+
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+        # Re-initialize the 'logger' attribute
+        self.logger = logging.getLogger(f'dnsrecon.{self.session_id}')
+        self.logger.setLevel(logging.INFO)
+        formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+        if not self.logger.handlers:
+            console_handler = logging.StreamHandler()
+            console_handler.setFormatter(formatter)
+            self.logger.addHandler(console_handler)
+
     def _generate_session_id(self) -> str:
         """Generate unique session identifier."""
         return f"dnsrecon_{datetime.now(timezone.utc).strftime('%Y%m%d_%H%M%S')}"
@@ -240,25 +255,3 @@ class ForensicLogger:
         start_time = datetime.fromisoformat(self.session_metadata['start_time'])
         duration = (end_time - start_time).total_seconds() / 60
         return round(duration, 2)
-
-
-# Global logger instance for the current session
-_current_logger: Optional[ForensicLogger] = None
-_logger_lock = threading.Lock()
-
-
-def get_forensic_logger() -> ForensicLogger:
-    """Get or create the current forensic logger instance."""
-    global _current_logger
-    with _logger_lock:
-        if _current_logger is None:
-            _current_logger = ForensicLogger()
-        return _current_logger
-
-
-def new_session() -> ForensicLogger:
-    """Start a new forensic logging session."""
-    global _current_logger
-    with _logger_lock:
-        _current_logger = ForensicLogger()
-        return _current_logger

core/scanner.py

@@ -1,8 +1,4 @@
-"""
+# dnsrecon/core/scanner.py
-Main scanning orchestrator for DNSRecon.
-Coordinates data gathering from multiple providers and builds the infrastructure graph.
-REFACTORED: Simplified recursion with forensic provider state tracking.
-"""
 
 import threading
 import traceback
@@ -12,7 +8,7 @@ from collections import defaultdict
 from datetime import datetime, timezone
 
 from core.graph_manager import GraphManager, NodeType, RelationshipType
-from core.logger import get_forensic_logger, new_session
+from core.logger import ForensicLogger
 from utils.helpers import _is_valid_ip, _is_valid_domain
 from providers.crtsh_provider import CrtShProvider
 from providers.dns_provider import DNSProvider
@@ -77,7 +73,7 @@ class Scanner:
 
             # Initialize logger
             print("Initializing forensic logger...")
-            self.logger = get_forensic_logger()
+            self.logger = ForensicLogger()
 
             print("Scanner initialization complete")
 
@@ -86,6 +82,23 @@ class Scanner:
             traceback.print_exc()
             raise
 
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        # Exclude unpickleable attributes
+        for attr in ['stop_event', 'scan_thread', 'executor', 'logger', 'providers']:
+            if attr in state:
+                del state[attr]
+        return state
+
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+        # Re-initialize unpickleable attributes
+        self.stop_event = threading.Event()
+        self.scan_thread = None
+        self.executor = None
+        self.logger = ForensicLogger()
+        self._initialize_providers()
+
     def _initialize_providers(self) -> None:
         """Initialize all available providers based on session configuration."""
         self.providers = []
@@ -163,7 +176,7 @@ class Scanner:
 
             # Start new forensic session
             print(f"Starting new forensic session for scanner {id(self)}...")
-            self.logger = new_session()
+            self.logger = ForensicLogger()
 
             # Start scan in separate thread
             print(f"Starting scan thread for scanner {id(self)}...")