maleo-logging 0.0.5__py3-none-any.whl → 0.0.7__py3-none-any.whl

maleo/logging/config.py

@@ -0,0 +1,31 @@
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+from typing import Optional, Self
+from maleo.types.base.dict import OptionalStringToStringDict
+from maleo.types.base.string import OptionalString
+from .enums import Level
+from .google import GoogleCloudLogging
+
+
+class Config(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    dir: str = Field(..., description="Log's directory")
+    level: Level = Field(Level.INFO, description="Log's level")
+    google_cloud_logging: Optional[GoogleCloudLogging] = Field(
+        default_factory=GoogleCloudLogging, description="Google cloud logging"
+    )
+    labels: OptionalStringToStringDict = Field(
+        None, description="Log labels. (Optional)"
+    )
+    aggregate_file_name: OptionalString = Field(
+        None, description="Log aggregate file name"
+    )
+    individual_log: bool = Field(True, description="Whether to have individual log")
+
+    @model_validator(mode="after")
+    def validate_aggregate_file_name(self) -> Self:
+        if isinstance(self.aggregate_file_name, str):
+            if not self.aggregate_file_name.endswith(".log"):
+                self.aggregate_file_name += ".log"
+
+        return self

maleo/logging/logger.py

@@ -1,31 +1,27 @@
 import logging
 import os
 from datetime import datetime, timezone
+from pydantic import BaseModel, ConfigDict, Field
 from typing import Literal, Optional, Union, overload
 from maleo.enums.environment import Environment
 from maleo.enums.service import Key
-from maleo.types.base.dict import OptionalStringToStringDict
+from maleo.types.base.dict import StringToStringDict
 from maleo.types.base.string import OptionalString
-from .dtos import Labels
-from maleo.utils.merger import merge_dicts
-from .enums import Level, LoggerType
-from .google import GoogleCloudLogging
+from .config import Config
+from .enums import LoggerType
 
 
+# * We suggest to NOT use this class
+# * Instead use the inherited classes
 class Base(logging.Logger):
     def __init__(
         self,
-        type: LoggerType,
-        dir: str,
+        type: LoggerType = LoggerType.BASE,
         *,
         environment: Optional[Environment] = None,
         service_key: Optional[Key] = None,
         client_key: OptionalString = None,
-        level: Level = Level.INFO,
-        google_cloud_logging: Optional[GoogleCloudLogging] = None,
-        labels: OptionalStringToStringDict = None,
-        aggregate_file_name: OptionalString = None,
-        inidividual_log: bool = True,
+        config: Config,
     ):
         self._type = type  # Declare logger type
 
@@ -63,14 +59,19 @@ class Base(logging.Logger):
             self._name = base_name
 
         # Define log labels
-        self._labels = Labels(
-            logger_type=self._type,
-            service_environment=self._environment,
-            service_key=self._service_key,
-            client_key=client_key,
-        )
+        self._labels: StringToStringDict = {
+            "logger_type": self._type.value,
+            "service_environment": self._environment.value,
+            "service_key": self._service_key.value,
+        }
+        if client_key is not None:
+            self._labels["client_key"] = client_key
+        if config.labels is not None:
+            self._labels.update(config.labels)
+
+        self._config = config
 
-        super().__init__(self._name, level)  # Init the superclass's logger
+        super().__init__(self._name, self._config.level)  # Init the superclass's logger
 
         # Clear existing handlers to prevent duplicates
         for handler in list(self.handlers):
@@ -85,13 +86,10 @@ class Base(logging.Logger):
         self.addHandler(console_handler)
 
         # Google Cloud Logging handler (If enabled)
-        if google_cloud_logging is not None:
-            final_labels = self._labels.model_dump(mode="json", exclude_none=True)
-            if labels is not None:
-                final_labels = merge_dicts(final_labels, labels)
-            cloud_logging_handler = google_cloud_logging.create_handler(
+        if self._config.google_cloud_logging is not None:
+            cloud_logging_handler = self._config.google_cloud_logging.create_handler(
                 name=self._name.replace(" ", ""),
-                labels=final_labels,
+                labels=self._labels,
             )
             self.addHandler(cloud_logging_handler)
         else:
@@ -100,10 +98,14 @@ class Base(logging.Logger):
             )
 
         # Define aggregate log directory
-        if aggregate_file_name is not None:
-            if not aggregate_file_name.endswith(".log"):
-                aggregate_file_name += ".log"
-            log_filename = os.path.join(self._log_dir, "aggregate", aggregate_file_name)
+        if self._config.aggregate_file_name is not None:
+            aggregate_log_dir = os.path.join(self._log_dir, "aggregate")
+            os.makedirs(aggregate_log_dir, exist_ok=True)
+            if not self._config.aggregate_file_name.endswith(".log"):
+                self._config.aggregate_file_name += ".log"
+            log_filename = os.path.join(
+                aggregate_log_dir, self._config.aggregate_file_name
+            )
 
             # File handler
             file_handler = logging.FileHandler(log_filename, mode="a")
@@ -114,13 +116,13 @@ class Base(logging.Logger):
             )
             self.addHandler(file_handler)
 
-        if inidividual_log:
-            # Define log directory
+        # Define individual log directory
+        if self._config.individual_log:
             if self._type == LoggerType.CLIENT:
                 log_dir = f"{self._type}/{self._client_key}"
             else:
                 log_dir = f"{self._type}"
-            self._log_dir = os.path.join(dir, log_dir)
+            self._log_dir = os.path.join(self._config.dir, log_dir)
             os.makedirs(self._log_dir, exist_ok=True)
 
             # Generate timestamped filename
@@ -138,34 +140,6 @@ class Base(logging.Logger):
             )
             self.addHandler(file_handler)
 
-    @property
-    def type(self) -> str:
-        return self._type
-
-    @property
-    def location(self) -> str:
-        return self._log_dir
-
-    @property
-    def environment(self) -> Environment:
-        return self._environment
-
-    @property
-    def service(self) -> str:
-        return self._service_key
-
-    @property
-    def client(self) -> OptionalString:
-        return self._client_key
-
-    @property
-    def identity(self) -> str:
-        return self._name
-
-    @property
-    def labels(self) -> Labels:
-        return self._labels
-
     def dispose(self):
         """Dispose of the logger by removing all handlers."""
         for handler in list(self.handlers):
@@ -177,355 +151,237 @@ class Base(logging.Logger):
 class Application(Base):
     def __init__(
         self,
-        dir: str,
+        *,
         environment: Optional[Environment] = None,
         service_key: Optional[Key] = None,
-        level: Level = Level.INFO,
-        google_cloud_logging: Optional[GoogleCloudLogging] = None,
-        labels: OptionalStringToStringDict = None,
-        aggregate_file_name: OptionalString = None,
-        inidividual_log: bool = True,
+        config: Config,
     ):
         super().__init__(
-            dir=dir,
-            type=LoggerType.APPLICATION,
+            LoggerType.APPLICATION,
             environment=environment,
             service_key=service_key,
             client_key=None,
-            level=level,
-            google_cloud_logging=google_cloud_logging,
-            labels=labels,
-            aggregate_file_name=aggregate_file_name,
-            inidividual_log=inidividual_log,
+            config=config,
         )
 
 
 class Cache(Base):
     def __init__(
         self,
-        dir: str,
+        *,
         environment: Optional[Environment] = None,
         service_key: Optional[Key] = None,
-        level: Level = Level.INFO,
-        google_cloud_logging: Optional[GoogleCloudLogging] = None,
-        labels: OptionalStringToStringDict = None,
-        aggregate_file_name: OptionalString = None,
-        inidividual_log: bool = True,
+        config: Config,
     ):
         super().__init__(
-            dir=dir,
-            type=LoggerType.CACHE,
+            LoggerType.CACHE,
             environment=environment,
             service_key=service_key,
             client_key=None,
-            level=level,
-            google_cloud_logging=google_cloud_logging,
-            labels=labels,
-            aggregate_file_name=aggregate_file_name,
-            inidividual_log=inidividual_log,
+            config=config,
         )
 
 
 class Client(Base):
     def __init__(
         self,
-        dir: str,
-        client_key: str,
+        *,
         environment: Optional[Environment] = None,
         service_key: Optional[Key] = None,
-        level: Level = Level.INFO,
-        google_cloud_logging: Optional[GoogleCloudLogging] = None,
-        labels: OptionalStringToStringDict = None,
-        aggregate_file_name: OptionalString = None,
-        inidividual_log: bool = True,
+        client_key: str,
+        config: Config,
     ):
         super().__init__(
-            dir=dir,
-            type=LoggerType.CLIENT,
+            LoggerType.CACHE,
             environment=environment,
             service_key=service_key,
             client_key=client_key,
-            level=level,
-            google_cloud_logging=google_cloud_logging,
-            labels=labels,
-            aggregate_file_name=aggregate_file_name,
-            inidividual_log=inidividual_log,
+            config=config,
         )
 
 
 class Controller(Base):
     def __init__(
         self,
-        dir: str,
+        *,
         environment: Optional[Environment] = None,
         service_key: Optional[Key] = None,
-        level: Level = Level.INFO,
-        google_cloud_logging: Optional[GoogleCloudLogging] = None,
-        labels: OptionalStringToStringDict = None,
-        aggregate_file_name: OptionalString = None,
-        inidividual_log: bool = True,
+        config: Config,
     ):
         super().__init__(
-            dir=dir,
-            type=LoggerType.CONTROLLER,
+            LoggerType.CONTROLLER,
             environment=environment,
             service_key=service_key,
             client_key=None,
-            level=level,
-            google_cloud_logging=google_cloud_logging,
-            labels=labels,
-            aggregate_file_name=aggregate_file_name,
-            inidividual_log=inidividual_log,
+            config=config,
         )
 
 
 class Database(Base):
     def __init__(
         self,
-        dir: str,
+        *,
         environment: Optional[Environment] = None,
         service_key: Optional[Key] = None,
-        level=Level.INFO,
-        google_cloud_logging=None,
-        labels: OptionalStringToStringDict = None,
-        aggregate_file_name: OptionalString = None,
-        inidividual_log: bool = True,
+        config: Config,
     ):
         super().__init__(
-            dir=dir,
-            type=LoggerType.DATABASE,
+            LoggerType.DATABASE,
             environment=environment,
             service_key=service_key,
             client_key=None,
-            level=level,
-            google_cloud_logging=google_cloud_logging,
-            labels=labels,
-            aggregate_file_name=aggregate_file_name,
-            inidividual_log=inidividual_log,
+            config=config,
         )
 
 
 class Exception(Base):
     def __init__(
         self,
-        dir: str,
+        *,
         environment: Optional[Environment] = None,
         service_key: Optional[Key] = None,
-        level=Level.INFO,
-        google_cloud_logging=None,
-        labels: OptionalStringToStringDict = None,
-        aggregate_file_name: OptionalString = None,
-        inidividual_log: bool = True,
+        config: Config,
     ):
         super().__init__(
-            dir=dir,
-            type=LoggerType.EXCEPTION,
+            LoggerType.EXCEPTION,
             environment=environment,
             service_key=service_key,
             client_key=None,
-            level=level,
-            google_cloud_logging=google_cloud_logging,
-            labels=labels,
-            aggregate_file_name=aggregate_file_name,
-            inidividual_log=inidividual_log,
+            config=config,
         )
 
 
 class Middleware(Base):
     def __init__(
         self,
-        dir: str,
+        *,
         environment: Optional[Environment] = None,
         service_key: Optional[Key] = None,
-        level=Level.INFO,
-        google_cloud_logging=None,
-        labels: OptionalStringToStringDict = None,
-        aggregate_file_name: OptionalString = None,
-        inidividual_log: bool = True,
+        config: Config,
     ):
         super().__init__(
-            dir=dir,
-            type=LoggerType.MIDDLEWARE,
+            LoggerType.MIDDLEWARE,
             environment=environment,
             service_key=service_key,
             client_key=None,
-            level=level,
-            google_cloud_logging=google_cloud_logging,
-            labels=labels,
-            aggregate_file_name=aggregate_file_name,
-            inidividual_log=inidividual_log,
+            config=config,
         )
 
 
 class Repository(Base):
     def __init__(
         self,
-        dir: str,
+        *,
         environment: Optional[Environment] = None,
         service_key: Optional[Key] = None,
-        level: Level = Level.INFO,
-        google_cloud_logging: Optional[GoogleCloudLogging] = None,
-        labels: OptionalStringToStringDict = None,
-        aggregate_file_name: OptionalString = None,
-        inidividual_log: bool = True,
+        config: Config,
     ):
         super().__init__(
-            dir=dir,
-            type=LoggerType.REPOSITORY,
+            LoggerType.REPOSITORY,
             environment=environment,
             service_key=service_key,
             client_key=None,
-            level=level,
-            google_cloud_logging=google_cloud_logging,
-            labels=labels,
-            aggregate_file_name=aggregate_file_name,
-            inidividual_log=inidividual_log,
+            config=config,
         )
 
 
 class Service(Base):
     def __init__(
         self,
-        dir: str,
+        *,
         environment: Optional[Environment] = None,
         service_key: Optional[Key] = None,
-        level: Level = Level.INFO,
-        google_cloud_logging: Optional[GoogleCloudLogging] = None,
-        labels: OptionalStringToStringDict = None,
-        aggregate_file_name: OptionalString = None,
-        inidividual_log: bool = True,
+        config: Config,
     ):
         super().__init__(
-            dir=dir,
-            type=LoggerType.SERVICE,
+            LoggerType.SERVICE,
             environment=environment,
             service_key=service_key,
             client_key=None,
-            level=level,
-            google_cloud_logging=google_cloud_logging,
-            labels=labels,
-            aggregate_file_name=aggregate_file_name,
-            inidividual_log=inidividual_log,
+            config=config,
         )
 
 
 @overload
 def create(
-    dir: str,
     type: Literal[LoggerType.APPLICATION],
     *,
     environment: Optional[Environment] = None,
     service_key: Optional[Key] = None,
-    level: Level = Level.INFO,
-    google_cloud_logging: Optional[GoogleCloudLogging] = None,
-    labels: OptionalStringToStringDict = None,
-    aggregate_file_name: OptionalString = None,
-    inidividual_log: bool = True,
+    config: Config,
 ) -> Application: ...
 @overload
 def create(
-    dir: str,
     type: Literal[LoggerType.CACHE],
     *,
     environment: Optional[Environment] = None,
     service_key: Optional[Key] = None,
-    level: Level = Level.INFO,
-    google_cloud_logging: Optional[GoogleCloudLogging] = None,
-    labels: OptionalStringToStringDict = None,
-    aggregate_file_name: OptionalString = None,
-    inidividual_log: bool = True,
+    config: Config,
 ) -> Cache: ...
 @overload
 def create(
-    dir: str,
     type: Literal[LoggerType.CLIENT],
     *,
     environment: Optional[Environment] = None,
     service_key: Optional[Key] = None,
     client_key: str,
-    level: Level = Level.INFO,
-    google_cloud_logging: Optional[GoogleCloudLogging] = None,
-    labels: OptionalStringToStringDict = None,
-    aggregate_file_name: OptionalString = None,
-    inidividual_log: bool = True,
+    config: Config,
 ) -> Client: ...
 @overload
 def create(
-    dir: str,
     type: Literal[LoggerType.CONTROLLER],
     *,
     environment: Optional[Environment] = None,
     service_key: Optional[Key] = None,
-    level: Level = Level.INFO,
-    google_cloud_logging: Optional[GoogleCloudLogging] = None,
-    labels: OptionalStringToStringDict = None,
-    aggregate_file_name: OptionalString = None,
-    inidividual_log: bool = True,
+    config: Config,
 ) -> Controller: ...
 @overload
 def create(
-    dir: str,
     type: Literal[LoggerType.DATABASE],
     *,
     environment: Optional[Environment] = None,
     service_key: Optional[Key] = None,
-    level: Level = Level.INFO,
-    google_cloud_logging: Optional[GoogleCloudLogging] = None,
-    labels: OptionalStringToStringDict = None,
-    aggregate_file_name: OptionalString = None,
-    inidividual_log: bool = True,
+    config: Config,
 ) -> Database: ...
 @overload
 def create(
-    dir: str,
+    type: Literal[LoggerType.EXCEPTION],
+    *,
+    environment: Optional[Environment] = None,
+    service_key: Optional[Key] = None,
+    config: Config,
+) -> Exception: ...
+@overload
+def create(
     type: Literal[LoggerType.MIDDLEWARE],
     *,
     environment: Optional[Environment] = None,
     service_key: Optional[Key] = None,
-    level: Level = Level.INFO,
-    google_cloud_logging: Optional[GoogleCloudLogging] = None,
-    labels: OptionalStringToStringDict = None,
-    aggregate_file_name: OptionalString = None,
-    inidividual_log: bool = True,
+    config: Config,
 ) -> Middleware: ...
 @overload
 def create(
-    dir: str,
     type: Literal[LoggerType.REPOSITORY],
     *,
     environment: Optional[Environment] = None,
     service_key: Optional[Key] = None,
-    level: Level = Level.INFO,
-    google_cloud_logging: Optional[GoogleCloudLogging] = None,
-    labels: OptionalStringToStringDict = None,
-    aggregate_file_name: OptionalString = None,
-    inidividual_log: bool = True,
+    config: Config,
 ) -> Repository: ...
 @overload
 def create(
-    dir: str,
     type: Literal[LoggerType.SERVICE],
     *,
     environment: Optional[Environment] = None,
     service_key: Optional[Key] = None,
-    level: Level = Level.INFO,
-    google_cloud_logging: Optional[GoogleCloudLogging] = None,
-    labels: OptionalStringToStringDict = None,
-    aggregate_file_name: OptionalString = None,
-    inidividual_log: bool = True,
+    config: Config,
 ) -> Service: ...
 def create(
-    dir: str,
     type: LoggerType = LoggerType.BASE,
     *,
     environment: Optional[Environment] = None,
     service_key: Optional[Key] = None,
     client_key: OptionalString = None,
-    level: Level = Level.INFO,
-    google_cloud_logging: Optional[GoogleCloudLogging] = None,
-    labels: OptionalStringToStringDict = None,
-    aggregate_file_name: OptionalString = None,
-    inidividual_log: bool = True,
+    config: Config,
 ) -> Union[
     Base,
     Application,
@@ -538,43 +394,24 @@ def create(
     Repository,
     Service,
 ]:
-    if type not in LoggerType:
-        raise ValueError(f"Invalid logger type of '{type}'")
-
     if type is LoggerType.BASE:
         return Base(
-            type=type,
-            dir=dir,
             environment=environment,
             service_key=service_key,
             client_key=client_key,
-            level=level,
-            google_cloud_logging=google_cloud_logging,
-            labels=labels,
-            aggregate_file_name=aggregate_file_name,
-            inidividual_log=inidividual_log,
+            config=config,
         )
     elif type is LoggerType.APPLICATION:
         return Application(
-            dir=dir,
             environment=environment,
             service_key=service_key,
-            level=level,
-            google_cloud_logging=google_cloud_logging,
-            labels=labels,
-            aggregate_file_name=aggregate_file_name,
-            inidividual_log=inidividual_log,
+            config=config,
         )
     elif type is LoggerType.CACHE:
         return Cache(
-            dir=dir,
             environment=environment,
             service_key=service_key,
-            level=level,
-            google_cloud_logging=google_cloud_logging,
-            labels=labels,
-            aggregate_file_name=aggregate_file_name,
-            inidividual_log=inidividual_log,
+            config=config,
         )
     elif type is LoggerType.CLIENT:
         if client_key is None:
@@ -582,79 +419,116 @@ def create(
                 "Argument 'client_key' can not be None if 'logger_type' is 'client'"
             )
         return Client(
-            dir=dir,
-            client_key=client_key,
             environment=environment,
             service_key=service_key,
-            level=level,
-            google_cloud_logging=google_cloud_logging,
-            labels=labels,
-            aggregate_file_name=aggregate_file_name,
-            inidividual_log=inidividual_log,
+            client_key=client_key,
+            config=config,
         )
     elif type is LoggerType.CONTROLLER:
         return Controller(
-            dir=dir,
             environment=environment,
             service_key=service_key,
-            level=level,
-            google_cloud_logging=google_cloud_logging,
-            labels=labels,
-            aggregate_file_name=aggregate_file_name,
-            inidividual_log=inidividual_log,
+            config=config,
         )
     elif type is LoggerType.DATABASE:
         return Database(
-            dir=dir,
             environment=environment,
             service_key=service_key,
-            level=level,
-            google_cloud_logging=google_cloud_logging,
-            labels=labels,
-            aggregate_file_name=aggregate_file_name,
-            inidividual_log=inidividual_log,
+            config=config,
         )
     elif type is LoggerType.EXCEPTION:
         return Exception(
-            dir=dir,
             environment=environment,
             service_key=service_key,
-            level=level,
-            google_cloud_logging=google_cloud_logging,
-            labels=labels,
-            aggregate_file_name=aggregate_file_name,
-            inidividual_log=inidividual_log,
+            config=config,
         )
     elif type is LoggerType.MIDDLEWARE:
         return Middleware(
-            dir=dir,
             environment=environment,
             service_key=service_key,
-            level=level,
-            google_cloud_logging=google_cloud_logging,
-            labels=labels,
-            aggregate_file_name=aggregate_file_name,
-            inidividual_log=inidividual_log,
+            config=config,
         )
     elif type is LoggerType.REPOSITORY:
         return Repository(
-            dir=dir,
             environment=environment,
             service_key=service_key,
-            level=level,
-            google_cloud_logging=google_cloud_logging,
-            labels=labels,
-            aggregate_file_name=aggregate_file_name,
-            inidividual_log=inidividual_log,
+            config=config,
         )
     elif type is LoggerType.SERVICE:
         return Service(
-            dir=dir,
             environment=environment,
             service_key=service_key,
-            level=level,
-            google_cloud_logging=google_cloud_logging,
-            labels=labels,
-            aggregate_file_name=aggregate_file_name,
-            inidividual_log=inidividual_log,
+            config=config,
+        )
+
+
+class Loggers(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    application: Application = Field(..., description="Application logger")
+    cache: Cache = Field(..., description="Cache logger")
+    controller: Controller = Field(..., description="Controller logger")
+    database: Database = Field(..., description="Database logger")
+    exception: Exception = Field(..., description="Exception logger")
+    middleware: Middleware = Field(..., description="Middleware logger")
+    repository: Repository = Field(..., description="Repository logger")
+    service: Service = Field(..., description="Service logger")
+
+    @classmethod
+    def create(
+        cls,
+        *,
+        environment: Optional[Environment] = None,
+        service_key: Optional[Key] = None,
+        config: Config,
+    ) -> "Loggers":
+        return cls(
+            application=create(
+                LoggerType.APPLICATION,
+                environment=environment,
+                service_key=service_key,
+                config=config,
+            ),
+            cache=create(
+                LoggerType.CACHE,
+                environment=environment,
+                service_key=service_key,
+                config=config,
+            ),
+            controller=create(
+                LoggerType.CONTROLLER,
+                environment=environment,
+                service_key=service_key,
+                config=config,
+            ),
+            database=create(
+                LoggerType.DATABASE,
+                environment=environment,
+                service_key=service_key,
+                config=config,
+            ),
+            exception=create(
+                LoggerType.EXCEPTION,
+                environment=environment,
+                service_key=service_key,
+                config=config,
+            ),
+            middleware=create(
+                LoggerType.MIDDLEWARE,
+                environment=environment,
+                service_key=service_key,
+                config=config,
+            ),
+            repository=create(
+                LoggerType.REPOSITORY,
+                environment=environment,
+                service_key=service_key,
+                config=config,
+            ),
+            service=create(
+                LoggerType.SERVICE,
+                environment=environment,
+                service_key=service_key,
+                config=config,
+            ),
         )

{maleo_logging-0.0.5.dist-info → maleo_logging-0.0.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maleo-logging
-Version: 0.0.5
+Version: 0.0.7
 Summary: Logging package for MaleoSuite
 Author-email: Agra Bima Yuda <agra@nexmedis.com>
 License: Proprietary
@@ -35,7 +35,7 @@ Requires-Dist: idna>=3.10
 Requires-Dist: importlib_metadata>=8.7.0
 Requires-Dist: maleo-enums>=0.0.6
 Requires-Dist: maleo-types-base>=0.0.2
-Requires-Dist: maleo-utils>=0.0.4
+Requires-Dist: maleo-utils>=0.0.5
 Requires-Dist: mypy_extensions>=1.1.0
 Requires-Dist: nodeenv>=1.9.1
 Requires-Dist: opentelemetry-api>=1.36.0

maleo_logging-0.0.7.dist-info/RECORD

@@ -0,0 +1,10 @@
+maleo/logging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maleo/logging/config.py,sha256=eOeMJqDCoH2i_Sqmr1FzuSMklmT61XrB1pCqXU8YZ5s,1208
+maleo/logging/enums.py,sha256=GrM5rC5k8ErR3fcq9W1VrKkTe1B-u5z61lGzqTVukpY,578
+maleo/logging/google.py,sha256=h4ZiPbCCOdSOGdSXOzEFlJyCzNBcsoAzb5w_YtV9ipc,1443
+maleo/logging/logger.py,sha256=TSRvSNliu2G5HVzKQOL7kr9draiVoVm7D8onPAHwAo8,15616
+maleo_logging-0.0.7.dist-info/licenses/LICENSE,sha256=aftGsecnk7TWVX-7KW94FqK4Syy6YSZ8PZEF7EcIp3M,2621
+maleo_logging-0.0.7.dist-info/METADATA,sha256=z1JbfP-R7kN_bf4J6_4n-dweY8WeVRAelOucBTz_jO4,2709
+maleo_logging-0.0.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+maleo_logging-0.0.7.dist-info/top_level.txt,sha256=3Tpd1siVsfYoeI9FEOJNYnffx_shzZ3wsPpTvz5bljc,6
+maleo_logging-0.0.7.dist-info/RECORD,,

maleo/logging/dtos.py

@@ -1,24 +0,0 @@
-from pydantic import BaseModel, Field, ConfigDict
-from typing import Optional
-from maleo.enums.environment import Environment
-from maleo.enums.service import Key
-from maleo.types.base.string import OptionalString
-from .enums import Level, LoggerType
-from .google import GoogleCloudLogging
-
-
-class Labels(BaseModel):
-    logger_type: LoggerType = Field(..., description="Logger's type")
-    service_environment: Environment = Field(..., description="Service's environment")
-    service_key: Key = Field(..., description="Service's key")
-    client_key: OptionalString = Field(None, description="Client's key (Optional)")
-
-
-class SimpleConfig(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    dir: str = Field(..., description="Log's directory")
-    level: Level = Field(Level.INFO, description="Log's level")
-    google_cloud_logging: Optional[GoogleCloudLogging] = Field(
-        default_factory=GoogleCloudLogging, description="Google cloud logging"
-    )

maleo_logging-0.0.5.dist-info/RECORD

@@ -1,10 +0,0 @@
-maleo/logging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-maleo/logging/dtos.py,sha256=CqRERlS8TVzj7v7JaDwqNbjfgzFB6BDHBepvjvn-D5Y,984
-maleo/logging/enums.py,sha256=GrM5rC5k8ErR3fcq9W1VrKkTe1B-u5z61lGzqTVukpY,578
-maleo/logging/google.py,sha256=h4ZiPbCCOdSOGdSXOzEFlJyCzNBcsoAzb5w_YtV9ipc,1443
-maleo/logging/logger.py,sha256=9e-P8LZIPF7TV3LLmJyaX8mUUbJ_N27tTxyClncydrc,21227
-maleo_logging-0.0.5.dist-info/licenses/LICENSE,sha256=aftGsecnk7TWVX-7KW94FqK4Syy6YSZ8PZEF7EcIp3M,2621
-maleo_logging-0.0.5.dist-info/METADATA,sha256=qE3E-xVNtVqfJANlHhW1NAOD37ApNEXGSmrHnpBwwgE,2709
-maleo_logging-0.0.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-maleo_logging-0.0.5.dist-info/top_level.txt,sha256=3Tpd1siVsfYoeI9FEOJNYnffx_shzZ3wsPpTvz5bljc,6
-maleo_logging-0.0.5.dist-info/RECORD,,