pygrlogging 0.1.0__tar.gz

pygrlogging-0.1.0/.gitignore

@@ -0,0 +1,22 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+uv.lock
+
+
+# logs
+logs/
+logging.json
+
+#python-version
+.python-version
+
+#environments
+.env

pygrlogging-0.1.0/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: pygrlogging
+Version: 0.1.0
+Summary: Biblioteca para configurar Logs
+Author-email: ruizgabriel161 <ruizgabriel161@outlook.com>

pygrlogging-0.1.0/README.md

@@ -0,0 +1 @@
+

pygrlogging-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "pygrlogging"
+authors = [
+    {name = "ruizgabriel161",email = "ruizgabriel161@outlook.com"}
+]
+version = "0.1.0"
+description = "Biblioteca para configurar Logs" 
+# ============================
+# Build e Setuptools
+# ============================
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ['./src/pygrlogging']
+
+[tool.ruff]
+extend = '../../pyproject.toml'
+
+[tool.pyright]
+extends = '../../pyproject.toml'

pygrlogging-0.1.0/src/pygrlogging/filters.py

@@ -0,0 +1,12 @@
+import logging
+
+
+class MaxLevelFilter(logging.Filter):
+    def __init__(self, max_level: str) -> None:
+
+        super().__init__()
+
+        self.max_level = logging.getLevelNamesMapping().get(max_level.upper(), 30)
+    
+    def filter(self, record: logging.LogRecord) -> bool:
+        return record.levelno <= self.max_level

pygrlogging-0.1.0/src/pygrlogging/formatters.py

@@ -0,0 +1,84 @@
+from datetime import datetime, timedelta, timezone
+import json
+import logging
+from typing import Any, override
+from zoneinfo import ZoneInfo
+
+
+LOG_RECORD_KEYS = [
+    "name",
+    "msg",
+    "args",
+    "levelname",
+    "levelno",
+    "pathname",
+    "filename",
+    "module",
+    "exc_info",
+    "exc_text",
+    "stack_info",
+    "lineno",
+    "funcName",
+    "created",
+    "msecs",
+    "relativeCreated",
+    "thread",
+    "threadName",
+    "processName",
+    "process",
+    "taskName",
+]
+
+
+class JSONLogFormatter(logging.Formatter):
+    """docstring for JSONLogFormatter."""
+
+    def __init__(
+        self,
+        include_keys: list[str] | None = None,
+        datefmt: str = "%Y-%m-%dT%H:%M:%S%z",
+    ) -> None:
+        super(JSONLogFormatter, self).__init__()
+        self.include_keys = (
+            include_keys if include_keys is not None else LOG_RECORD_KEYS
+        )
+        self.datefmt = datefmt
+
+    @override
+    def format(self, record: logging.LogRecord) -> str:
+        dict_record: dict[str, Any] = {
+            key: getattr(record, key)
+            for key in self.include_keys
+            if LOG_RECORD_KEYS and getattr(record, key, None) is not None
+        }
+
+        if "created" in dict_record:
+            #sobreescreve o formato de data e hora
+            dict_record["created"] = self.formatTime(
+                record=record, datefmt=self.datefmt
+            )
+
+        if "message" in self.include_keys:
+            #
+            dict_record["message"] = record.getMessage()
+
+        if "exc_info" in dict_record and record.exc_info:
+            dict_record["exc_info"] = self.formatException(record.exc_info)
+
+        if "stack_info" in dict_record and record.stack_info:
+            dict_record["exc_info"] = self.formatStack(record.stack_info)
+
+        for key, val in vars(record).items():
+            if key in LOG_RECORD_KEYS:
+                continue
+            dict_record[key] = val
+
+        return json.dumps(obj=dict_record, default=str)
+
+    @override
+    def formatTime(self, record: logging.LogRecord, datefmt: str | None = None) -> str:
+        tz_sp = timezone(timedelta(hours=-3))
+        date = datetime.fromtimestamp(record.created, tz=tz_sp)
+        if datefmt:
+            return date.strftime(datefmt)
+        return date.isoformat()

pygrlogging-0.1.0/src/pygrlogging/handlers.py

@@ -0,0 +1,19 @@
+
+from logging import LogRecord
+from logging.handlers import QueueHandler
+import sys
+from typing import Any, Literal
+
+from rich.console import Console
+from rich.logging import RichHandler
+
+
+class MyRichHandler(RichHandler):
+    def __init__(self, file: Literal['stdout', 'stderr'], **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+
+        if file not in ['stdout', 'stderr']:
+            ValueError('file in not stdout or stderr')
+
+        console = Console(file=getattr(sys,file))
+        self.console = console

pygrlogging-0.1.0/src/pygrlogging/logging_config.py

@@ -0,0 +1,110 @@
+import atexit
+import json
+import logging
+from logging.config import dictConfig
+from logging.handlers import QueueHandler, QueueListener
+from pathlib import Path
+
+
+class LoggingConfig:
+    """
+    Classe responsável por abstrair as configurações do logging
+    """
+
+    _instance = None
+    _initialized: bool = False
+
+    def __new__(cls, *args, **kwargs):
+        """
+        __new__ Implementação do padrão singleton para evitar multiplas istânciais
+
+        Returns:
+            cls: instância da classe
+        """
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self, config_file: str | Path, logs_dir: str | Path):
+
+        if self._initialized:
+            return
+
+        self.config_file: Path = Path(config_file).resolve()
+        self.logs_dir = Path(logs_dir).resolve()
+        self._queue_handler: QueueHandler | None = None
+        self._queue_listener: QueueListener | None = None
+        self.logger: logging.Logger = logging.getLogger("config_setup")
+        self.logger.setLevel(logging.DEBUG)
+        self._setup_logging()
+
+    def _setup_logging(self) -> None:
+        """
+        _setup_logging Método responsável a configuração dos logs da aplicação
+        """
+
+        try:
+            config: dict = self._load_config()
+
+            # Carrega as configuração dos json para o log
+            dictConfig(config=config)
+
+            self._queue_handler = self._get_queue_handler()
+
+            self._setup_queue_listener()
+            self.logger.debug("Logging configurado com sucesso")
+            
+        except Exception as e:
+            self.logger.error(f"Erro ao configurar logging: {e}")
+            raise
+
+    def _setup_queue_listener(self) -> None:
+        if self._queue_handler is not None:
+            self._queue_listener = self._queue_handler.listener
+            if self._queue_listener is not None:
+                # caso exista um handler queue inicia o listener
+                self._queue_listener.start()
+                atexit.register(self._stop_queue_listener)
+
+    def _stop_queue_listener(self) -> None:
+        if self._queue_listener is not None:
+            self._queue_listener.stop()
+
+    def _get_queue_handler(self) -> QueueHandler | None:
+
+        queue_handlers = [
+            handler
+            for handler in logging.getLogger().handlers
+            if isinstance(handler, QueueHandler)
+        ]
+
+        if len(queue_handlers) > 1:
+            msg = "Não é permitido mais de um QueueHandler"
+            self.logger.exception(msg=msg)
+            raise RuntimeError(msg)
+
+        if len(queue_handlers) == 1:
+            return queue_handlers[0]
+        return None
+
+    def _load_config(self) -> dict:
+        """
+        _load_config Método para ler o json de configuração
+
+        Returns:
+            dict: retorna o json em dicionário
+        """
+        with self.config_file.open("r", encoding="utf8") as file:
+            return json.load(file)
+
+    def get_logger(self, name: str = "") -> logging.Logger:
+        """
+        Retorna um logger configurado.
+
+        Args:
+            name: Nome do logger (geralmente __name__)
+
+        Returns:
+            Logger configurado
+        """
+        return logging.getLogger(name)

pygrlogging-0.1.0/src/pygrlogging/settings_log.py

@@ -0,0 +1,89 @@
+from pathlib import Path
+from typing import Literal, TypeAlias
+
+from pydantic import field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+LogLevel: TypeAlias = Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+
+class SettingsLooging(BaseSettings):
+    model_config: SettingsConfigDict = SettingsConfigDict(
+    env_file='.env',  # determina onde está armazena as variaveis de ambiente, 
+    extra='ignore', # permite variáveis desconhecidas,
+    case_sensitive=True
+    )
+
+    ROOT_DIR: Path = Path(".").resolve()
+    LOGS_DIR: Path = Path("logs")
+    LOGGING_CONFIG_JSON: Path = Path("logging.json")
+
+    # -------------------------
+    # Logger config
+    # -------------------------
+
+    SETUP_LOGGER_NAME: str = "setup"
+    SETUP_LOGGER_LEVEL: LogLevel = "WARNING"
+    DEFAULT_LOGGER_LEVEL: LogLevel = "WARNING"
+
+    @field_validator('LOGS_DIR')
+    @classmethod
+    def validate_logs_dir(cls, path: Path | str) -> Path:
+        '''
+        validate_logs_dir Método responsável por verificar e garantir a existência de uma página de logs
+
+        Args:
+            path (Path | str): caminho do arquivo
+
+        Returns:
+            Path: caminho da pasta de logs
+        '''        
+        if isinstance(path, str):
+            path = Path(path).resolve()
+        
+        if not path.is_dir():
+            path.mkdir(parents=True, exist_ok=True)
+        return path
+
+    @field_validator('LOGGING_CONFIG_JSON')
+    @classmethod
+    def validate_logs_file(cls, path: Path) -> Path:
+        '''
+        validate_logs_file Método responsável por verificar a existência do arquivo de configuração
+
+        Args:
+            path (Path): Caminho do arquivo
+
+        Raises:
+            FileNotFoundError: Caso o arquivo não for encontrado
+
+        Returns:
+            Path: retorna o caminho
+        '''        
+
+        if isinstance(path, str):
+            path = Path(path).resolve()
+        if not path.is_file():
+             raise FileNotFoundError(path)
+        return path
+
+    @field_validator('DEFAULT_LOGGER_LEVEL')
+    @classmethod
+    def validate_level(cls, level: str) -> LogLevel:
+        '''
+        validate_level Método responsável por verificar o level do log
+
+        Args:
+            level (str): level padrão do log
+
+        Raises:
+            ValueError: erro caso o level não exista    
+
+        Returns:
+            LogLevel: retorna o level padrão
+        '''        
+        level = level.upper()
+        if level not in ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]:
+             msg = 'Level escolhido não suportado pelo Logging'
+             raise ValueError(msg)
+        return level #pyright: ignore
+