feat: Refactor log-alert application into modular structure

- Introduced alerters package with base Alerter class and implementations for LogAlerter and GotifyAlerter.
- Created fetchers package with abstract LogFetcher class and implementations for FileLogFetcher, LokiLogFetcher, and ParseableLogFetcher.
- Added filters package with base Filter class and implementations for RegexpFilter and GeolocationFilter.
- Implemented rules package with base AlertRule class and SimpleAlertRule for alerting logic.
- Enhanced configuration handling with utilities for loading and validating JSON configuration.
- Updated logging setup for better logging management.
- Modified main application logic to utilize the new modular structure, improving maintainability and readability.
- Updated config.json and config.schema.json to reflect changes in alerting and fetching configurations.
- Added python-dateutil to requirements for date parsing functionality.

log-alert/filters/__init__.py

@@ -0,0 +1,7 @@
+"""Filters package for log-alert."""
+
+from .base import Filter
+from .regexp import RegexpFilter
+from .geolocation import GeolocationFilter
+
+__all__ = ["Filter", "RegexpFilter", "GeolocationFilter"]

log-alert/filters/base.py

@@ -0,0 +1,20 @@
+"""Abstract base class for filters."""
+
+from abc import ABC, abstractmethod
+from typing import Dict, Any, Optional
+
+
+class Filter(ABC):
+    """Abstract base class for filters."""
+
+    @abstractmethod
+    def filter(self, log: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        """Apply filter to a log entry.
+        
+        Args:
+            log: Log entry dictionary
+            
+        Returns:
+            Modified log entry, or None if the log should be filtered out
+        """
+        pass

log-alert/filters/geolocation.py

@@ -0,0 +1,34 @@
+"""Geolocation filter implementation."""
+
+import logging
+import requests
+from typing import Dict, Any, Optional
+
+from .base import Filter
+
+logger = logging.getLogger("log-alert")
+
+
+class GeolocationFilter(Filter):
+    """Concrete implementation for Geolocation filter."""
+
+    def __init__(self, config: Dict[str, Any]):
+        self.source_field = config["source-field"]
+
+    def filter(self, log: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        ip_address = log.get("labels", {}).get(self.source_field)
+        if not ip_address:
+            logger.warning("No IP address found in log labels for geolocation")
+        else:
+            try:
+                response = requests.get(f"http://ip-api.com/json/{ip_address}").json()
+                if response["status"] == "success":
+                    logger.debug(f"Found info {response} for IP {ip_address}")
+                    del response["status"]
+                    del response["query"]
+                    log.setdefault("labels", {}).update(response)
+                else:
+                    logger.warning("No info found for IP {ip_address}")
+            except requests.exceptions.RequestException as e:
+                logger.error(f"Error fetching geolocation for IP {ip_address}: {e}")
+        return log

log-alert/filters/regexp.py

@@ -0,0 +1,29 @@
+"""Regexp filter implementation."""
+
+import logging
+import re
+from typing import Dict, Any, Optional
+
+from .base import Filter
+
+logger = logging.getLogger("log-alert")
+
+
+class RegexpFilter(Filter):
+    """Concrete implementation for Regexp filter."""
+
+    def __init__(self, config: Dict[str, Any]):
+        self.match = config["match"]
+
+    def filter(self, log: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        match = re.search(self.match, log["log"])
+        if match:
+            # Only call groupdict() when there is a match
+            groups = match.groupdict()
+            logger.debug(f"Regex match for '{self.match}' in log: {groups}")
+            if groups:
+                log.setdefault("labels", {}).update(groups)
+            return log
+        # no match
+        logger.debug(f"Regex did not match for pattern '{self.match}' in log: {log.get('log')}")
+        return None