nexo-logging 0.0.1__tar.gz

nexo_logging-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 hubagrayuda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

nexo_logging-0.0.1/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: nexo-logging
+Version: 0.0.1
+Summary: Logging package for Nexo
+Author-email: Agra Bima Yuda <agra@nexmedis.com>
+License: Proprietary
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: annotated-types>=0.7.0
+Requires-Dist: black>=25.1.0
+Requires-Dist: cachetools>=5.5.2
+Requires-Dist: certifi>=2025.8.3
+Requires-Dist: cfgv>=3.4.0
+Requires-Dist: charset-normalizer>=3.4.3
+Requires-Dist: click>=8.3.0
+Requires-Dist: colorama>=0.4.6
+Requires-Dist: distlib>=0.4.0
+Requires-Dist: filelock>=3.19.1
+Requires-Dist: google-api-core>=2.25.1
+Requires-Dist: google-auth>=2.40.3
+Requires-Dist: google-cloud-appengine-logging>=1.6.2
+Requires-Dist: google-cloud-audit-log>=0.3.2
+Requires-Dist: google-cloud-core>=2.4.3
+Requires-Dist: google-cloud-logging>=3.12.1
+Requires-Dist: googleapis-common-protos>=1.70.0
+Requires-Dist: grpc-google-iam-v1>=0.14.2
+Requires-Dist: grpcio>=1.75.0
+Requires-Dist: grpcio-status>=1.75.0
+Requires-Dist: identify>=2.6.14
+Requires-Dist: idna>=3.10
+Requires-Dist: importlib_metadata>=8.7.0
+Requires-Dist: mypy_extensions>=1.1.0
+Requires-Dist: nexo-types>=0.0.1
+Requires-Dist: nodeenv>=1.9.1
+Requires-Dist: opentelemetry-api>=1.37.0
+Requires-Dist: packaging>=25.0
+Requires-Dist: pathspec>=0.12.1
+Requires-Dist: platformdirs>=4.4.0
+Requires-Dist: pre_commit>=4.3.0
+Requires-Dist: proto-plus>=1.26.1
+Requires-Dist: protobuf>=6.32.1
+Requires-Dist: pyasn1>=0.6.1
+Requires-Dist: pyasn1_modules>=0.4.2
+Requires-Dist: pydantic>=2.11.9
+Requires-Dist: pydantic_core>=2.33.2
+Requires-Dist: pytokens>=0.1.10
+Requires-Dist: PyYAML>=6.0.2
+Requires-Dist: requests>=2.32.5
+Requires-Dist: rsa>=4.9.1
+Requires-Dist: typing-inspection>=0.4.1
+Requires-Dist: typing_extensions>=4.15.0
+Requires-Dist: urllib3>=2.5.0
+Requires-Dist: virtualenv>=20.34.0
+Requires-Dist: zipp>=3.23.0
+Dynamic: license-file

nexo_logging-0.0.1/nexo_logging.egg-info/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: nexo-logging
+Version: 0.0.1
+Summary: Logging package for Nexo
+Author-email: Agra Bima Yuda <agra@nexmedis.com>
+License: Proprietary
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: annotated-types>=0.7.0
+Requires-Dist: black>=25.1.0
+Requires-Dist: cachetools>=5.5.2
+Requires-Dist: certifi>=2025.8.3
+Requires-Dist: cfgv>=3.4.0
+Requires-Dist: charset-normalizer>=3.4.3
+Requires-Dist: click>=8.3.0
+Requires-Dist: colorama>=0.4.6
+Requires-Dist: distlib>=0.4.0
+Requires-Dist: filelock>=3.19.1
+Requires-Dist: google-api-core>=2.25.1
+Requires-Dist: google-auth>=2.40.3
+Requires-Dist: google-cloud-appengine-logging>=1.6.2
+Requires-Dist: google-cloud-audit-log>=0.3.2
+Requires-Dist: google-cloud-core>=2.4.3
+Requires-Dist: google-cloud-logging>=3.12.1
+Requires-Dist: googleapis-common-protos>=1.70.0
+Requires-Dist: grpc-google-iam-v1>=0.14.2
+Requires-Dist: grpcio>=1.75.0
+Requires-Dist: grpcio-status>=1.75.0
+Requires-Dist: identify>=2.6.14
+Requires-Dist: idna>=3.10
+Requires-Dist: importlib_metadata>=8.7.0
+Requires-Dist: mypy_extensions>=1.1.0
+Requires-Dist: nexo-types>=0.0.1
+Requires-Dist: nodeenv>=1.9.1
+Requires-Dist: opentelemetry-api>=1.37.0
+Requires-Dist: packaging>=25.0
+Requires-Dist: pathspec>=0.12.1
+Requires-Dist: platformdirs>=4.4.0
+Requires-Dist: pre_commit>=4.3.0
+Requires-Dist: proto-plus>=1.26.1
+Requires-Dist: protobuf>=6.32.1
+Requires-Dist: pyasn1>=0.6.1
+Requires-Dist: pyasn1_modules>=0.4.2
+Requires-Dist: pydantic>=2.11.9
+Requires-Dist: pydantic_core>=2.33.2
+Requires-Dist: pytokens>=0.1.10
+Requires-Dist: PyYAML>=6.0.2
+Requires-Dist: requests>=2.32.5
+Requires-Dist: rsa>=4.9.1
+Requires-Dist: typing-inspection>=0.4.1
+Requires-Dist: typing_extensions>=4.15.0
+Requires-Dist: urllib3>=2.5.0
+Requires-Dist: virtualenv>=20.34.0
+Requires-Dist: zipp>=3.23.0
+Dynamic: license-file

nexo_logging-0.0.1/nexo_logging.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+pyproject.toml
+nexo_logging.egg-info/PKG-INFO
+nexo_logging.egg-info/SOURCES.txt
+nexo_logging.egg-info/dependency_links.txt
+nexo_logging.egg-info/requires.txt
+nexo_logging.egg-info/top_level.txt
+src/__init__.py
+src/config.py
+src/enums.py
+src/logger.py

nexo_logging-0.0.1/nexo_logging.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

nexo_logging-0.0.1/nexo_logging.egg-info/requires.txt

@@ -0,0 +1,46 @@
+annotated-types>=0.7.0
+black>=25.1.0
+cachetools>=5.5.2
+certifi>=2025.8.3
+cfgv>=3.4.0
+charset-normalizer>=3.4.3
+click>=8.3.0
+colorama>=0.4.6
+distlib>=0.4.0
+filelock>=3.19.1
+google-api-core>=2.25.1
+google-auth>=2.40.3
+google-cloud-appengine-logging>=1.6.2
+google-cloud-audit-log>=0.3.2
+google-cloud-core>=2.4.3
+google-cloud-logging>=3.12.1
+googleapis-common-protos>=1.70.0
+grpc-google-iam-v1>=0.14.2
+grpcio>=1.75.0
+grpcio-status>=1.75.0
+identify>=2.6.14
+idna>=3.10
+importlib_metadata>=8.7.0
+mypy_extensions>=1.1.0
+nexo-types>=0.0.1
+nodeenv>=1.9.1
+opentelemetry-api>=1.37.0
+packaging>=25.0
+pathspec>=0.12.1
+platformdirs>=4.4.0
+pre_commit>=4.3.0
+proto-plus>=1.26.1
+protobuf>=6.32.1
+pyasn1>=0.6.1
+pyasn1_modules>=0.4.2
+pydantic>=2.11.9
+pydantic_core>=2.33.2
+pytokens>=0.1.10
+PyYAML>=6.0.2
+requests>=2.32.5
+rsa>=4.9.1
+typing-inspection>=0.4.1
+typing_extensions>=4.15.0
+urllib3>=2.5.0
+virtualenv>=20.34.0
+zipp>=3.23.0

nexo_logging-0.0.1/nexo_logging.egg-info/top_level.txt

@@ -0,0 +1 @@
+nexo

nexo_logging-0.0.1/pyproject.toml

@@ -0,0 +1,71 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "nexo-logging"
+version = "0.0.1"
+description = "Logging package for Nexo"
+authors = [
+    { name = "Agra Bima Yuda", email = "agra@nexmedis.com" }
+]
+license = { text = "Proprietary"}
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "annotated-types>=0.7.0",
+    "black>=25.1.0",
+    "cachetools>=5.5.2",
+    "certifi>=2025.8.3",
+    "cfgv>=3.4.0",
+    "charset-normalizer>=3.4.3",
+    "click>=8.3.0",
+    "colorama>=0.4.6",
+    "distlib>=0.4.0",
+    "filelock>=3.19.1",
+    "google-api-core>=2.25.1",
+    "google-auth>=2.40.3",
+    "google-cloud-appengine-logging>=1.6.2",
+    "google-cloud-audit-log>=0.3.2",
+    "google-cloud-core>=2.4.3",
+    "google-cloud-logging>=3.12.1",
+    "googleapis-common-protos>=1.70.0",
+    "grpc-google-iam-v1>=0.14.2",
+    "grpcio>=1.75.0",
+    "grpcio-status>=1.75.0",
+    "identify>=2.6.14",
+    "idna>=3.10",
+    "importlib_metadata>=8.7.0",
+    "mypy_extensions>=1.1.0",
+    "nexo-types>=0.0.1",
+    "nodeenv>=1.9.1",
+    "opentelemetry-api>=1.37.0",
+    "packaging>=25.0",
+    "pathspec>=0.12.1",
+    "platformdirs>=4.4.0",
+    "pre_commit>=4.3.0",
+    "proto-plus>=1.26.1",
+    "protobuf>=6.32.1",
+    "pyasn1>=0.6.1",
+    "pyasn1_modules>=0.4.2",
+    "pydantic>=2.11.9",
+    "pydantic_core>=2.33.2",
+    "pytokens>=0.1.10",
+    "PyYAML>=6.0.2",
+    "requests>=2.32.5",
+    "rsa>=4.9.1",
+    "typing-inspection>=0.4.1",
+    "typing_extensions>=4.15.0",
+    "urllib3>=2.5.0",
+    "virtualenv>=20.34.0",
+    "zipp>=3.23.0",
+]
+
+[tool.setuptools]
+packages = ["nexo.logging"]
+
+[tool.setuptools.package-data]
+"nexo.logging" = ["*.json", "*.yaml"]
+
+[tool.setuptools.package-dir]
+"nexo.logging" = "src"

nexo_logging-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

nexo_logging-0.0.1/src/config.py

@@ -0,0 +1,38 @@
+from google.cloud.logging import Client
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+from typing import Self
+from typing_extensions import Annotated
+from nexo.types.dict import OptStrToStrDict
+from nexo.types.string import OptStr
+from .enums import Level
+
+
+class LogConfig(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    dir: Annotated[str, Field(..., description="Log's directory")]
+    level: Annotated[Level, Field(Level.INFO, description="Log's level")] = Level.INFO
+
+    google_cloud_logging: Annotated[
+        Client | None, Field(None, description="Google cloud logging")
+    ] = None
+
+    labels: Annotated[
+        OptStrToStrDict, Field(None, description="Log labels. (Optional)")
+    ] = None
+
+    aggregate_file_name: Annotated[
+        OptStr, Field(None, description="Log aggregate file name")
+    ] = None
+
+    individual_log: Annotated[
+        bool, Field(True, description="Whether to have individual log")
+    ] = True
+
+    @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

nexo_logging-0.0.1/src/enums.py

@@ -0,0 +1,36 @@
+import logging
+from enum import IntEnum, StrEnum
+from nexo.types.integer import ListOfInts
+from nexo.types.string import ListOfStrs
+
+
+class Level(IntEnum):
+    CRITICAL = logging.CRITICAL
+    FATAL = logging.FATAL
+    ERROR = logging.ERROR
+    WARNING = logging.WARNING
+    WARN = logging.WARN
+    INFO = logging.INFO
+    DEBUG = logging.DEBUG
+    NOTSET = logging.NOTSET
+
+    @classmethod
+    def choices(cls) -> ListOfInts:
+        return [e.value for e in cls]
+
+
+class LoggerType(StrEnum):
+    BASE = "base"
+    APPLICATION = "application"
+    CACHE = "cache"
+    CLIENT = "client"
+    CONTROLLER = "controller"
+    DATABASE = "database"
+    EXCEPTION = "exception"
+    MIDDLEWARE = "middleware"
+    REPOSITORY = "repository"
+    SERVICE = "service"
+
+    @classmethod
+    def choices(cls) -> ListOfStrs:
+        return [e.value for e in cls]

nexo_logging-0.0.1/src/logger.py

@@ -0,0 +1,565 @@
+import logging
+import os
+from datetime import datetime, timezone
+from google.cloud.logging.handlers import CloudLoggingHandler
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Generic, Literal, TypeVar, overload
+from nexo.types.dict import StrToStrDict
+from nexo.types.misc import StrOrStrEnum
+from nexo.types.string import OptStr
+from .config import LogConfig
+from .enums import LoggerType
+
+
+EnvironmentT = TypeVar("EnvironmentT", bound=StrOrStrEnum)
+ServiceKeyT = TypeVar("ServiceKeyT", bound=StrOrStrEnum)
+
+
+# * We suggest to NOT use this class
+# * Instead use the inherited classes
+class Base(
+    logging.Logger,
+    Generic[
+        EnvironmentT,
+        ServiceKeyT,
+    ],
+):
+    def __init__(
+        self,
+        type: LoggerType = LoggerType.BASE,
+        *,
+        environment: EnvironmentT | None = None,
+        service_key: ServiceKeyT | None = None,
+        client_key: OptStr = None,
+        config: LogConfig,
+    ):
+        self._type = type  # Declare logger type
+
+        # Ensure environment exists
+        actual_environment = environment or os.getenv("ENVIRONMENT")
+        if actual_environment is None:
+            raise ValueError(
+                "ENVIRONMENT environment variable must be set if 'environment' is set to None"
+            )
+        else:
+            self._environment = actual_environment
+
+        # Ensure service_key exists
+        actual_service_key = service_key or os.getenv("SERVICE_KEY")
+        if actual_service_key is None:
+            raise ValueError(
+                "SERVICE_KEY environment variable must be set if 'service_key' is set to None"
+            )
+        else:
+            self._service_key = actual_service_key
+
+        self._client_key = client_key  # Declare client key
+
+        # Ensure client_key is valid if logger type is a client
+        if self._type is LoggerType.CLIENT and self._client_key is None:
+            raise ValueError(
+                "'client_key' parameter must be provided if 'logger_type' is 'client'"
+            )
+
+        # Define logger name
+        base_name = f"{self._environment} - {self._service_key} - {self._type}"
+        if self._type is LoggerType.CLIENT:
+            self._name = f"{base_name} - {self._client_key}"
+        else:
+            self._name = base_name
+
+        # Define log labels
+        self._labels: StrToStrDict = {
+            "logger_type": self._type.value,
+            "service_environment": str(self._environment),
+            "service_key": str(self._service_key),
+        }
+        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, self._config.level)  # Init the superclass's logger
+
+        # Clear existing handlers to prevent duplicates
+        for handler in list(self.handlers):
+            self.removeHandler(handler)
+            handler.close()
+
+        # Console handler
+        console_handler = logging.StreamHandler()
+        console_handler.setFormatter(
+            logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+        )
+        self.addHandler(console_handler)
+
+        # Google Cloud Logging handler (If enabled)
+        if self._config.google_cloud_logging is not None:
+            self._cloud_logging_handler = CloudLoggingHandler(
+                self._config.google_cloud_logging,
+                name=self._name.replace(" ", ""),
+                labels=self._labels,
+            )
+            self.addHandler(self._cloud_logging_handler)
+        else:
+            self.warning(
+                "Cloud logging is not configured. Will not add cloud logging handler"
+            )
+
+        # Define aggregate log directory
+        if self._config.aggregate_file_name is not None:
+            self._aggregate_log_dir = os.path.join(self._config.dir, "aggregate")
+            os.makedirs(self._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(
+                self._aggregate_log_dir, self._config.aggregate_file_name
+            )
+
+            # File handler
+            file_handler = logging.FileHandler(log_filename, mode="a")
+            file_handler.setFormatter(
+                logging.Formatter(
+                    "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+                )
+            )
+            self.addHandler(file_handler)
+
+        # Define individual log directory
+        if self._config.individual_log:
+            self._individual_log_dir = os.path.join(self._config.dir, self._type)
+            if self._type is LoggerType.CLIENT:
+                if self._client_key is None:
+                    raise ValueError(
+                        "'client_key' parameter must be provided if 'logger_type' is 'client'"
+                    )
+                self._individual_log_dir = os.path.join(
+                    self._individual_log_dir, self._client_key
+                )
+            os.makedirs(self._individual_log_dir, exist_ok=True)
+
+            # Generate timestamped filename
+            log_filename = os.path.join(
+                self._individual_log_dir,
+                f"{datetime.now(tz=timezone.utc).isoformat(timespec="seconds")}.log",
+            )
+
+            # File handler
+            file_handler = logging.FileHandler(log_filename, mode="a")
+            file_handler.setFormatter(
+                logging.Formatter(
+                    "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+                )
+            )
+            self.addHandler(file_handler)
+
+        logging.Logger.manager.loggerDict[self._name] = self
+
+    def dispose(self):
+        """Dispose of the logger by removing all handlers."""
+        for handler in list(self.handlers):
+            self.removeHandler(handler)
+            handler.close()
+        self.handlers.clear()
+
+
+class Application(Base[EnvironmentT, ServiceKeyT], Generic[EnvironmentT, ServiceKeyT]):
+    def __init__(
+        self,
+        *,
+        environment: EnvironmentT | None = None,
+        service_key: ServiceKeyT | None = None,
+        config: LogConfig,
+    ):
+        super().__init__(
+            LoggerType.APPLICATION,
+            environment=environment,
+            service_key=service_key,
+            client_key=None,
+            config=config,
+        )
+
+
+class Cache(Base[EnvironmentT, ServiceKeyT], Generic[EnvironmentT, ServiceKeyT]):
+    def __init__(
+        self,
+        *,
+        environment: EnvironmentT | None = None,
+        service_key: ServiceKeyT | None = None,
+        config: LogConfig,
+    ):
+        super().__init__(
+            LoggerType.CACHE,
+            environment=environment,
+            service_key=service_key,
+            client_key=None,
+            config=config,
+        )
+
+
+class Client(Base[EnvironmentT, ServiceKeyT], Generic[EnvironmentT, ServiceKeyT]):
+    def __init__(
+        self,
+        *,
+        environment: EnvironmentT | None = None,
+        service_key: ServiceKeyT | None = None,
+        client_key: str,
+        config: LogConfig,
+    ):
+        super().__init__(
+            LoggerType.CLIENT,
+            environment=environment,
+            service_key=service_key,
+            client_key=client_key,
+            config=config,
+        )
+
+
+class Controller(Base[EnvironmentT, ServiceKeyT], Generic[EnvironmentT, ServiceKeyT]):
+    def __init__(
+        self,
+        *,
+        environment: EnvironmentT | None = None,
+        service_key: ServiceKeyT | None = None,
+        config: LogConfig,
+    ):
+        super().__init__(
+            LoggerType.CONTROLLER,
+            environment=environment,
+            service_key=service_key,
+            client_key=None,
+            config=config,
+        )
+
+
+class Database(Base[EnvironmentT, ServiceKeyT], Generic[EnvironmentT, ServiceKeyT]):
+    def __init__(
+        self,
+        *,
+        environment: EnvironmentT | None = None,
+        service_key: ServiceKeyT | None = None,
+        config: LogConfig,
+    ):
+        super().__init__(
+            LoggerType.DATABASE,
+            environment=environment,
+            service_key=service_key,
+            client_key=None,
+            config=config,
+        )
+
+
+class Exception(Base[EnvironmentT, ServiceKeyT], Generic[EnvironmentT, ServiceKeyT]):
+    def __init__(
+        self,
+        *,
+        environment: EnvironmentT | None = None,
+        service_key: ServiceKeyT | None = None,
+        config: LogConfig,
+    ):
+        super().__init__(
+            LoggerType.EXCEPTION,
+            environment=environment,
+            service_key=service_key,
+            client_key=None,
+            config=config,
+        )
+
+
+class Middleware(Base[EnvironmentT, ServiceKeyT], Generic[EnvironmentT, ServiceKeyT]):
+    def __init__(
+        self,
+        *,
+        environment: EnvironmentT | None = None,
+        service_key: ServiceKeyT | None = None,
+        config: LogConfig,
+    ):
+        super().__init__(
+            LoggerType.MIDDLEWARE,
+            environment=environment,
+            service_key=service_key,
+            client_key=None,
+            config=config,
+        )
+
+
+class Repository(Base[EnvironmentT, ServiceKeyT], Generic[EnvironmentT, ServiceKeyT]):
+    def __init__(
+        self,
+        *,
+        environment: EnvironmentT | None = None,
+        service_key: ServiceKeyT | None = None,
+        config: LogConfig,
+    ):
+        super().__init__(
+            LoggerType.REPOSITORY,
+            environment=environment,
+            service_key=service_key,
+            client_key=None,
+            config=config,
+        )
+
+
+class Service(Base[EnvironmentT, ServiceKeyT], Generic[EnvironmentT, ServiceKeyT]):
+    def __init__(
+        self,
+        *,
+        environment: EnvironmentT | None = None,
+        service_key: ServiceKeyT | None = None,
+        config: LogConfig,
+    ):
+        super().__init__(
+            LoggerType.SERVICE,
+            environment=environment,
+            service_key=service_key,
+            client_key=None,
+            config=config,
+        )
+
+
+@overload
+def create(
+    type: Literal[LoggerType.APPLICATION],
+    *,
+    environment: EnvironmentT | None = None,
+    service_key: ServiceKeyT | None = None,
+    config: LogConfig,
+) -> Application[EnvironmentT, ServiceKeyT]: ...
+@overload
+def create(
+    type: Literal[LoggerType.CACHE],
+    *,
+    environment: EnvironmentT | None = None,
+    service_key: ServiceKeyT | None = None,
+    config: LogConfig,
+) -> Cache[EnvironmentT, ServiceKeyT]: ...
+@overload
+def create(
+    type: Literal[LoggerType.CLIENT],
+    *,
+    environment: EnvironmentT | None = None,
+    service_key: ServiceKeyT | None = None,
+    client_key: str,
+    config: LogConfig,
+) -> Client[EnvironmentT, ServiceKeyT]: ...
+@overload
+def create(
+    type: Literal[LoggerType.CONTROLLER],
+    *,
+    environment: EnvironmentT | None = None,
+    service_key: ServiceKeyT | None = None,
+    config: LogConfig,
+) -> Controller[EnvironmentT, ServiceKeyT]: ...
+@overload
+def create(
+    type: Literal[LoggerType.DATABASE],
+    *,
+    environment: EnvironmentT | None = None,
+    service_key: ServiceKeyT | None = None,
+    config: LogConfig,
+) -> Database[EnvironmentT, ServiceKeyT]: ...
+@overload
+def create(
+    type: Literal[LoggerType.EXCEPTION],
+    *,
+    environment: EnvironmentT | None = None,
+    service_key: ServiceKeyT | None = None,
+    config: LogConfig,
+) -> Exception[EnvironmentT, ServiceKeyT]: ...
+@overload
+def create(
+    type: Literal[LoggerType.MIDDLEWARE],
+    *,
+    environment: EnvironmentT | None = None,
+    service_key: ServiceKeyT | None = None,
+    config: LogConfig,
+) -> Middleware[EnvironmentT, ServiceKeyT]: ...
+@overload
+def create(
+    type: Literal[LoggerType.REPOSITORY],
+    *,
+    environment: EnvironmentT | None = None,
+    service_key: ServiceKeyT | None = None,
+    config: LogConfig,
+) -> Repository[EnvironmentT, ServiceKeyT]: ...
+@overload
+def create(
+    type: Literal[LoggerType.SERVICE],
+    *,
+    environment: EnvironmentT | None = None,
+    service_key: ServiceKeyT | None = None,
+    config: LogConfig,
+) -> Service[EnvironmentT, ServiceKeyT]: ...
+def create(
+    type: LoggerType = LoggerType.BASE,
+    *,
+    environment: EnvironmentT | None = None,
+    service_key: ServiceKeyT | None = None,
+    client_key: OptStr = None,
+    config: LogConfig,
+) -> (
+    Base[EnvironmentT, ServiceKeyT]
+    | Application[EnvironmentT, ServiceKeyT]
+    | Cache[EnvironmentT, ServiceKeyT]
+    | Client[EnvironmentT, ServiceKeyT]
+    | Controller[EnvironmentT, ServiceKeyT]
+    | Database[EnvironmentT, ServiceKeyT]
+    | Exception[EnvironmentT, ServiceKeyT]
+    | Middleware[EnvironmentT, ServiceKeyT]
+    | Repository[EnvironmentT, ServiceKeyT]
+    | Service[EnvironmentT, ServiceKeyT]
+):
+    if type is LoggerType.BASE:
+        return Base[EnvironmentT, ServiceKeyT](
+            environment=environment,
+            service_key=service_key,
+            client_key=client_key,
+            config=config,
+        )
+    elif type is LoggerType.APPLICATION:
+        return Application[EnvironmentT, ServiceKeyT](
+            environment=environment,
+            service_key=service_key,
+            config=config,
+        )
+    elif type is LoggerType.CACHE:
+        return Cache[EnvironmentT, ServiceKeyT](
+            environment=environment,
+            service_key=service_key,
+            config=config,
+        )
+    elif type is LoggerType.CLIENT:
+        if client_key is None:
+            raise ValueError(
+                "Argument 'client_key' can not be None if 'logger_type' is 'client'"
+            )
+        return Client[EnvironmentT, ServiceKeyT](
+            environment=environment,
+            service_key=service_key,
+            client_key=client_key,
+            config=config,
+        )
+    elif type is LoggerType.CONTROLLER:
+        return Controller[EnvironmentT, ServiceKeyT](
+            environment=environment,
+            service_key=service_key,
+            config=config,
+        )
+    elif type is LoggerType.DATABASE:
+        return Database[EnvironmentT, ServiceKeyT](
+            environment=environment,
+            service_key=service_key,
+            config=config,
+        )
+    elif type is LoggerType.EXCEPTION:
+        return Exception[EnvironmentT, ServiceKeyT](
+            environment=environment,
+            service_key=service_key,
+            config=config,
+        )
+    elif type is LoggerType.MIDDLEWARE:
+        return Middleware[EnvironmentT, ServiceKeyT](
+            environment=environment,
+            service_key=service_key,
+            config=config,
+        )
+    elif type is LoggerType.REPOSITORY:
+        return Repository[EnvironmentT, ServiceKeyT](
+            environment=environment,
+            service_key=service_key,
+            config=config,
+        )
+    elif type is LoggerType.SERVICE:
+        return Service[EnvironmentT, ServiceKeyT](
+            environment=environment,
+            service_key=service_key,
+            config=config,
+        )
+
+
+class ApplicationLoggers(BaseModel, Generic[EnvironmentT, ServiceKeyT]):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    application: Application[EnvironmentT, ServiceKeyT] = Field(
+        ..., description="Application logger"
+    )
+    cache: Cache[EnvironmentT, ServiceKeyT] = Field(..., description="Cache logger")
+    controller: Controller[EnvironmentT, ServiceKeyT] = Field(
+        ..., description="Controller logger"
+    )
+    database: Database[EnvironmentT, ServiceKeyT] = Field(
+        ..., description="Database logger"
+    )
+    exception: Exception[EnvironmentT, ServiceKeyT] = Field(
+        ..., description="Exception logger"
+    )
+    middleware: Middleware[EnvironmentT, ServiceKeyT] = Field(
+        ..., description="Middleware logger"
+    )
+    repository: Repository[EnvironmentT, ServiceKeyT] = Field(
+        ..., description="Repository logger"
+    )
+    service: Service[EnvironmentT, ServiceKeyT] = Field(
+        ..., description="Service logger"
+    )
+
+    @classmethod
+    def new(
+        cls,
+        *,
+        environment: EnvironmentT | None = None,
+        service_key: ServiceKeyT | None = None,
+        config: LogConfig,
+    ) -> "ApplicationLoggers[EnvironmentT, ServiceKeyT]":
+        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,
+            ),
+        )