maleo-foundation 0.0.85__py3-none-any.whl → 0.0.87__py3-none-any.whl

maleo_foundation/managers/client/google/secret.py

@@ -0,0 +1,65 @@
+from google.api_core import retry
+from google.api_core.exceptions import NotFound
+from google.cloud import secretmanager
+from typing import Optional
+from .base import GoogleClientManager
+
+class GoogleSecretManager(GoogleClientManager):
+    def __init__(self, logs_dir, google_cloud_logging=None, credentials_path=None) -> None:
+        self._key = "google-secret-manager"
+        self._name = "GoogleSecretManager"
+        super().__init__(
+            key=self._key,
+            name=self._name,
+            logs_dir=logs_dir,
+            google_cloud_logging=google_cloud_logging,
+            credentials_path=credentials_path
+        )
+        self._client = secretmanager.SecretManagerServiceClient(credentials=self._credentials)
+
+    @property
+    def client(self) -> secretmanager.SecretManagerServiceClient:
+        return self._client
+
+    def dispose(self) -> None:
+        if self._client is not None:
+            self._client = None
+
+    @retry.Retry(predicate=retry.if_exception_type(Exception), timeout=5)
+    def get(self, name:str, version:str = "latest") -> Optional[str]:
+        try:
+            secret_path = f"projects/{self._project_id}/secrets/{name}/versions/{version}"
+            request = secretmanager.AccessSecretVersionRequest(name=secret_path)
+            response = self._client.access_secret_version(request=request)
+            self._logger.info("Successfully retrieved secret '%s' with version '%s'", name, version)
+            return response.payload.data.decode()
+        except Exception:
+            self._logger.error("Exception occured with retrieving secret '%s' with version '%s'", name, version, exc_info=True)
+            return None
+
+    @retry.Retry(predicate=retry.if_exception_type(Exception), timeout=5)
+    def create(self, name:str, data:str) -> Optional[str]:
+        parent = f"projects/{self._project_id}"
+        secret_path = f"{parent}/secrets/{name}"
+        try:
+            #* Check if the secret already exists
+            request = secretmanager.GetSecretRequest(name=secret_path)
+            self._client.get_secret(request=request)
+
+        except NotFound:
+            #* Secret does not exist, create it first
+            try:
+                secret = secretmanager.Secret(name=name, replication={"automatic": {}})
+                request = secretmanager.CreateSecretRequest(parent=parent, secret_id=name, secret=secret)
+                self._client.create_secret(request=request)
+            except Exception as e:
+                return None
+
+        #* Add a new secret version
+        try:
+            payload = secretmanager.SecretPayload(data=data.encode())
+            request = secretmanager.AddSecretVersionRequest(parent=secret_path, payload=payload)
+            response = self._client.add_secret_version(request=request)
+            return data
+        except Exception as e:
+            return None

maleo_foundation/managers/client/google/storage.py

@@ -0,0 +1,60 @@
+import os
+from datetime import timedelta
+from google.cloud.storage import Bucket, Client
+from maleo_foundation.types import BaseTypes
+from .base import GoogleClientManager
+
+class GoogleCloudStorage(GoogleClientManager):
+    def __init__(self, logs_dir, google_cloud_logging=None, credentials_path=None, bucket_name:BaseTypes.OptionalString=None) -> None:
+        self._key = "google-secret-manager"
+        self._name = "GoogleSecretManager"
+        super().__init__(
+            key=self._key,
+            name=self._name,
+            logs_dir=logs_dir,
+            google_cloud_logging=google_cloud_logging,
+            credentials_path=credentials_path
+        )
+        self._client = Client(credentials=self._credentials)
+        self._bucket_name = bucket_name or os.getenv("GCS_BUCKET_NAME")
+        if self._bucket_name is None:
+            self._client.close()
+            raise ValueError("GCS_BUCKET_NAME environment variable must be set if 'bucket_name' is set to None")
+        self._bucket = self._client.lookup_bucket(bucket_name=self._bucket_name)
+        if self._bucket is None:
+            self._client.close()
+            raise ValueError(f"Bucket '{self._bucket_name}' does not exist.")
+
+    @property
+    def bucket_name(self) -> str:
+        return self._bucket_name
+
+    @property
+    def bucket(self) -> Bucket:
+        return self._bucket
+
+    def dispose(self) -> None:
+        if self._client is not None:
+            self._client.close()
+            self._client = None
+
+    def generate_signed_url(self, location:str) -> str:
+        """
+        generate signed URL of a file in the bucket based on its location.
+
+        Args:
+            location: str
+                Location of the file inside the bucket
+
+        Returns:
+            str: File's pre-signed download url
+
+        Raises:
+            ValueError: If the file does not exist
+        """
+        blob = self._bucket.blob(blob_name=location)
+        if not blob.exists():
+            raise ValueError(f"File '{location}' did not exists.")
+
+        url = blob.generate_signed_url(version="v4", expiration=timedelta(minutes=15), method="GET")
+        return url

maleo_foundation/managers/client/http.py

@@ -0,0 +1,40 @@
+import httpx
+from contextlib import asynccontextmanager
+from typing import AsyncGenerator, Optional
+
+class HTTPClientManager:
+    _client:Optional[httpx.AsyncClient] = None
+
+    @classmethod
+    def initialize(cls) -> None:
+        """Initialize the HTTP client if not already initialized."""
+        if cls._client is None:
+            cls._client = httpx.AsyncClient()
+
+    @classmethod
+    async def _client_handler(cls) -> AsyncGenerator[httpx.AsyncClient, None]:
+        """Reusable generator for client handling."""
+        if cls._client is None:
+            raise RuntimeError("Client has not been initialized. Call initialize first.")
+        yield cls._client
+
+    @classmethod
+    async def inject_client(cls) -> AsyncGenerator[httpx.AsyncClient, None]:
+        return cls._client_handler()
+
+    @classmethod
+    @asynccontextmanager
+    async def get_client(cls) -> AsyncGenerator[httpx.AsyncClient, None]:
+        """
+        Async context manager for manual HTTP client handling.
+        Supports `async with HTTPClientManager.get() as client:`
+        """
+        async for client in cls._client_handler():
+            yield client
+
+    @classmethod
+    async def dispose(cls) -> None:
+        """Dispose of the HTTP client and release any resources."""
+        if cls._client is not None:
+            await cls._client.aclose()
+            cls._client = None

maleo_foundation/managers/db.py

@@ -0,0 +1,123 @@
+import os
+from contextlib import contextmanager
+from sqlalchemy import MetaData
+from sqlalchemy.engine import Engine, create_engine
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.ext.declarative import DeclarativeMeta
+from sqlalchemy.orm import sessionmaker, Session, declarative_base
+from typing import Generator, Optional, Type
+from maleo_foundation.types import BaseTypes
+from maleo_foundation.utils.logger import BaseLogger
+from maleo_foundation.db.table import BaseTable
+
+class MetadataManager:
+    _Base:DeclarativeMeta = declarative_base()
+
+    @property
+    def Base(self) -> DeclarativeMeta:
+        return self._Base
+
+    @property
+    def metadata(self) -> MetaData:
+        return self._Base.metadata
+
+class SessionManager:
+    def __init__(self, logger:BaseLogger, engine:Engine):
+        self._logger = logger
+        self._logger.info("Initializing SessionMaker.")
+        self._sessionmaker:sessionmaker[Session] = sessionmaker(bind=engine, expire_on_commit=False)
+        self._logger.info("SessionMaker initialized successfully.")
+
+    def _session_handler(self) -> Generator[Session, None, None]:
+        """Reusable function for managing database sessions."""
+        session = self._sessionmaker()
+        self._logger.debug("New database session created.")
+        try:
+            yield session  #* Provide session
+            session.commit()  #* Auto-commit on success
+        except SQLAlchemyError as e:
+            session.rollback()  #* Rollback on error
+            self._logger.error(f"[SQLAlchemyError] Database transaction failed: {e}", exc_info=True)
+            raise
+        except Exception as e:
+            session.rollback()  #* Rollback on error
+            self._logger.error(f"[Exception] Database transaction failed: {e}", exc_info=True)
+            raise
+        finally:
+            session.close()  #* Ensure session closes
+            self._logger.debug("Database session closed.")
+
+    def inject(self) -> Generator[Session, None, None]:
+        """Returns a generator that yields a SQLAlchemy session for dependency injection."""
+        return self._session_handler()
+
+    @contextmanager
+    def get(self) -> Generator[Session, None, None]:
+        """Context manager for manual session handling. Supports `with SessionManager.get() as session:`"""
+        yield from self._session_handler()
+
+    def dispose(self) -> None:
+        """Dispose of the sessionmaker and release any resources."""
+        if self._sessionmaker is not None:
+            self._sessionmaker.close_all()
+            self._sessionmaker = None
+
+        self._logger.info("SessionManager disposed successfully.")
+        self._logger = None
+
+class DatabaseManager:
+    def __init__(
+        self,
+        metadata:MetaData,
+        logger:BaseLogger,
+        url:BaseTypes.OptionalString = None
+    ):
+        self._metadata = metadata #* Define database metadata
+        self._logger = logger #* Define database logger
+
+        #* Create engine
+        url = url or os.getenv("DB_URL")
+        if url is None:
+            raise ValueError("DB_URL environment variable must be set if url is not provided")
+        self._logger.info("Creating SQlAlchemy engine")
+        self._engine = create_engine(url=url, echo=False, pool_pre_ping=True, pool_recycle=3600)
+        self._logger.info("SQlAlchemy engine created")
+
+        #* Creating all table from metadata
+        self._logger.info("Creating all tables defined in metadata")
+        self._metadata.create_all(bind=self._engine) #* Create all tables
+        self._logger.info("Created all tables defined in metadata")
+
+        #* Initializing session manager
+        self._logger.info("Initializing session manager")
+        self._session = SessionManager(logger=self._logger, engine=self._engine) #* Define session
+        self._logger.info("Session manager initialized")
+
+    @property
+    def metadata(self) -> MetaData:
+        return self._metadata
+
+    @property
+    def engine(self) -> Engine:
+        return self._engine
+
+    @property
+    def session(self) -> SessionManager:
+        return self._session
+
+    def dispose(self) -> None:
+        #* Dispose session
+        if self._session is not None:
+            self._session.dispose()
+            self._session = None
+        #* Dispose engine
+        if self._engine is not None:
+            self._engine.dispose()
+            self._engine = None
+        #* Dispose logger
+        if self._logger is not None:
+            self._logger.dispose()
+            self._logger = None
+        #* Dispose metadata
+        if self._metadata is not None:
+            self._metadata = None

maleo_foundation/managers/service.py

@@ -0,0 +1,251 @@
+import json
+import os
+from pydantic_settings import BaseSettings
+from pydantic import BaseModel, Field
+from sqlalchemy import MetaData
+from typing import Dict, List, Optional, Type
+from maleo_foundation.db.manager import DatabaseManagerV2
+from maleo_foundation.enums import BaseEnums
+from maleo_foundation.models.transfers.general.token import BaseTokenGeneralTransfers
+from maleo_foundation.models.transfers.parameters.token import BaseTokenParametersTransfers
+from maleo_foundation.managers.client.google.secret import GoogleSecretManager
+from maleo_foundation.managers.client.google.storage import GoogleCloudStorage
+from maleo_foundation.managers.client.http import HTTPClientManager
+from maleo_foundation.managers.db import DatabaseManager
+from maleo_foundation.services.token import BaseTokenService
+from maleo_foundation.types import BaseTypes
+from maleo_foundation.utils.keyloader import load_key
+from maleo_foundation.utils.logging import GoogleCloudLogging, ServiceLogger
+
+class Settings(BaseSettings):
+    GOOGLE_CREDENTIALS_PATH:str = Field("/creds/maleo-google-service-account.json", description="Internal credential's file path")
+    INTERNAL_CREDENTIALS_PATH:str = Field("/creds/maleo-internal-service-account.json", description="Internal credential's file path")
+    PRIVATE_KEY_PATH:str = Field("/keys/maleo-private-key.pem", description="Maleo's private key path")
+    PUBLIC_KEY_PATH:str = Field("/keys/maleo-public-key.pem", description="Maleo's public key path")
+    KEY_PASSWORD:str = Field(..., description="Maleo key's password")
+    CONFIGURATIONS_PATH:str = Field("...", description="Service's configuration file path")
+
+class Keys(BaseModel):
+    password:str = Field(..., description="Key's password")
+    private:str = Field(..., description="Private key")
+    public:str = Field(..., description="Public key")
+
+class GoogleCredentials(BaseModel):
+    type:str = Field(..., description="Credentials type")
+    project_id:str = Field(..., description="Google project ID")
+    private_key_id:str = Field(..., description="Private key ID")
+    private_key:str = Field(..., description="Private key")
+    client_email:str = Field(..., description="Client email")
+    client_id:str = Field(..., description="Client ID")
+    auth_uri:str = Field(..., description="Authorization URI")
+    token_uri:str = Field(..., description="Token URI")
+    auth_provider_x509_cert_url:str = Field(..., description="Authorization provider x509 certificate URL")
+    client_x509_cert_url:str = Field(..., description="Client x509 certificate URL")
+    universe_domain:str = Field(..., description="Universe domains")
+
+class InternalCredentials(BaseModel):
+    system_role:str = Field(..., description="System role")
+    username:str = Field(..., description="Username")
+    email:str = Field(..., description="Email")
+    user_type:str = Field(..., description="User type")
+
+class Credentials(BaseModel):
+    google:GoogleCredentials = Field(..., description="Google's credentials")
+    internal:InternalCredentials = Field(..., description="Internal's credentials")
+
+class ServiceConfigurations(BaseModel):
+    key:str = Field(..., description="Service's key")
+    name:str = Field(..., description="Service's name")
+
+class MiddlewareConfigurations(BaseModel):
+    allowed_origins:List[str] = Field(default_factory=list, description="Allowed origins")
+    service_ips:List[str] = Field(default_factory=list, description="Other service's IPs")
+
+class DatabaseConfigurations(BaseModel):
+    username:str = Field("postgres", description="Database user's username")
+    password:str = Field(..., description="Database user's password")
+    host:str = Field(..., description="Database's host")
+    port:str = Field("5432", description="Database's port")
+    database:str = Field(..., description="Database")
+
+    @property
+    def url(self) -> str:
+        return f"postgresql://{self.username}:{self.password}@{self.host}:{self.port}/{self.database}"
+
+class Configurations(BaseModel):
+    service:ServiceConfigurations = Field(..., description="Service's configurations")
+    middleware:MiddlewareConfigurations = Field(..., description="Middleware's configurations")
+    database:DatabaseConfigurations = Field(..., description="Database's configurations")
+
+class Loggers(BaseModel):
+    application:ServiceLogger = Field(..., description="Application logger")
+    database:ServiceLogger = Field(..., description="Database logger")
+    middleware:ServiceLogger = Field(..., description="Middleware logger")
+
+class GoogleClientManagers(BaseModel):
+    secret:GoogleSecretManager = Field(..., description="Google secret manager client manager")
+    storage:GoogleCloudStorage = Field(..., description="Google cloud storage client manager")
+
+class ClientManagers(BaseModel):
+    google:GoogleClientManagers = Field(..., description="Google client's managers")
+    http:HTTPClientManager = Field(..., description="HTTP client's manager")
+
+class ServiceManager:
+    def __init__(
+        self,
+        db_metadata:MetaData,
+        base_dir:BaseTypes.OptionalString = None,
+        settings:Optional[Settings] = None,
+        google_cloud_logging:Optional[GoogleCloudLogging] = None
+    ):
+        self._db_metadata = db_metadata
+
+        if base_dir is None:
+            self._base_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..")
+        else:
+            self._base_dir = base_dir
+
+        self._logs_dir = os.path.join(self._base_dir, "logs")
+
+        #* Initialize settings
+        if settings is None:
+            self._settings = Settings()
+        else:
+            self._settings = settings
+
+        #* Load configs
+        self._load_configs()
+
+        #* Initialize google cloud logging
+        if google_cloud_logging is None:
+            self._google_cloud_logging = GoogleCloudLogging()
+        else:
+            self._google_cloud_logging = google_cloud_logging
+
+        self._initialize_loggers()
+        self._load_credentials()
+        self._parse_keys()
+        self._initialize_db()
+        self._initialize_clients()
+
+    @property
+    def base_dir(self) -> str:
+        return self._base_dir
+
+    @property
+    def logs_dir(self) -> str:
+        return self._logs_dir
+
+    @property
+    def settings(self) -> Settings:
+        return self._settings
+
+    def _load_configs(self) -> None:
+        with open(self._settings.CONFIGURATIONS_PATH) as f:
+            data = json.load(f)
+            self._configs = Configurations.model_validate(data)
+
+    @property
+    def configs(self) -> str:
+        return self._configs
+
+    def _initialize_loggers(self) -> None:
+        application = ServiceLogger(logs_dir=self._logs_dir, type=BaseEnums.LoggerType.APPLICATION, google_cloud_logging=self._google_cloud_logging)
+        database = ServiceLogger(logs_dir=self._logs_dir, type=BaseEnums.LoggerType.DATABASE, google_cloud_logging=self._google_cloud_logging)
+        middleware = ServiceLogger(logs_dir=self._logs_dir, type=BaseEnums.LoggerType.MIDDLEWARE, google_cloud_logging=self._google_cloud_logging)
+        self._loggers = Loggers(application=application, database=database, middleware=middleware)
+
+    @property
+    def loggers(self) -> Loggers:
+        return self._loggers
+
+    def _load_credentials(self) -> None:
+        #* Load google credentials
+        with open(self._settings.GOOGLE_CREDENTIALS_PATH) as f:
+            data = json.load(f)
+            google = GoogleCredentials.model_validate(data)
+        #* Load internal credentials
+        with open(self._settings.INTERNAL_CREDENTIALS_PATH) as f:
+            data = json.load(f)
+            internal = InternalCredentials.model_validate(data)
+        self._credentials = Credentials(google=google, internal=internal)
+
+    @property
+    def credentials(self) -> Credentials:
+        return self._credentials
+
+    def _parse_keys(self) -> None:
+        #* Parse private key
+        key_type = BaseEnums.KeyType.PRIVATE
+        private = load_key(
+            type=key_type,
+            path=self._settings.PRIVATE_KEY_PATH,
+            password=self._settings.KEY_PASSWORD
+        )
+        #* Parse public key
+        key_type = BaseEnums.KeyType.PUBLIC
+        public = load_key(
+            type=key_type,
+            path=self._settings.PUBLIC_KEY_PATH
+        )
+        self._keys = Keys(password=self._settings.KEY_PASSWORD, private=private, public=public)
+
+    @property
+    def keys(self) -> Keys:
+        return self._keys
+
+    def _initialize_db(self) -> None:
+        self._database = DatabaseManager(metadata=self._db_metadata, logger=self._loggers.database, url=self._configs.database.url)
+
+    @property
+    def database(self) -> DatabaseManager:
+        return self._database
+
+    def _initialize_clients(self) -> None:
+        #* Initialize google clients
+        secret = GoogleSecretManager(logs_dir=self._logs_dir, google_cloud_logging=self._google_cloud_logging)
+        storage = GoogleCloudStorage(logs_dir=self._logs_dir, google_cloud_logging=self._google_cloud_logging)
+        self._google_clients = GoogleClientManagers(secret=secret, storage=storage)
+        #* Initialize http clients
+        http = HTTPClientManager.initialize()
+        self._clients = ClientManagers(google=self._google_clients, http=http)
+
+    @property
+    def google_clients(self) -> GoogleClientManagers:
+        return self._google_clients
+
+    @property
+    def client_managers(self) -> ClientManagers:
+        return self._clients
+
+    @property
+    def token(self) -> str:
+        payload = BaseTokenGeneralTransfers.BaseEncodePayload(
+            sr=self._credentials.internal.system_role,
+            u_u=self._credentials.internal.username,
+            u_e=self._credentials.internal.email,
+            u_ut=self._credentials.internal.user_type
+        )
+        parameters = BaseTokenParametersTransfers.Encode(
+            key=self.keys.private,
+            password=self.keys.password,
+            payload=payload
+        )
+        result = BaseTokenService.encode(parameters=parameters)
+        if not result.success:
+            raise ValueError("Failed generating token")
+        return result.data.token
+
+    async def dispose(self) -> None:
+        if self._database is not None:
+            self._database.dispose()
+            self._database = None
+        if self._clients is not None:
+            self._clients.google.storage.dispose()
+            self._clients.google.secret.dispose()
+            await self._clients.http.dispose()
+        if self._loggers is not None:
+            self._loggers.application.dispose()
+            self._loggers.database.dispose()
+            self._loggers.middleware.dispose()
+            self._loggers = None

maleo_foundation/models/transfers/general/token.py

@@ -20,7 +20,7 @@ class BaseTokenGeneralTransfers:
         exp_dt:datetime = Field(..., description="Expired at (datetime)")
         exp:int = Field(..., description="Expired at (integet)")
 
-    class BaseEncodePayload(BasePayload, BaseTokenSchemas.ExpIn): pass
+    class BaseEncodePayload(BaseTokenSchemas.ExpIn, BasePayload): pass
 
     class EncodePayload(DecodePayload):
         iat_dt:datetime = Field(datetime.now(timezone.utc), description="Issued at (datetime)")

maleo_foundation/utils/keyloader.py

@@ -30,7 +30,7 @@ def load_key(
     if password is not None and not isinstance(password, (str, bytes)):
         raise TypeError("Invalid passsword type")
 
-    if not isinstance(type, BaseEnums.KeyFormatType):
+    if not isinstance(format, BaseEnums.KeyFormatType):
         raise TypeError("Invalid key format type")
 
     key_data = file_path.read_bytes()

maleo_foundation/utils/logger.py

@@ -1,8 +1,8 @@
 import logging
 import os
 from datetime import datetime
-from typing import Callable
-from maleo_foundation.clients.google.cloud.logging import GoogleCloudLogging
+from typing import Callable, Optional
+from maleo_foundation.clients.google.cloud.logging import GoogleCloudLoggingV2
 from maleo_foundation.enums import BaseEnums
 from maleo_foundation.types import BaseTypes
 
@@ -13,7 +13,8 @@ class BaseLogger(logging.Logger):
         type:BaseEnums.LoggerType,
         service_name:BaseTypes.OptionalString = None,
         client_name:BaseTypes.OptionalString = None,
-        level:BaseEnums.LoggerLevel = BaseEnums.LoggerLevel.INFO
+        level:BaseEnums.LoggerLevel = BaseEnums.LoggerLevel.INFO,
+        cloud_logging_manager:Optional[GoogleCloudLoggingV2] = None
     ):
         """
         Custom extended logger with file, console, and Google Cloud Logging.
@@ -23,24 +24,26 @@ class BaseLogger(logging.Logger):
 
         Args:
             base_dir (str): Base directory for logs (e.g., "/path/to/maleo_security")
-            service_name (str): The service name (e.g., "maleo_security")
             type (str): Log type (e.g., "application", "middleware")
+            service_name (str): The service name (e.g., "maleo_security")
         """
         #* Ensure service_name exists
         service_name = service_name or os.getenv("SERVICE_NAME")
         if service_name is None:
-            raise ValueError("SERVICE_NAME environment variable must be set if service_name is set to None")
+            raise ValueError("SERVICE_NAME environment variable must be set if 'service_name' is set to None")
 
         #* Ensure client_name is valid if logger type is a client
         if type == BaseEnums.LoggerType.CLIENT and client_name is None:
             raise ValueError("'client_name' parameter must be provided if 'logger_type' is 'client'")
 
+        self.type = type #* Define logger type
+
         #* Define logger name
-        if type == BaseEnums.LoggerType.CLIENT:
-            name = f"{service_name} - {type} - {client_name}"
+        if self.type == BaseEnums.LoggerType.CLIENT:
+            self.name = f"{service_name} - {self.type} - {client_name}"
         else:
-            name = f"{service_name} - {type}"
-        super().__init__(name, level)
+            self.name = f"{service_name} - {self.type}"
+        super().__init__(self.name, level)
 
         #* Clear existing handlers to prevent duplicates
         for handler in list(self.handlers):
@@ -56,11 +59,11 @@ class BaseLogger(logging.Logger):
         self.addHandler(console_handler)
 
         #* Google Cloud Logging handler (If enabled)
-        try:
-            cloud_handler = GoogleCloudLogging.create_handler(name=name.replace(" ", ""))
-            self.addHandler(cloud_handler)
-        except Exception as e:
-            self.warning(f"Failed to initialize Google Cloud Logging: {str(e)}")
+        if cloud_logging_manager is not None:
+            cloud_logging_handler = cloud_logging_manager.create_handler(name=self.name)
+            self.addHandler(cloud_logging_handler)
+        else:
+            self.info("Cloud logging is not configured.")
 
         #* Define log directory
         if type == BaseEnums.LoggerType.CLIENT: