jaylog 0.2.1__tar.gz → 0.2.4__tar.gz

{jaylog-0.2.1 → jaylog-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: jaylog
-Version: 0.2.1
+Version: 0.2.4
 Summary: Customized Python logging library with file rotation and HTTP forwarding
 Author: Gpocas
 Author-email: Gpocas <gpocas01@gmail.com>

{jaylog-0.2.1 → jaylog-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "jaylog"
-version = "0.2.1"
+version = "0.2.4"
 description = "Customized Python logging library with file rotation and HTTP forwarding"
 readme = "README.md"
 authors = [

{jaylog-0.2.1 → jaylog-0.2.4}/src/jaylog/formatters.py

@@ -100,11 +100,18 @@ def build_log_entry_dict(record: logging.LogRecord) -> dict:
 class PlainTextFormatter(logging.Formatter):
     """Human-readable single-line formatter for .log files."""
 
+    def __init__(self, show_service: bool = True) -> None:
+        super().__init__()
+        self.show_service = show_service
+
     def format(self, record: logging.LogRecord) -> str:
         entry = build_log_entry_dict(record)
-        line = (
-            f"{entry['log_timestamp']} [{entry['log_level']}]"
-            f" {entry['service']} {entry['hostname']}({entry['ipv4']}) {entry['username']}"
-            f" | {entry['log_message']}"
+        log_timestamp = datetime.fromisoformat(entry['log_timestamp']).strftime('%d/%m/%Y %X')
+        log_level = f'[{entry["log_level"]}]'
+        service_segment = f'[{entry["service"]}] | ' if self.show_service else ''
+        return (
+            f'{log_timestamp} '
+            f'{log_level.ljust(11)} | '
+            f'{service_segment}'
+            f"{entry['log_message']}"
         )
-        return line

jaylog-0.2.4/src/jaylog/handlers/__init__.py

@@ -0,0 +1,5 @@
+from .console_handler import JaylogConsoleHandler
+from .file_handler import JaylogFileHandler
+from .http_handler import JaylogHttpHandler
+
+__all__ = ["JaylogConsoleHandler", "JaylogFileHandler", "JaylogHttpHandler"]

jaylog-0.2.4/src/jaylog/handlers/console_handler.py

@@ -0,0 +1,43 @@
+import logging
+import sys
+from datetime import datetime
+
+from jaylog.formatters import build_log_entry_dict
+
+_GREEN = "\033[32m"
+_BLUE = "\033[34m"
+_PURPLE = "\033[35m"
+_YELLOW = "\033[33m"
+_RED = "\033[31m"
+_RESET = "\033[0m"
+
+_LEVEL_COLORS = {
+    "DEBUG": _PURPLE,
+    "INFO": _BLUE,
+    "WARNING": _YELLOW,
+}
+
+
+def _level_color(level: str) -> str:
+    return _LEVEL_COLORS.get(level, _RED)
+
+
+class ConsoleFormatter(logging.Formatter):
+    def __init__(self, show_service: bool = True) -> None:
+        super().__init__()
+        self.show_service = show_service
+
+    def format(self, record: logging.LogRecord) -> str:
+        entry = build_log_entry_dict(record)
+        log_timestamp = datetime.fromisoformat(entry["log_timestamp"]).strftime("%d/%m/%Y %X")
+        log_level = f'[{entry["log_level"]}]'
+        colored_timestamp = f"{_GREEN}{log_timestamp}{_RESET}"
+        colored_level = f"{_level_color(entry['log_level'])}{log_level.ljust(11)}{_RESET}"
+        service_segment = f'[{entry["service"]}] | ' if self.show_service else ''
+        return f"{colored_timestamp} {colored_level} | {service_segment}{entry['log_message']}"
+
+
+class JaylogConsoleHandler(logging.StreamHandler):
+    def __init__(self, show_service: bool = True) -> None:
+        super().__init__(stream=sys.stdout)
+        self.setFormatter(ConsoleFormatter(show_service=show_service))

{jaylog-0.2.1 → jaylog-0.2.4}/src/jaylog/handlers/file_handler.py

@@ -19,6 +19,7 @@ class JaylogFileHandler(RotatingFileHandler):
         backup_count: int = 20,
         retention_days: int = 7,
         encoding: str = "utf-8",
+        show_service: bool = True,
     ) -> None:
         filename.parent.mkdir(parents=True, exist_ok=True)
         super().__init__(
@@ -28,7 +29,7 @@ class JaylogFileHandler(RotatingFileHandler):
             encoding=encoding,
         )
         self.retention_days = retention_days
-        self.setFormatter(PlainTextFormatter())
+        self.setFormatter(PlainTextFormatter(show_service=show_service))
 
     def doRollover(self) -> None:
         super().doRollover()

{jaylog-0.2.1 → jaylog-0.2.4}/src/jaylog/logger.py

@@ -6,6 +6,7 @@ from queue import Queue
 
 from jaylog.filters import ExceptionFlagFilter
 from jaylog.formatters import configure_screenshot
+from jaylog.handlers.console_handler import JaylogConsoleHandler
 from jaylog.handlers.file_handler import JaylogFileHandler
 from jaylog.handlers.http_handler import JaylogHttpHandler
 from jaylog.settings import JaylogSettings
@@ -13,14 +14,39 @@ from jaylog.settings import JaylogSettings
 # Registry: name -> (logger, listener) so callers can shut down cleanly
 _registry: dict[str, tuple[logging.Logger, QueueListener]] = {}
 _shutdown_registered = False
-_default_settings: JaylogSettings | None = None
+# name (== app_name) -> settings registrada via configure()
+_settings_registry: dict[str, JaylogSettings] = {}
 
 
-def configure(settings: JaylogSettings) -> None:
-    """Configure as settings padrão globais usadas por get_logger()."""
-    global _default_settings
-    _default_settings = settings
+def configure(settings: JaylogSettings | list[JaylogSettings]) -> None:
+    """
+    Registra uma ou mais configurações de logger.
+
+    Aceita uma única ``JaylogSettings`` ou uma lista delas. Cada configuração é
+    registrada sob o seu próprio ``app_name``, permitindo vários loggers com
+    configurações diferentes no mesmo projeto::
+
+        configure(settings_order)
+        configure([settings_order, settings_billing])
+
+    Cada chamada é a "fonte da verdade" do conjunto de loggers: derruba os
+    loggers registrados anteriormente e registra apenas os informados aqui.
+    Levanta ``ValueError`` se a lista contiver ``app_name`` duplicado.
+    """
+    items = [settings] if isinstance(settings, JaylogSettings) else list(settings)
+
+    seen: set[str] = set()
+    for item in items:
+        if item.app_name in seen:
+            raise ValueError(
+                f"app_name duplicado em configure(): '{item.app_name}'"
+            )
+        seen.add(item.app_name)
+
     shutdown()
+    _settings_registry.clear()
+    for item in items:
+        _settings_registry[item.app_name] = item
 
 
 def _register_shutdown_hooks() -> None:
@@ -39,13 +65,14 @@ def _register_shutdown_hooks() -> None:
     signal.signal(signal.SIGTERM, _sigterm_handler)
 
 
-def get_logger() -> logging.Logger:
+def get_logger(name: str | None = None) -> logging.Logger:
     """
     Return a configured logger.
 
-    The logger name is read from JAYLOG_LOGGER_NAME (default: "jaylog").
-    Calling this multiple times with the same logger name returns the **same**
-    logger without re-attaching handlers.
+    O ``name`` deve ser exatamente o ``app_name`` de uma configuração registrada
+    via ``configure()``. Quando omitido, retorna o logger da **primeira**
+    configuração registrada. Chamadas repetidas com o mesmo nome retornam o
+    **mesmo** logger, sem re-anexar handlers.
 
     Architecture:
         logger  →  QueueHandler  →  Queue  →  QueueListener  →  [FileHandler, HttpHandler?]
@@ -53,12 +80,22 @@ def get_logger() -> logging.Logger:
     The QueueListener runs in a background thread so `emit()` never blocks the
     calling thread.
     """
-    if _default_settings is None:
-        settings = JaylogSettings()  # ty:ignore[missing-argument]
-    else:
-        settings = _default_settings
+    if not _settings_registry:
+        raise Exception(
+            'Não é possivel retornar uma instancia de logger sem configuração\n'
+            'use jaylog.configure() antes de jaylog.get_logger()'
+        )
 
-    name = settings.app_name
+    if name is None:
+        name = next(iter(_settings_registry))
+    elif name not in _settings_registry:
+        disponiveis = ', '.join(_settings_registry) or '(nenhum)'
+        raise KeyError(
+            f"Nenhuma configuração registrada para '{name}'. "
+            f"Nomes disponíveis: {disponiveis}"
+        )
+
+    settings = _settings_registry[name]
 
     configure_screenshot(settings.log_screenshot_enabled)
 
@@ -69,16 +106,24 @@ def get_logger() -> logging.Logger:
     # Build the actual (downstream) handlers
     # ------------------------------------------------------------------
     downstream: list[logging.Handler] = []
+    show_service = len(_settings_registry) > 1
+
+    if settings.log_dir is not None:
+        log_path = settings.log_dir / settings.log_filename
+        file_handler = JaylogFileHandler(
+            filename=log_path,
+            max_bytes=settings.log_max_bytes,
+            backup_count=settings.log_backup_count,
+            retention_days=settings.log_retention_days,
+            show_service=show_service,
+        )
+        file_handler.setLevel(settings.log_level)
+        downstream.append(file_handler)
 
-    log_path = settings.log_dir / settings.log_filename
-    file_handler = JaylogFileHandler(
-        filename=log_path,
-        max_bytes=settings.log_max_bytes,
-        backup_count=settings.log_backup_count,
-        retention_days=settings.log_retention_days,
-    )
-    file_handler.setLevel(settings.log_level)
-    downstream.append(file_handler)
+    if settings.log_console_enabled:
+        console_handler = JaylogConsoleHandler(show_service=show_service)
+        console_handler.setLevel(settings.log_level)
+        downstream.append(console_handler)
 
     if settings.log_http_endpoint and settings.log_http_api_key:
         http_handler = JaylogHttpHandler(

{jaylog-0.2.1 → jaylog-0.2.4}/src/jaylog/settings.py

@@ -17,15 +17,21 @@ class JaylogSettings(BaseSettings):
     )
 
     _env_file: str | tuple | None = None
+    _secrets_dir: str | None = None
 
-    def __init__(self, _env_file=None, **data):
-        _env_file = self.model_config.get('env_file') if _env_file is None else _env_file
-        super().__init__(_env_file=_env_file, **data)
+    def __init__(
+        self,
+        _env_file=model_config.get('env_file'),
+        _secrets_dir=model_config.get('secrets_dir'),
+        **data
+    ):
+        super().__init__(_env_file=_env_file, _secrets_dir=_secrets_dir, **data)
         object.__setattr__(self, '_env_file', _env_file)
+        object.__setattr__(self, '_secrets_dir', _secrets_dir)
 
     # App identity
     app_name: str
-    log_dir: Path
+    log_dir: Path | None = None
 
     secrets_dir: Path | None = None
 
@@ -41,25 +47,36 @@ class JaylogSettings(BaseSettings):
     log_http_timeout: float = 5.0
     log_http_proxy: Optional[str] = None
 
+    # Console handler — desativar com JAYLOG_LOG_CONSOLE_ENABLED=false
+    log_console_enabled: bool = True
+
     # Screenshot (log_img field) — desativar com JAYLOG_LOG_SCREENSHOT_ENABLED=false
     log_screenshot_enabled: bool = False
 
     @field_validator("log_dir", mode="after")
     @classmethod
-    def validate_log_dir(cls, v: Path) -> Path:
-        if v.exists() and not v.is_dir():
+    def validate_log_dir(cls, v: Path | None) -> Path | None:
+        if v is not None and v.exists() and not v.is_dir():
             raise ValueError(f"JAYLOG_LOG_DIR '{v}' exists but is not a directory")
         return v
 
     @computed_field
     @property
-    def log_filename(self) -> Path:
+    def log_filename(self) -> Path | None:
+        if self.log_dir is None:
+            return None
         return Path(f"{self.app_name}_{_HOSTNAME}_{_HOST_USERNAME}.log")
 
     def reload_secrets(self):
         if self.secrets_dir:
             if not self.secrets_dir.exists() or not self.secrets_dir.is_dir:
                 raise ValueError('SECRETS_DIR is not valid directory')
+
+        elif self._secrets_dir != self.model_config.get('secrets_dir'):
+            raise SyntaxError(
+                'Não é possivel usar `reload_secrets` caso o valor de _secrets_dir foi sobrescrito'
+            )
+            
                 
         
         return JaylogSettings(

jaylog-0.2.1/src/jaylog/handlers/__init__.py

@@ -1,4 +0,0 @@
-from .file_handler import JaylogFileHandler
-from .http_handler import JaylogHttpHandler
-
-__all__ = ["JaylogFileHandler", "JaylogHttpHandler"]