Human rework of the PR task

Author: tmikula-dev

conf/api.yaml

@@ -66,12 +66,14 @@ paths:
                   status:
                     type: string
                     example: degraded
-                  details:
+                  failures:
                     type: object
                     additionalProperties:
                       type: string
                     example:
-                      kafka: not_initialized
+                      eventbridge: client not initialized
+                      kafka: producer not initialized
+                      postgres: host not configured
 
   /topics:
     get:

src/event_gate_lambda.py

@@ -87,7 +87,7 @@
 handler_topic = HandlerTopic(CONF_DIR, ACCESS, handler_token).load_topic_schemas()
 
 # Initialize health handler
-handler_health = HandlerHealth(logger, config)
+handler_health = HandlerHealth()
 
 
 def get_api() -> Dict[str, Any]:

src/handlers/handler_health.py

@@ -19,83 +19,74 @@
 """
 import json
 import logging
+import os
 from datetime import datetime, timezone
 from typing import Dict, Any
 
 from src.writers import writer_eventbridge, writer_kafka, writer_postgres
 
+logger = logging.getLogger(__name__)
+log_level = os.environ.get("LOG_LEVEL", "INFO")
+logger.setLevel(log_level)
+
 
 class HandlerHealth:
     """
     HandlerHealth manages service health checks and dependency status monitoring.
     """
 
-    def __init__(self, logger_instance: logging.Logger, config: Dict[str, Any]):
-        """
-        Initialize the health handler.
-
-        Args:
-            logger_instance: Shared application logger.
-            config: Configuration dictionary.
-        """
-        self.logger = logger_instance
-        self.config = config
-        self.start_time = datetime.now(timezone.utc)
+    def __init__(self):
+        self.start_time: datetime = datetime.now(timezone.utc)
 
     def get_health(self) -> Dict[str, Any]:
         """
         Check service health and return status.
 
-        Performs lightweight dependency checks by verifying that writer STATE
-        dictionaries are properly initialized with required keys.
-
         Returns:
             Dict[str, Any]: API Gateway response with health status.
                 - 200: All dependencies healthy
                 - 503: One or more dependencies not initialized
         """
-        self.logger.debug("Handling GET Health")
-
-        details: Dict[str, str] = {}
-        all_healthy = True
-
-        # Check Kafka writer STATE
-        kafka_state = writer_kafka.STATE
-        if not all(key in kafka_state for key in ["logger", "producer"]):
-            details["kafka"] = "not_initialized"
-            all_healthy = False
-            self.logger.debug("Kafka writer not properly initialized")
-
-        # Check EventBridge writer STATE
-        eventbridge_state = writer_eventbridge.STATE
-        if not all(key in eventbridge_state for key in ["logger", "client", "event_bus_arn"]):
-            details["eventbridge"] = "not_initialized"
-            all_healthy = False
-            self.logger.debug("EventBridge writer not properly initialized")
-
-        # Check PostgreSQL writer - it uses global logger variable and POSTGRES dict
-        # Just verify the module is accessible (init is always called in event_gate_lambda)
-        try:
-            _ = writer_postgres.logger
-        except AttributeError:
-            details["postgres"] = "not_initialized"
-            all_healthy = False
-            self.logger.debug("PostgreSQL writer not accessible")
+        logger.debug("Handling GET Health")
+
+        failures: Dict[str, str] = {}
+
+        # Check Kafka writer
+        if writer_kafka.STATE.get("producer") is None:
+            failures["kafka"] = "producer not initialized"
+
+        # Check EventBridge writer
+        eventbus_arn = writer_eventbridge.STATE.get("event_bus_arn")
+        eventbridge_client = writer_eventbridge.STATE.get("client")
+        if eventbus_arn:
+            if eventbridge_client is None:
+                failures["eventbridge"] = "client not initialized"
+
+        # Check PostgreSQL writer
+        postgres_config = writer_postgres.POSTGRES
+        if postgres_config.get("database"):
+            if not postgres_config.get("host"):
+                failures["postgres"] = "host not configured"
+            elif not postgres_config.get("user"):
+                failures["postgres"] = "user not configured"
+            elif not postgres_config.get("password"):
+                failures["postgres"] = "password not configured"
+            elif not postgres_config.get("port"):
+                failures["postgres"] = "port not configured"
 
-        # Calculate uptime
         uptime_seconds = int((datetime.now(timezone.utc) - self.start_time).total_seconds())
 
-        if all_healthy:
-            self.logger.debug("Health check passed - all dependencies healthy")
+        if not failures:
+            logger.debug("Health check passed")
             return {
                 "statusCode": 200,
                 "headers": {"Content-Type": "application/json"},
                 "body": json.dumps({"status": "ok", "uptime_seconds": uptime_seconds}),
             }
 
-        self.logger.debug("Health check degraded - some dependencies not initialized: %s", details)
+        logger.debug("Health check degraded: %s", failures)
         return {
             "statusCode": 503,
             "headers": {"Content-Type": "application/json"},
-            "body": json.dumps({"status": "degraded", "details": details}),
+            "body": json.dumps({"status": "degraded", "failures": failures}),
         }

tests/handlers/test_handler_health.py

@@ -16,126 +16,131 @@
 
 import json
 from unittest.mock import MagicMock, patch
-import logging
 
 from src.handlers.handler_health import HandlerHealth
 
+### get_health()
 
-## get_health() - healthy state
-def test_get_health_all_dependencies_healthy():
-    """Health check returns 200 when all writer STATEs are properly initialized."""
-    logger = logging.getLogger("test")
-    config = {}
-    handler = HandlerHealth(logger, config)
+## Minimal healthy state (just kafka)
+def test_get_health_minimal_kafka_healthy():
+    """Health check returns 200 when Kafka is initialized and optional writers are disabled."""
+    handler = HandlerHealth()
 
-    # Mock all writers as healthy
     with (
-        patch("src.handlers.handler_health.writer_kafka.STATE", {"logger": logger, "producer": MagicMock()}),
-        patch(
-            "src.handlers.handler_health.writer_eventbridge.STATE",
-            {
-                "logger": logger,
-                "client": MagicMock(),
-                "event_bus_arn": "arn:aws:events:us-east-1:123456789012:event-bus/my-bus",
-            },
-        ),
-        patch("src.handlers.handler_health.writer_postgres.logger", logger),
+        patch("src.handlers.handler_health.writer_kafka.STATE", {"producer": MagicMock()}),
+        patch("src.handlers.handler_health.writer_eventbridge.STATE", {"client": None, "event_bus_arn": ""}),
+        patch("src.handlers.handler_health.writer_postgres.POSTGRES", {"database": ""}),
+    ):
+        response = handler.get_health()
+
+    assert response["statusCode"] == 200
+    body = json.loads(response["body"])
+    assert body["status"] == "ok"
+    assert "uptime_seconds" in body
+
+
+## Healthy state with all writers enabled
+def test_get_health_all_writers_enabled_and_healthy():
+    """Health check returns 200 when all writers are enabled and properly configured."""
+    handler = HandlerHealth()
+    postgres_config = {"database": "db", "host": "localhost", "user": "user", "password": "pass", "port": "5432"}
+
+    with (
+        patch("src.handlers.handler_health.writer_kafka.STATE", {"producer": MagicMock()}),
+        patch("src.handlers.handler_health.writer_eventbridge.STATE", {"client": MagicMock(), "event_bus_arn": "arn"}),
+        patch("src.handlers.handler_health.writer_postgres.POSTGRES", postgres_config),
     ):
         response = handler.get_health()
 
     assert response["statusCode"] == 200
     body = json.loads(response["body"])
     assert body["status"] == "ok"
     assert "uptime_seconds" in body
-    assert isinstance(body["uptime_seconds"], int)
-    assert body["uptime_seconds"] >= 0
 
 
-## get_health() - degraded state - kafka
+## Degraded state with all writers enabled
 def test_get_health_kafka_not_initialized():
     """Health check returns 503 when Kafka writer is not initialized."""
-    logger = logging.getLogger("test")
-    config = {}
-    handler = HandlerHealth(logger, config)
+    handler = HandlerHealth()
+    postgres_config = {"database": "db", "host": "", "user": "", "password": "", "port": ""}
 
-    # Mock Kafka as not initialized (missing producer key)
     with (
-        patch("src.handlers.handler_health.writer_kafka.STATE", {"logger": logger}),
+        patch("src.handlers.handler_health.writer_kafka.STATE", {"producer": None}),
         patch(
             "src.handlers.handler_health.writer_eventbridge.STATE",
-            {"logger": logger, "client": MagicMock(), "event_bus_arn": "arn"},
+            {"client": None, "event_bus_arn": "arn:aws:events:us-east-1:123:event-bus/bus"}
         ),
-        patch("src.handlers.handler_health.writer_postgres.logger", logger),
+        patch("src.handlers.handler_health.writer_postgres.POSTGRES", postgres_config),
     ):
         response = handler.get_health()
 
     assert response["statusCode"] == 503
     body = json.loads(response["body"])
     assert body["status"] == "degraded"
-    assert "details" in body
-    assert "kafka" in body["details"]
-    assert body["details"]["kafka"] == "not_initialized"
+    assert "kafka" in body["failures"]
+    assert "eventbridge" in body["failures"]
+    assert "postgres" in body["failures"]
 
 
-## get_health() - degraded state - eventbridge
-def test_get_health_eventbridge_not_initialized():
-    """Health check returns 503 when EventBridge writer is not initialized."""
-    logger = logging.getLogger("test")
-    config = {}
-    handler = HandlerHealth(logger, config)
+## Healthy when eventbridge is disabled
+def test_get_health_eventbridge_disabled():
+    """Health check returns 200 when EventBridge is disabled (empty event_bus_arn)."""
+    handler = HandlerHealth()
+    postgres_config = {"database": "db", "host": "localhost", "user": "user", "password": "pass", "port": "5432"}
 
-    # Mock EventBridge as not initialized (missing client key)
     with (
-        patch("src.handlers.handler_health.writer_kafka.STATE", {"logger": logger, "producer": MagicMock()}),
-        patch("src.handlers.handler_health.writer_eventbridge.STATE", {"logger": logger}),
-        patch("src.handlers.handler_health.writer_postgres.logger", logger),
+        patch("src.handlers.handler_health.writer_kafka.STATE", {"producer": MagicMock()}),
+        patch("src.handlers.handler_health.writer_eventbridge.STATE", {"client": None, "event_bus_arn": ""}),
+        patch("src.handlers.handler_health.writer_postgres.POSTGRES", postgres_config),
     ):
         response = handler.get_health()
 
-    assert response["statusCode"] == 503
-    body = json.loads(response["body"])
-    assert body["status"] == "degraded"
-    assert "eventbridge" in body["details"]
-    assert body["details"]["eventbridge"] == "not_initialized"
+    assert response["statusCode"] == 200
+
+
+## Healthy when postgres is disabled
+def test_get_health_postgres_disabled():
+    """Health check returns 200 when PostgreSQL is disabled (empty database)."""
+    handler = HandlerHealth()
+
+    with (
+        patch("src.handlers.handler_health.writer_kafka.STATE", {"producer": MagicMock()}),
+        patch("src.handlers.handler_health.writer_eventbridge.STATE", {"client": MagicMock(), "event_bus_arn": "arn"}),
+        patch("src.handlers.handler_health.writer_postgres.POSTGRES", {"database": ""}),
+    ):
+        response = handler.get_health()
+
+    assert response["statusCode"] == 200
 
 
-## get_health() - degraded state - multiple failures
-def test_get_health_multiple_dependencies_not_initialized():
-    """Health check returns 503 when multiple writers are not initialized."""
-    logger = logging.getLogger("test")
-    config = {}
-    handler = HandlerHealth(logger, config)
+## Degraded state - postgres host not configured
+def test_get_health_postgres_host_not_configured():
+    """Health check returns 503 when PostgreSQL host is not configured."""
+    handler = HandlerHealth()
+    postgres_config = {"database": "db", "host": "", "user": "user", "password": "pass", "port": "5432"}
 
-    # Mock multiple writers as not initialized
     with (
-        patch("src.handlers.handler_health.writer_kafka.STATE", {}),
-        patch("src.handlers.handler_health.writer_eventbridge.STATE", {}),
-        patch("src.handlers.handler_health.writer_postgres", spec=[]),  # spec=[] makes logger not exist
+        patch("src.handlers.handler_health.writer_kafka.STATE", {"producer": MagicMock()}),
+        patch("src.handlers.handler_health.writer_eventbridge.STATE", {"client": MagicMock(), "event_bus_arn": "arn"}),
+        patch("src.handlers.handler_health.writer_postgres.POSTGRES", postgres_config),
     ):
         response = handler.get_health()
 
     assert response["statusCode"] == 503
     body = json.loads(response["body"])
-    assert body["status"] == "degraded"
-    assert len(body["details"]) >= 2  # At least kafka and eventbridge
-    assert "kafka" in body["details"]
-    assert "eventbridge" in body["details"]
+    assert body["failures"]["postgres"] == "host not configured"
 
 
-## get_health() - uptime calculation
+## Uptime calculation
 def test_get_health_uptime_is_positive():
     """Verify uptime_seconds is calculated and is a positive integer."""
-    logger = logging.getLogger("test")
-    config = {}
-    handler = HandlerHealth(logger, config)
+    handler = HandlerHealth()
+    postgres_config = {"database": "db", "host": "localhost", "user": "user", "password": "pass", "port": "5432"}
 
     with (
-        patch("src.handlers.handler_health.writer_kafka.STATE", {"logger": logger, "producer": MagicMock()}),
-        patch(
-            "src.handlers.handler_health.writer_eventbridge.STATE",
-            {"logger": logger, "client": MagicMock(), "event_bus_arn": "arn"},
-        ),
-        patch("src.handlers.handler_health.writer_postgres.logger", logger),
+        patch("src.handlers.handler_health.writer_kafka.STATE", {"producer": MagicMock()}),
+        patch("src.handlers.handler_health.writer_eventbridge.STATE", {"client": MagicMock(), "event_bus_arn": "arn"}),
+        patch("src.handlers.handler_health.writer_postgres.POSTGRES", postgres_config),
     ):
         response = handler.get_health()