sharedkernel 2.4.1__tar.gz → 2.5.2__tar.gz

{sharedkernel-2.4.1 → sharedkernel-2.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sharedkernel
-Version: 2.4.1
+Version: 2.5.2
 Summary: sharekernel is a shared package between all python projects
 Author: Smilinno
 Description-Content-Type: text/markdown
@@ -19,6 +19,7 @@ Requires-Dist: mammoth
 Requires-Dist: markdown
 Requires-Dist: beautifulsoup4
 Requires-Dist: deepdiff
+Requires-Dist: kombu
 Dynamic: author
 Dynamic: description
 Dynamic: description-content-type
@@ -29,6 +30,12 @@ Dynamic: summary
 this is a shared kernel package
 
 # Change Log
+### Version 2.5.2
+- Minor Fix
+### Version 2.5.1
+- Apply log on jwt service
+### Version 2.5.0
+- Implement logger
 ### Version 2.4.1
 - Fix file validation
 ### Version 2.4.0

{sharedkernel-2.4.1 → sharedkernel-2.5.2}/README.md

@@ -2,6 +2,12 @@
 this is a shared kernel package
 
 # Change Log
+### Version 2.5.2
+- Minor Fix
+### Version 2.5.1
+- Apply log on jwt service
+### Version 2.5.0
+- Implement logger
 ### Version 2.4.1
 - Fix file validation
 ### Version 2.4.0

{sharedkernel-2.4.1 → sharedkernel-2.5.2}/setup.py

@@ -17,6 +17,7 @@ setup(
         "sharedkernel.exception",
         "sharedkernel.objects",
         "sharedkernel.normalizer",
+        "sharedkernel.logger",
     ],
     # Needed for dependencies
     install_requires=[
@@ -35,9 +36,10 @@ setup(
         "markdown",
         "beautifulsoup4",
         "deepdiff",
+        "kombu",
     ],
     # *strongly* suggested for sharing
-    version="2.4.1",
+    version="2.5.2",
     description="sharekernel is a shared package between all python projects",
     long_description=long_description,
     long_description_content_type="text/markdown",

{sharedkernel-2.4.1 → sharedkernel-2.5.2}/sharedkernel/jwt_service.py

@@ -5,6 +5,7 @@ from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
 from sharedkernel.exception.exception import UnAuthorizedException
 from sharedkernel.objects import JwtModel
 from sharedkernel.objects.user_info import current_user_info, UserInfo
+from sharedkernel.logger.log_decorator import unified_logger
 
 
 class JWTBearer(HTTPBearer):
@@ -13,6 +14,7 @@ class JWTBearer(HTTPBearer):
         self.jwt_config = jwt_config
         super(JWTBearer, self).__init__(auto_error=auto_error)
 
+    @unified_logger(class_name="JWTBearer")
     async def __call__(self, request: Request):
         try:
             if current_user_info.get(None):
@@ -33,6 +35,7 @@ class JWTBearer(HTTPBearer):
         except:
             raise UnAuthorizedException()
 
+    @unified_logger(class_name="JWTBearer")
     def verify(self, token: str) -> dict:
         decoded_token = jwt.decode(
             jwt=token.replace("Bearer", "").strip(),

sharedkernel-2.5.2/sharedkernel/logger/log_decorator.py

@@ -0,0 +1,64 @@
+import inspect
+from functools import wraps
+from typing import Callable, Type
+from asyncio import iscoroutinefunction
+import os
+
+from sharedkernel.logger.logger_service import LoggerService
+
+LOG_ENABLE = True if os.getenv("LOG_ENABLE", "True").lower() == "true" else False
+print("Log Enable" if LOG_ENABLE else "Log Disable")
+
+logger = LoggerService()
+
+def decorate_class_methods(cls: Type) -> Type:
+    for name, attr in cls.__dict__.items():
+        if name.startswith("_"):
+            continue
+
+        if isinstance(attr, staticmethod):
+            original = attr.__func__
+            wrapped = unified_logger(class_name=cls.__name__)(original)
+            setattr(cls, name, staticmethod(wrapped))
+
+        elif isinstance(attr, classmethod):
+            original = attr.__func__
+            wrapped = unified_logger(class_name=cls.__name__)(original)
+            setattr(cls, name, classmethod(wrapped))
+
+        elif callable(attr):
+            wrapped = unified_logger(class_name=cls.__name__)(attr)
+            setattr(cls, name, wrapped)
+
+    return cls
+
+
+
+def unified_logger(endpoint_name: str = None, class_name: str = None) -> Callable:
+    def decorator(target: Callable | Type):
+
+        if not LOG_ENABLE:
+            return target
+
+        if inspect.isclass(target):
+            return decorate_class_methods(target)
+
+        method_name = f"{class_name}.{target.__name__}" if class_name else target.__name__
+
+        if iscoroutinefunction(target):
+
+            @wraps(target)
+            async def async_wrapper(*args, **kwargs):
+                return await logger.execute_async(target, args, kwargs, method_name, endpoint_name)
+
+            return async_wrapper
+
+        else:
+
+            @wraps(target)
+            def sync_wrapper(*args, **kwargs):
+                return logger.execute_sync(target, args, kwargs, method_name, endpoint_name)
+
+            return sync_wrapper
+
+    return decorator

sharedkernel-2.5.2/sharedkernel/logger/log_dto.py

@@ -0,0 +1,23 @@
+from typing import Optional
+from pydantic import BaseModel
+import datetime
+
+from sharedkernel.logger.log_enums import LogEventTypeEnum, LogLevelEnum
+
+
+class LogDTO(BaseModel):
+    EventType : Optional[LogEventTypeEnum] = None
+    Description: Optional[str] = None
+    MethodName: Optional[str] = None
+    IsSuccess : Optional[bool] = None
+    UserId : Optional[str] = None
+    UserName : Optional[str] = None
+    FailureReason : Optional[str] = None
+    UserAgent : Optional[str] = None
+    IpAddress : Optional[str] = None
+    RequestPath : Optional[str] = None
+    ServiceName : Optional[str] = None
+    HttpMethod : Optional[str] = None
+    CorrelationId : Optional[str] = None
+    Level : Optional[LogLevelEnum] = None
+    CreatedOn : datetime.datetime = None

sharedkernel-2.5.2/sharedkernel/logger/log_enums.py

@@ -0,0 +1,12 @@
+from enum import IntEnum
+
+class LogEventTypeEnum(IntEnum):
+    START = 1
+    END = 2
+
+class LogLevelEnum(IntEnum):
+    INFORMATION = 1
+    WARNING = 2
+    CRITICAL = 3
+    SECURITY = 4
+    ERROR = 5

sharedkernel-2.5.2/sharedkernel/logger/log_info.py

@@ -0,0 +1,5 @@
+from contextvars import ContextVar
+
+from sharedkernel.logger.log_dto import LogDTO
+
+log_info: ContextVar[LogDTO] = ContextVar("log_info")

sharedkernel-2.5.2/sharedkernel/logger/log_middlewares.py

@@ -0,0 +1,38 @@
+import uuid
+from typing import Callable
+import os
+from fastapi import Request, Response
+from starlette.middleware.base import BaseHTTPMiddleware
+
+
+from sharedkernel.logger.log_info import log_info
+from sharedkernel.logger.log_dto import LogDTO
+
+IP_HEADER_NAME = os.getenv("IP_HEADER_NAME")
+LOG_ENABLE = True if os.getenv("LOG_ENABLE", "True").lower() == "true" else False
+
+class LogMiddleware(BaseHTTPMiddleware):
+
+    async def dispatch(self, request: Request, call_next: Callable) -> Response:
+
+        if not LOG_ENABLE:
+            return await call_next(request)
+
+        correlation_id = request.headers.get("x-request-id") or uuid.uuid4().hex
+        ip_address = request.headers.get(IP_HEADER_NAME)
+        log_obj = LogDTO(
+            CorrelationId=correlation_id,
+            RequestPath=request.url.path,
+            HttpMethod=request.method,
+            UserAgent=request.headers.get("user-agent"),
+            IpAddress=ip_address,
+        )
+
+        log_info.set(log_obj)
+
+        response = await call_next(request)
+        
+        return response
+
+
+    

sharedkernel-2.5.2/sharedkernel/logger/logger_service.py

@@ -0,0 +1,155 @@
+from fastapi import HTTPException, WebSocket
+from kombu import Connection, Producer, Exchange
+from pydantic import BaseModel
+from typing import Optional
+import datetime
+import uuid
+import os
+
+from sharedkernel.logger.log_info import log_info
+from sharedkernel.enum import ErrorCode
+from sharedkernel.objects.user_info import current_user_info
+from sharedkernel.exception.exception import BusinessException
+from sharedkernel.logger.log_dto import LogDTO
+from sharedkernel.logger.log_enums import LogEventTypeEnum, LogLevelEnum
+
+RABBITMQ_USER = os.getenv("RABBITMQ_USER")
+RABBITMQ_PASSWORD = os.getenv("RABBITMQ_PASSWORD")
+RABBITMQ_HOST = os.getenv("RABBITMQ_HOST")
+RABBITMQ_VHOST = os.getenv("RABBITMQ_VHOST")
+LOG_EXCHANGE = os.getenv("LOG_EXCHANGE")
+LOG_REQUESTS_QUEUE = os.getenv("LOG_REQUESTS_QUEUE")
+SERVICE_NAME = os.getenv("SERVICE_NAME")
+IP_HEADER_NAME = os.getenv("IP_HEADER_NAME")
+
+rabbitmq_url = (
+    f"amqp://{RABBITMQ_USER}:{RABBITMQ_PASSWORD}"
+    f"@{RABBITMQ_HOST}/{RABBITMQ_VHOST}"
+)
+
+class LoggerService:
+    def __init__(self):
+        self._connection: Optional[Connection] = None
+        self._producer: Optional[Producer] = None
+        self._exchange = Exchange(LOG_EXCHANGE, type="topic")
+
+
+    def _ensure_connection(self):
+        if not self._connection or not self._connection.connected:
+            self._connection = Connection(rabbitmq_url)
+            self._connection.connect()
+            self._producer = Producer(self._connection)
+
+
+    def publish(self, log: BaseModel):
+        self._ensure_connection()
+
+        self._producer.publish(
+            body=log.model_dump_json(),
+            exchange=self._exchange,
+            routing_key=LOG_REQUESTS_QUEUE,
+            headers={
+                "cap-msg-id": str(uuid.uuid4()),
+                "cap-msg-name": LOG_REQUESTS_QUEUE,
+            },
+            content_type="application/json",
+            retry=True
+        )
+    
+
+    def build(
+        self,
+        method_name: str,
+        event_type: LogEventTypeEnum,
+        endpoint_name: str = None,
+        is_success: bool = True,
+        failure_reason: Optional[str] = None,
+    ) -> LogDTO:
+
+        log = log_info.get()
+        user = current_user_info.get(None)
+        if user:
+            log.UserId = user.nameid
+        log.ServiceName = SERVICE_NAME
+        log.MethodName = method_name
+        log.Description = endpoint_name
+        log.IsSuccess = is_success
+        log.Level = LogLevelEnum.INFORMATION if is_success else LogLevelEnum.ERROR
+        log.EventType = event_type
+        log.FailureReason = failure_reason
+        log.CreatedOn = datetime.datetime.now(datetime.timezone.utc)
+
+        return log
+
+
+    def map_exception(self, exc: Exception):
+        if isinstance(exc, BusinessException):
+            return str(exc.detail)
+        if isinstance(exc, HTTPException):
+            return str(exc.detail)
+        return ErrorCode.Internal_Server
+
+
+    def emit(self, log: LogDTO):
+        self.publish(log)
+
+
+    async def execute_async(self, target, args, kwargs, method_name, endpoint_name):
+        self.emit(self.build(method_name, LogEventTypeEnum.START, endpoint_name))
+
+        try:
+            result = await target(*args, **kwargs)
+
+        except Exception as exc:
+            self.emit(
+                self.build(
+                    method_name,
+                    LogEventTypeEnum.END,
+                    endpoint_name,
+                    is_success=False,
+                    failure_reason=self.map_exception(exc),
+                )
+            )
+            raise
+
+        else:
+            self.emit(self.build(method_name, LogEventTypeEnum.END, endpoint_name))
+            return result
+
+
+    def execute_sync(self, target, args, kwargs, method_name, endpoint_name):
+        self.emit(self.build(method_name, LogEventTypeEnum.START, endpoint_name))
+
+        try:
+            result = target(*args, **kwargs)
+
+        except Exception as exc:
+            self.emit(
+                self.build(
+                    method_name,
+                    LogEventTypeEnum.END,
+                    endpoint_name,
+                    is_success=False,
+                    failure_reason=self.map_exception(exc),
+                )
+            )
+            raise
+
+        else:
+            self.emit(self.build(method_name, LogEventTypeEnum.END, endpoint_name))
+            return result
+
+    @staticmethod
+    def websocket_handler(websocket: WebSocket):
+        correlation_id = websocket.headers.get("x-request-id") or uuid.uuid4().hex
+        ip_address = websocket.headers.get(IP_HEADER_NAME)
+
+        log_obj = LogDTO(
+            CorrelationId=correlation_id,
+            RequestPath=websocket.url.path,
+            HttpMethod="ws",
+            UserAgent=websocket.headers.get("user-agent"),
+            IpAddress=ip_address,
+        )
+
+        log_info.set(log_obj)

{sharedkernel-2.4.1 → sharedkernel-2.5.2}/sharedkernel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sharedkernel
-Version: 2.4.1
+Version: 2.5.2
 Summary: sharekernel is a shared package between all python projects
 Author: Smilinno
 Description-Content-Type: text/markdown
@@ -19,6 +19,7 @@ Requires-Dist: mammoth
 Requires-Dist: markdown
 Requires-Dist: beautifulsoup4
 Requires-Dist: deepdiff
+Requires-Dist: kombu
 Dynamic: author
 Dynamic: description
 Dynamic: description-content-type
@@ -29,6 +30,12 @@ Dynamic: summary
 this is a shared kernel package
 
 # Change Log
+### Version 2.5.2
+- Minor Fix
+### Version 2.5.1
+- Apply log on jwt service
+### Version 2.5.0
+- Implement logger
 ### Version 2.4.1
 - Fix file validation
 ### Version 2.4.0

{sharedkernel-2.4.1 → sharedkernel-2.5.2}/sharedkernel.egg-info/SOURCES.txt

@@ -26,6 +26,12 @@ sharedkernel/enum/sort_order.py
 sharedkernel/exception/__init__.py
 sharedkernel/exception/exception.py
 sharedkernel/exception/exception_handlers.py
+sharedkernel/logger/log_decorator.py
+sharedkernel/logger/log_dto.py
+sharedkernel/logger/log_enums.py
+sharedkernel/logger/log_info.py
+sharedkernel/logger/log_middlewares.py
+sharedkernel/logger/logger_service.py
 sharedkernel/normalizer/__init__.py
 sharedkernel/normalizer/number_normalizer.py
 sharedkernel/normalizer/phone_number_normalizer.py

{sharedkernel-2.4.1 → sharedkernel-2.5.2}/sharedkernel.egg-info/requires.txt

@@ -13,3 +13,4 @@ mammoth
 markdown
 beautifulsoup4
 deepdiff
+kombu