Merge pull request #6 from madeiramadeirabr/health_check

Implementação de health check de monitoramento

Author: andersoncontreira

examples/lambda_api/app.py

@@ -8,7 +8,10 @@
 env = helper.get_environment()
 load_dot_env(env)
 
-# load env
+from lambda_app.services.v1.healthcheck import HealthCheckSchema
+from lambda_app.services.v1.healthcheck.resources import MysqlConnectionHealthCheck, RedisConnectionHealthCheck, \
+    SQSConnectionHealthCheck, SelfConnectionHealthCheck
+from lambda_app.services.v1.healthcheck_service import HealthCheckService
 from lambda_app.config import get_config
 from lambda_app.enums.events import EventType
 from lambda_app.enums.messages import MessagesEnum
@@ -65,10 +68,17 @@ def alive():
                     description: Success response
                     content:
                         application/json:
-                            schema: AliveSchema
+                            schema: HealthCheckSchema
         """
-    body = {"app": "I'm alive!"}
-    return http_helper.create_response(body=body, status_code=200)
+    # body = {"app": "I'm alive!"}
+    # return http_helper.create_response(body=body, status_code=200)
+    service = HealthCheckService()
+    service.add_check("self", SelfConnectionHealthCheck(logger, config), [])
+    service.add_check("mysql", MysqlConnectionHealthCheck(logger, config), ["db"])
+    service.add_check("redis", RedisConnectionHealthCheck(logger, config), ["redis"])
+    service.add_check("queue", SQSConnectionHealthCheck(logger, config), ["queue"])
+
+    return service.get_response()
 
 
 @app.route('/favicon-32x32.png')

examples/lambda_api/env/development.env

@@ -7,7 +7,7 @@ SQS_ENDPOINT=http://localstack:4566
 SQS_LOCALSTACK=http://localstack:4566
 APP_QUEUE=http://localstack:4566/000000000000/test-queue
 API_SERVER=http://localhost:5000
-API_SERVER_DESCRIPTION=Staging server
+API_SERVER_DESCRIPTION=Development server
 LOCAL_API_SERVER=http://localhost:5000
 LOCAL_API_SERVER_DESCRIPTION=Development server
 REDIS_HOST=redis

examples/lambda_api/lambda_app/events/aws/sqs.py

@@ -52,6 +52,7 @@ def connect(self, retry=False):
                     self.logger.info('SQSEvents - Connected')
                     self.logger.error(err)
                 else:
+                    connection = None
                     raise err
 
             _CONNECTION = connection

examples/lambda_api/lambda_app/helper.py

@@ -78,7 +78,7 @@ def to_dict(obj, force_str=False):
 
 
 def to_json(obj):
-    return json.dumps(obj)
+    return json.dumps(obj, default=str)
 
 
 def debug_mode():

examples/lambda_api/lambda_app/services/v1/healthcheck/__init__.py

@@ -0,0 +1,105 @@
+import json
+from datetime import timedelta
+
+from lambda_app import helper
+from lambda_app.config import get_config
+from lambda_app.enums import CustomStringEnum
+from lambda_app.http_resources.response import ApiResponse
+from lambda_app.logging import get_logger
+from flask import Response
+from marshmallow import Schema, fields
+
+
+class HealthStatus(CustomStringEnum):
+    # all available
+    HEALTHY = 'healthy'
+    # partial
+    DEGRADED = 'degraded'
+    # unavailable
+    UNHEALTHY = 'unhealthy'
+
+
+class HealthCheckResult:
+    def __init__(self, status, description):
+        self.status = status if status is not None and isinstance(status, HealthStatus) else HealthStatus.UNHEALTHY
+        self.description = description if description is not None else ""
+
+    @staticmethod
+    def healthy(description):
+        return HealthCheckResult(HealthStatus.HEALTHY, description)
+
+    @staticmethod
+    def unhealthy(description):
+        return HealthCheckResult(HealthStatus.UNHEALTHY, description)
+
+    @staticmethod
+    def degraded(description):
+        return HealthCheckResult(HealthStatus.DEGRADED, description)
+
+
+class EntrySchema(Schema):
+    status = fields.Str(example=HealthStatus.HEALTHY.value)
+    duration = fields.Str(example="0:00:00.013737")
+    tags = fields.List(fields.Str(example="db"))
+
+
+class EntryData(Schema):
+    name = fields.Nested(EntrySchema)
+
+
+class HealthCheckSchema(Schema):
+    status = fields.Str(example=HealthStatus.HEALTHY.value)
+    total_duration = fields.Str(example="0:00:00.013737")
+    entries = fields.Nested(EntryData)
+
+
+class AbstractHealthCheck:
+    def __init__(self, logger=None, config=None):
+        # logger
+        self.logger = logger if logger is not None else get_logger()
+        # configurations
+        self.config = config if config is not None else get_config()
+
+    def check_health(self):
+        return HealthCheckResult.unhealthy("undefined test")
+
+
+class HealthCheckResponse(ApiResponse):
+
+    def __init__(self, api_request=None):
+        super(HealthCheckResponse, self).__init__(api_request)
+        self.status_code = 200
+        self.status = HealthStatus.HEALTHY
+        self.total_duration = timedelta()
+        self.duration = timedelta()
+        self.entries = {}
+
+    def get_response(self, status_code=None):
+
+        if not status_code:
+            if self.status == HealthStatus.UNHEALTHY:
+                self.status_code = 503
+            elif self.status == HealthStatus.DEGRADED:
+                self.status_code = 424
+        else:
+            self.status_code = status_code
+
+        headers = self.headers
+
+        # # update entries
+        # self.entries["self"] = {
+        #     "status": self.self_status,
+        #     "duration": self.duration,
+        #     "tags": []
+        # }
+        self.entries.update(self.data)
+
+        body = {
+            "status": self.status,
+            "total_duration": self.total_duration,
+            "entries": self.entries
+        }
+
+        if 'Content-Type' in headers and headers['Content-Type'] == 'application/json':
+            body = helper.to_json(body)
+        return Response(response=body, status=self.status_code, headers=headers)

examples/lambda_api/lambda_app/services/v1/healthcheck/resources.py

@@ -0,0 +1,120 @@
+import os
+
+import requests
+
+from lambda_app.services.v1.healthcheck import AbstractHealthCheck, HealthCheckResult
+from lambda_app.database.mysql import get_connection
+from lambda_app.database.redis import get_connection as redis_get_connection
+from lambda_app.events.aws.sqs import SQSEvents
+
+
+class SelfConnectionHealthCheck(AbstractHealthCheck):
+    def __init__(self, logger=None, config=None):
+        super().__init__(logger=logger, config=config)
+
+    def check_health(self):
+        result = False
+        description = "Unable to connect"
+        check_result = HealthCheckResult.unhealthy(description)
+        response = None
+        try:
+            result = True
+            url = os.environ["API_SERVER"] if "API_SERVER" in os.environ else None
+            url = url + "/docs"
+            self.logger.info("requesting url: {}".format(url))
+            response = requests.get(url)
+            if response:
+                if response.status_code == 200:
+                    result = True
+                    description = "Connection successful"
+                else:
+                    result = False
+                    description = "Something wrong"
+                    check_result = HealthCheckResult.degraded(description)
+            else:
+                raise Exception("Unable to connect")
+        except Exception as err:
+            self.logger.error(err)
+
+        if result:
+            check_result = HealthCheckResult.healthy(description)
+        return check_result
+
+
+class MysqlConnectionHealthCheck(AbstractHealthCheck):
+    def __init__(self, logger=None, config=None, mysql_connection=None):
+        super().__init__(logger=logger, config=config)
+        # database connection
+        self.mysql_connection = mysql_connection if mysql_connection is not None else get_connection()
+
+    def check_health(self):
+        result = False
+        description = "Unable to connect"
+        check_result = HealthCheckResult.unhealthy(description)
+
+        try:
+            if self.mysql_connection:
+                self.mysql_connection.connect()
+                self.mysql_connection.ping()
+                result = True
+                description = "Connection successful"
+            else:
+                raise Exception("mysql_connection is None")
+        except Exception as err:
+            self.logger.error(err)
+
+        if result:
+            check_result = HealthCheckResult.healthy(description)
+        return check_result
+
+
+class RedisConnectionHealthCheck(AbstractHealthCheck):
+    def __init__(self, logger=None, config=None, redis_connection=None):
+        super().__init__(logger=logger, config=config)
+        # database connection
+        self.redis_connection = redis_connection if redis_connection is not None else redis_get_connection()
+
+    def check_health(self):
+        result = False
+        description = "Unable to connect"
+        check_result = HealthCheckResult.unhealthy(description)
+
+        try:
+            if self.redis_connection:
+                result = self.redis_connection.set('connection', 'true')
+                description = "Connection successful"
+            else:
+                raise Exception("redis_connection is None")
+        except Exception as err:
+            self.logger.error(err)
+
+        if result:
+            check_result = HealthCheckResult.healthy(description)
+        return check_result
+
+
+class SQSConnectionHealthCheck(AbstractHealthCheck):
+    def __init__(self, logger=None, config=None, sqs_events=None):
+        super().__init__(logger=logger, config=config)
+        # sqs_events connection
+        self.sqs_events = sqs_events if sqs_events is not None else SQSEvents()
+
+    def check_health(self):
+        result = False
+        description = "Unable to connect"
+        check_result = HealthCheckResult.unhealthy(description)
+
+        try:
+            if self.sqs_events:
+                connection = self.sqs_events.connect()
+                if connection:
+                    result = True
+                    description = "Connection successful"
+            else:
+                raise Exception("redis_connection is None")
+        except Exception as err:
+            self.logger.error(err)
+
+        if result:
+            check_result = HealthCheckResult.healthy(description)
+        return check_result

examples/lambda_api/lambda_app/services/v1/healthcheck_service.py

@@ -0,0 +1,90 @@
+import datetime
+
+from lambda_app.config import get_config
+from lambda_app.logging import get_logger
+from lambda_app.services.v1.healthcheck import AbstractHealthCheck, HealthCheckResponse, HealthStatus
+
+
+class HealthCheckService:
+    def __init__(self, logger=None, config=None):
+        # logger
+        self.logger = logger if logger is not None else get_logger()
+        # configurations
+        self.config = config if config is not None else get_config()
+        # checks
+        self.entries = []
+
+    def add_check(self, name: str, health_check, tags: list, args: dict = None):
+        entry = {
+            "name": name,
+            "health_check": health_check,
+            "tags": tags,
+            "args": args
+        }
+        self.entries.append(entry)
+
+    def get_result(self):
+
+        service_status = HealthStatus.HEALTHY
+        total_duration = datetime.timedelta()
+
+        result = {
+            "status": service_status,
+            "total_duration": total_duration,
+            "entries": {}
+        }
+
+        for entry in self.entries:
+            name = entry["name"]
+            health_check = entry["health_check"]
+            tags = entry["tags"]
+            args = entry["args"]
+            status = HealthStatus.UNHEALTHY
+            start = datetime.datetime.now()
+
+            try:
+                if isinstance(health_check, AbstractHealthCheck):
+                    check = health_check.check_health()
+                elif callable(health_check):
+                    if args and len(args) > 0:
+                        check = health_check(**args)
+                    else:
+                        check = health_check()
+                else:
+                    check = None
+                if check is None or check.status == HealthStatus.UNHEALTHY:
+                    status = HealthStatus.UNHEALTHY
+                else:
+                    status = check.status
+
+            except Exception as err:
+                self.logger.error(err)
+
+            end = datetime.datetime.now()
+            duration = (end - start)
+            total_duration = total_duration.__add__(duration)
+
+            if status != HealthStatus.HEALTHY:
+                if service_status == HealthStatus.HEALTHY:
+                    service_status = HealthStatus.DEGRADED
+                else:
+                    service_status = HealthStatus.UNHEALTHY
+
+            result["entries"][name] = {
+                "status": status,
+                "duration": duration,
+                "tags": tags
+            }
+
+        # update variables
+        result["status"] = service_status
+        result["total_duration"] = total_duration
+        return result
+
+    def get_response(self):
+        result = self.get_result()
+        response = HealthCheckResponse()
+        response.status = result["status"]
+        response.total_duration = result["total_duration"]
+        response.set_data(result["entries"])
+        return response.get_response()

examples/lambda_api/lambda_app/services/v1/ocoren_event_service.py

@@ -15,7 +15,7 @@ def __init__(self, logger=None, config=None, sqs_events=None):
         self.logger = logger if logger is not None else get_logger()
         # configurations
         self.config = config if config is not None else get_config()
-        # database connection
+        # sqs event service
         self.sqs_events = sqs_events if sqs_events is not None else SQSEvents()
         # queue_url
         self.queue = self.config.APP_QUEUE