jaylog 0.2.6__tar.gz → 0.2.8__tar.gz

{jaylog-0.2.6 → jaylog-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: jaylog
-Version: 0.2.6
+Version: 0.2.8
 Summary: Customized Python logging library with file rotation and HTTP forwarding
 Author: Gpocas
 Author-email: Gpocas <gpocas01@gmail.com>
@@ -39,7 +39,8 @@ As variáveis usam o prefixo `JAYLOG_`. Podem ser definidas no ambiente do siste
 | `JAYLOG_LOG_MAX_BYTES`          | NÃO          | `5242880` | Tamanho máximo do arquivo de log antes de rotacionar (bytes)            |
 | `JAYLOG_LOG_BACKUP_COUNT`       | NÃO          | `5`       | Quantidade de arquivos de backup mantidos após rotação                  |
 | `JAYLOG_LOG_RETENTION_DAYS`     | NÃO          | `7`       | Dias para manter arquivos de log antigos                                |
-| `JAYLOG_LOG_CONSOLE_ENABLED`    | NÃO          | `true`    | Habilita saída colorida no console (`true`/`false`)                     |
+| `JAYLOG_LOG_CONSOLE_ENABLED`    | NÃO          | `true`    | Habilita a saída de log no console (`true`/`false`)                     |
+| `JAYLOG_LOG_CONSOLE_COLOR`      | NÃO          | `null`    | Força (`true`) ou desliga (`false`) as cores no console. Se omitido, detecta automaticamente o suporte do terminal |
 | `JAYLOG_LOG_HTTP_TIMEOUT`       | NÃO          | `5.0`     | Timeout em segundos para o envio HTTP                                   |
 | `JAYLOG_LOG_HTTP_ENDPOINT`      | NÃO          | `null`    | URL do endpoint que receberá os logs                                    |
 | `JAYLOG_LOG_HTTP_API_KEY`       | NÃO          | `null`    | Chave de autenticação enviada no header `x-api-key`                     |
@@ -151,6 +152,33 @@ billing_logger.info("Fatura emitida")
 
 
 
+## Cores no console
+
+As cores são ligadas automaticamente quando o terminal suporta ANSI. A detecção cobre:
+
+- **Windows**: o modo *virtual terminal* do console é habilitado em tempo de execução, o que faz as cores funcionarem também no `cmd.exe`/PowerShell rodando no console legado (`conhost`) do Windows 10 — antes só saía colorido no Windows Terminal.
+- **Saída redirecionada** (`python main.py > saida.txt`, pipes, serviços sem console): as cores são desligadas, para o arquivo não ficar com lixo do tipo `←[32m`.
+- **Consoles antigos** que não suportam ANSI de jeito nenhum: o log sai em texto limpo, com o mesmo alinhamento.
+- As convenções `NO_COLOR` e `FORCE_COLOR` são respeitadas.
+
+Para forçar um comportamento, use `JAYLOG_LOG_CONSOLE_COLOR`:
+
+__*.env.logging*__
+```env
+JAYLOG_APP_NAME=meu-bot
+JAYLOG_LOG_CONSOLE_COLOR=false
+```
+
+Ou direto no código:
+
+```python
+configure(JaylogSettings(app_name="meu-bot", log_console_color=False))
+```
+
+> [!TIP]
+> `JAYLOG_LOG_CONSOLE_COLOR=true` força as cores mesmo com a saída redirecionada — útil quando o log é consumido por uma ferramenta que entende ANSI (ex: `... | less -R`).
+
+
 ## Alterando Caminho padrão do .env
 
 __*development.env*__
@@ -232,3 +260,28 @@ configure(JaylogSettings(_env_file='prodution.env').reload_secrets())
 logger = get_logger()
 
 logger.info("Mensagem de log")
+```
+
+`reload_secrets()` devolve uma **nova** instância preservando tudo que foi passado explicitamente no construtor, então dá para combinar configuração em código com secrets em disco:
+
+```python
+settings = JaylogSettings(app_name='meu-bot', log_level='DEBUG').reload_secrets()
+configure(settings)  # app_name e log_level mantidos; endpoint/api_key vêm dos secrets
+```
+
+> [!NOTE]
+> Valores passados no construtor têm prioridade sobre os secrets: um `log_http_api_key='...'` definido em código **não** é sobrescrito pelo arquivo em `secrets/`.
+
+## Reconfigurando sem repetir argumentos
+
+`reconfigure()` recria a configuração com os mesmos argumentos do construtor, aplicando apenas os overrides informados. Vale tanto para campos quanto para os argumentos de configuração do pydantic-settings (`_env_file`, `_secrets_dir`, `_case_sensitive`, `_env_prefix`, ...):
+
+```python
+base = JaylogSettings(app_name='meu-bot', log_level='DEBUG')
+
+homolog = base.reconfigure(_env_file='homolog.env')
+prod    = base.reconfigure(_env_file='producao.env', log_level='WARNING')
+# app_name preservado nos dois; só o que foi informado muda
+```
+
+É sobre esse mecanismo que o `reload_secrets()` é construído — ele é só um `reconfigure(_secrets_dir=...)` com validação.

{jaylog-0.2.6 → jaylog-0.2.8}/README.md

@@ -20,7 +20,8 @@ As variáveis usam o prefixo `JAYLOG_`. Podem ser definidas no ambiente do siste
 | `JAYLOG_LOG_MAX_BYTES`          | NÃO          | `5242880` | Tamanho máximo do arquivo de log antes de rotacionar (bytes)            |
 | `JAYLOG_LOG_BACKUP_COUNT`       | NÃO          | `5`       | Quantidade de arquivos de backup mantidos após rotação                  |
 | `JAYLOG_LOG_RETENTION_DAYS`     | NÃO          | `7`       | Dias para manter arquivos de log antigos                                |
-| `JAYLOG_LOG_CONSOLE_ENABLED`    | NÃO          | `true`    | Habilita saída colorida no console (`true`/`false`)                     |
+| `JAYLOG_LOG_CONSOLE_ENABLED`    | NÃO          | `true`    | Habilita a saída de log no console (`true`/`false`)                     |
+| `JAYLOG_LOG_CONSOLE_COLOR`      | NÃO          | `null`    | Força (`true`) ou desliga (`false`) as cores no console. Se omitido, detecta automaticamente o suporte do terminal |
 | `JAYLOG_LOG_HTTP_TIMEOUT`       | NÃO          | `5.0`     | Timeout em segundos para o envio HTTP                                   |
 | `JAYLOG_LOG_HTTP_ENDPOINT`      | NÃO          | `null`    | URL do endpoint que receberá os logs                                    |
 | `JAYLOG_LOG_HTTP_API_KEY`       | NÃO          | `null`    | Chave de autenticação enviada no header `x-api-key`                     |
@@ -132,6 +133,33 @@ billing_logger.info("Fatura emitida")
 
 
 
+## Cores no console
+
+As cores são ligadas automaticamente quando o terminal suporta ANSI. A detecção cobre:
+
+- **Windows**: o modo *virtual terminal* do console é habilitado em tempo de execução, o que faz as cores funcionarem também no `cmd.exe`/PowerShell rodando no console legado (`conhost`) do Windows 10 — antes só saía colorido no Windows Terminal.
+- **Saída redirecionada** (`python main.py > saida.txt`, pipes, serviços sem console): as cores são desligadas, para o arquivo não ficar com lixo do tipo `←[32m`.
+- **Consoles antigos** que não suportam ANSI de jeito nenhum: o log sai em texto limpo, com o mesmo alinhamento.
+- As convenções `NO_COLOR` e `FORCE_COLOR` são respeitadas.
+
+Para forçar um comportamento, use `JAYLOG_LOG_CONSOLE_COLOR`:
+
+__*.env.logging*__
+```env
+JAYLOG_APP_NAME=meu-bot
+JAYLOG_LOG_CONSOLE_COLOR=false
+```
+
+Ou direto no código:
+
+```python
+configure(JaylogSettings(app_name="meu-bot", log_console_color=False))
+```
+
+> [!TIP]
+> `JAYLOG_LOG_CONSOLE_COLOR=true` força as cores mesmo com a saída redirecionada — útil quando o log é consumido por uma ferramenta que entende ANSI (ex: `... | less -R`).
+
+
 ## Alterando Caminho padrão do .env
 
 __*development.env*__
@@ -213,3 +241,28 @@ configure(JaylogSettings(_env_file='prodution.env').reload_secrets())
 logger = get_logger()
 
 logger.info("Mensagem de log")
+```
+
+`reload_secrets()` devolve uma **nova** instância preservando tudo que foi passado explicitamente no construtor, então dá para combinar configuração em código com secrets em disco:
+
+```python
+settings = JaylogSettings(app_name='meu-bot', log_level='DEBUG').reload_secrets()
+configure(settings)  # app_name e log_level mantidos; endpoint/api_key vêm dos secrets
+```
+
+> [!NOTE]
+> Valores passados no construtor têm prioridade sobre os secrets: um `log_http_api_key='...'` definido em código **não** é sobrescrito pelo arquivo em `secrets/`.
+
+## Reconfigurando sem repetir argumentos
+
+`reconfigure()` recria a configuração com os mesmos argumentos do construtor, aplicando apenas os overrides informados. Vale tanto para campos quanto para os argumentos de configuração do pydantic-settings (`_env_file`, `_secrets_dir`, `_case_sensitive`, `_env_prefix`, ...):
+
+```python
+base = JaylogSettings(app_name='meu-bot', log_level='DEBUG')
+
+homolog = base.reconfigure(_env_file='homolog.env')
+prod    = base.reconfigure(_env_file='producao.env', log_level='WARNING')
+# app_name preservado nos dois; só o que foi informado muda
+```
+
+É sobre esse mecanismo que o `reload_secrets()` é construído — ele é só um `reconfigure(_secrets_dir=...)` com validação.

{jaylog-0.2.6 → jaylog-0.2.8}/pyproject.toml

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

jaylog-0.2.8/src/jaylog/colors.py

@@ -0,0 +1,137 @@
+"""
+Detecção e habilitação de cores ANSI no console.
+
+O console legado do Windows (``conhost.exe``, usado pelo `cmd.exe` do Windows 10
+quando não está hospedado no Windows Terminal) não interpreta sequências ANSI
+por padrão: o flag ``ENABLE_VIRTUAL_TERMINAL_PROCESSING`` existe desde o build
+10586, mas vem desligado. Por isso o mesmo log que sai colorido no Windows 11 +
+Windows Terminal aparece com lixo (``←[32m``) — ou sem cor — no Windows 10 + cmd.
+
+Este módulo resolve os dois lados do problema:
+
+* liga o modo VT no handle do console quando o Windows suporta;
+* quando não suporta (ou a saída foi redirecionada para arquivo/pipe),
+  desabilita as cores para que o log saia em texto limpo, sem escape codes.
+"""
+
+import os
+import sys
+from typing import IO
+
+GREEN = "\033[32m"
+BLUE = "\033[34m"
+PURPLE = "\033[35m"
+YELLOW = "\033[33m"
+RED = "\033[31m"
+RESET = "\033[0m"
+
+_ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
+_STD_HANDLE_BY_FILENO = {1: -11, 2: -12}  # STD_OUTPUT_HANDLE, STD_ERROR_HANDLE
+
+# handles já processados, para não chamar SetConsoleMode a cada logger criado
+_vt_cache: dict[int, bool] = {}
+
+
+def _env_flag(name: str) -> bool | None:
+    """Lê uma env var no padrão NO_COLOR/FORCE_COLOR: ausente/vazia = indefinido."""
+    value = os.environ.get(name)
+    if value is None or value.strip() == "":
+        return None
+    return value.strip().lower() not in {"0", "false", "no", "off"}
+
+
+def _enable_windows_vt(stream: IO[str]) -> bool:
+    """
+    Liga ``ENABLE_VIRTUAL_TERMINAL_PROCESSING`` no console do Windows.
+
+    Retorna ``True`` se o stream passa a interpretar ANSI (ou já interpretava).
+    """
+    try:
+        fileno = stream.fileno()
+    except (AttributeError, OSError, ValueError):
+        return False
+
+    handle_id = _STD_HANDLE_BY_FILENO.get(fileno)
+    if handle_id is None:
+        return False
+
+    if fileno in _vt_cache:
+        return _vt_cache[fileno]
+
+    enabled = False
+    try:
+        import ctypes
+        from ctypes import wintypes
+
+        kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+
+        kernel32.GetStdHandle.argtypes = [wintypes.DWORD]
+        kernel32.GetStdHandle.restype = wintypes.HANDLE
+        kernel32.GetConsoleMode.argtypes = [wintypes.HANDLE, ctypes.POINTER(wintypes.DWORD)]
+        kernel32.GetConsoleMode.restype = wintypes.BOOL
+        kernel32.SetConsoleMode.argtypes = [wintypes.HANDLE, wintypes.DWORD]
+        kernel32.SetConsoleMode.restype = wintypes.BOOL
+
+        handle = kernel32.GetStdHandle(wintypes.DWORD(handle_id & 0xFFFFFFFF))
+        invalid_handle = ctypes.c_void_p(-1).value
+        if not handle or handle == invalid_handle:
+            enabled = False
+        else:
+            mode = wintypes.DWORD()
+            if not kernel32.GetConsoleMode(handle, ctypes.byref(mode)):
+                # não é um console de verdade (pipe, arquivo, serviço sem console)
+                enabled = False
+            elif mode.value & _ENABLE_VIRTUAL_TERMINAL_PROCESSING:
+                enabled = True
+            else:
+                enabled = bool(
+                    kernel32.SetConsoleMode(
+                        handle, mode.value | _ENABLE_VIRTUAL_TERMINAL_PROCESSING
+                    )
+                )
+    except Exception:
+        # build antigo do Windows, ctypes indisponível, etc.
+        enabled = False
+
+    _vt_cache[fileno] = enabled
+    return enabled
+
+
+def supports_color(stream: IO[str] | None = None, force: bool | None = None) -> bool:
+    """
+    Decide se ``stream`` deve receber sequências ANSI.
+
+    ``force=True``/``False`` sobrepõe a detecção automática (vem de
+    ``JAYLOG_LOG_CONSOLE_COLOR``); mesmo com ``force=True`` o modo VT do Windows
+    ainda é ligado, senão o "forçar" só produziria lixo na tela.
+
+    Sem override, respeita as convenções ``NO_COLOR`` e ``FORCE_COLOR``, exige
+    um TTY e, no Windows, exige que o modo VT tenha sido habilitado com sucesso.
+    """
+    stream = stream if stream is not None else sys.stdout
+
+    if sys.platform == "win32":
+        vt_enabled = _enable_windows_vt(stream)
+    else:
+        vt_enabled = True
+
+    if force is not None:
+        return force
+
+    if _env_flag("NO_COLOR"):
+        return False
+
+    forced_by_env = _env_flag("FORCE_COLOR")
+    if forced_by_env is not None:
+        return forced_by_env
+
+    try:
+        if not stream.isatty():
+            return False
+    except (AttributeError, ValueError):
+        return False
+
+    if os.environ.get("TERM", "").strip().lower() in {"dumb", "unknown"}:
+        return False
+
+    return vt_enabled

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

@@ -0,0 +1,71 @@
+import logging
+import sys
+from datetime import datetime
+from typing import IO
+
+from jaylog.colors import BLUE, GREEN, PURPLE, RED, RESET, YELLOW, supports_color
+from jaylog.formatters import build_log_entry_dict
+
+_LEVEL_COLORS = {
+    "DEBUG": PURPLE,
+    "INFO": BLUE,
+    "WARNING": YELLOW,
+}
+
+
+def _level_color(level: str) -> str:
+    return _LEVEL_COLORS.get(level, RED)
+
+
+class ConsoleFormatter(logging.Formatter):
+    """
+    Formata o log para o console.
+
+    Quando ``use_color`` é falso (console legado do Windows sem suporte a ANSI,
+    saída redirecionada para arquivo/pipe, ``NO_COLOR`` etc.) a mesma linha é
+    emitida sem nenhum escape code, em vez de sujar a tela com ``←[32m``.
+    """
+
+    def __init__(self, show_service: bool = True, use_color: bool = True) -> None:
+        super().__init__()
+        self.show_service = show_service
+        self.use_color = use_color
+
+    def _paint(self, text: str, color: str) -> str:
+        if not self.use_color:
+            return text
+        return f"{color}{text}{RESET}"
+
+    def format(self, record: logging.LogRecord) -> str:
+        entry = build_log_entry_dict(record)
+        log_timestamp = datetime.fromisoformat(entry["log_timestamp"]).astimezone().strftime("%d/%m/%Y %X")
+        log_level = f'[{entry["log_level"]}]'
+        colored_timestamp = self._paint(log_timestamp, GREEN)
+        colored_level = self._paint(log_level.ljust(11), _level_color(entry['log_level']))
+        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):
+    """
+    Handler de console.
+
+    ``color=None`` (padrão) detecta automaticamente o suporte a ANSI do stream —
+    ligando o modo VT do console do Windows quando disponível. ``True``/``False``
+    forçam o comportamento.
+    """
+
+    def __init__(
+        self,
+        show_service: bool = True,
+        color: bool | None = None,
+        stream: IO[str] | None = None,
+    ) -> None:
+        stream = stream if stream is not None else sys.stdout
+        super().__init__(stream=stream)
+        self.setFormatter(
+            ConsoleFormatter(
+                show_service=show_service,
+                use_color=supports_color(stream, force=color),
+            )
+        )

{jaylog-0.2.6 → jaylog-0.2.8}/src/jaylog/logger.py

@@ -137,7 +137,10 @@ def _build_logger(name: str | None) -> logging.Logger:
         downstream.append(file_handler)
 
     if settings.log_console_enabled:
-        console_handler = JaylogConsoleHandler(show_service=show_service)
+        console_handler = JaylogConsoleHandler(
+            show_service=show_service,
+            color=settings.log_console_color,
+        )
         console_handler.setLevel(settings.log_level)
         downstream.append(console_handler)
 

jaylog-0.2.8/src/jaylog/settings.py

@@ -0,0 +1,154 @@
+from pathlib import Path
+
+from pydantic import computed_field, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from jaylog.formatters import _HOST_USERNAME, _HOSTNAME
+
+# Compat: na assinatura anterior de `JaylogSettings.__init__` estes eram os dois
+# primeiros parâmetros posicionais. Pode ser removido quando não houver mais
+# chamadas posicionais em uso.
+_LEGACY_POSITIONAL_ARGS = ('_env_file', '_secrets_dir')
+
+
+class JaylogSettings(BaseSettings):
+    model_config = SettingsConfigDict(
+        env_prefix="JAYLOG_",
+        env_file=('.env.logging', '.env'),
+        env_file_encoding='utf-8',
+        secrets_dir='secrets',
+        extra="ignore"
+    )
+
+    # Tudo que foi recebido no construtor: os campos normais (`app_name=...`) e
+    # os argumentos de configuração do pydantic-settings (`_env_file`,
+    # `_secrets_dir`, `_case_sensitive`, ... — são 28 e variam por versão).
+    # Guardado inteiro para que `reconfigure()` recrie a instância sem perder
+    # nada, sem precisar conhecer os nomes um a um.
+    _init_values: dict = {}
+
+    def __init__(self, *args, **values) -> None:
+        if len(args) > len(_LEGACY_POSITIONAL_ARGS):
+            raise TypeError(
+                f'{type(self).__name__}() aceita no máximo '
+                f'{len(_LEGACY_POSITIONAL_ARGS)} argumentos posicionais'
+            )
+        for name, value in zip(_LEGACY_POSITIONAL_ARGS, args):
+            if name in values:
+                raise TypeError(
+                    f'{type(self).__name__}() recebeu dois valores para {name!r}'
+                )
+            values[name] = value
+
+        super().__init__(**values)
+        object.__setattr__(self, '_init_values', dict(values))
+
+    def _settings_arg(self, name: str):
+        """
+        Valor efetivo de um argumento ``_``-prefixado do pydantic-settings:
+        o que foi passado no construtor ou, na ausência dele, o que está no
+        ``model_config`` (``_env_file`` -> ``env_file``).
+        """
+        if name in self._init_values:
+            return self._init_values[name]
+        return self.model_config.get(name.lstrip('_'))
+
+    @property
+    def _env_file(self):
+        return self._settings_arg('_env_file')
+
+    @property
+    def _secrets_dir(self):
+        return self._settings_arg('_secrets_dir')
+
+    def reconfigure(self, **overrides) -> "JaylogSettings":
+        """
+        Recria a instância com os mesmos argumentos do construtor, aplicando
+        ``overrides`` por cima.
+
+        Serve para reler a configuração mudando um detalhe sem repetir (nem
+        perder) o resto::
+
+            settings = JaylogSettings(app_name='meu-bot', log_level='DEBUG')
+            outra = settings.reconfigure(_env_file='producao.env')
+            # app_name e log_level preservados, .env trocado
+
+        Vale para qualquer argumento aceito por ``BaseSettings`` — inclusive os
+        que esta classe não conhece explicitamente.
+        """
+        return type(self)(**{**self._init_values, **overrides})
+
+    # App identity
+    app_name: str
+    log_dir: Path | None = None
+
+    secrets_dir: Path | None = None
+
+    # File handler
+    log_level: str = "INFO"
+    log_max_bytes: int = 5 * 1024 * 1024  # 5 MB
+    log_backup_count: int = 5
+    log_retention_days: int = 7
+
+    # HTTP handler
+    log_http_endpoint: str | None = None
+    log_http_api_key: str | None = None
+    log_http_timeout: float = 5.0
+    log_http_proxy: str | None = None
+
+    # Console handler — desativar com JAYLOG_LOG_CONSOLE_ENABLED=false
+    log_console_enabled: bool = True
+
+    # Cores ANSI no console. `None` (padrão) detecta o suporte do terminal;
+    # true/false forçam. Ver JAYLOG_LOG_CONSOLE_COLOR no README.
+    log_console_color: bool | None = None
+
+    # 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 | 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 | None:
+        if self.log_dir is None:
+            return None
+        return Path(f"{self.app_name}_{_HOSTNAME}_{_HOST_USERNAME}.log")
+
+    def reload_secrets(self) -> "JaylogSettings":
+        """
+        Recarrega a configuração usando o diretório apontado por
+        ``JAYLOG_SECRETS_DIR``.
+
+        Necessário porque o diretório de secrets só é conhecido depois que o
+        ``.env`` é lido — ou seja, tarde demais para o pydantic-settings usá-lo
+        como fonte na primeira instanciação.
+
+        Retorna uma **nova** instância preservando tudo que foi passado
+        explicitamente no construtor, para que isto continue funcionando::
+
+            JaylogSettings(app_name='meu-bot').reload_secrets()
+
+        Os valores explícitos continuam tendo prioridade sobre os secrets: um
+        ``log_http_api_key`` passado no código não é sobrescrito pelo arquivo.
+        """
+        if self.secrets_dir is not None:
+            if not self.secrets_dir.is_dir():
+                raise ValueError(
+                    f"JAYLOG_SECRETS_DIR '{self.secrets_dir}' não é um diretório válido"
+                )
+            return self.reconfigure(_secrets_dir=self.secrets_dir)
+
+        if '_secrets_dir' in self._init_values:
+            raise SyntaxError(
+                'Não é possivel usar `reload_secrets` caso o valor de _secrets_dir foi sobrescrito'
+            )
+
+        # nenhum JAYLOG_SECRETS_DIR definido: relê mantendo o diretório atual,
+        # em vez de desligar a leitura de secrets
+        return self.reconfigure()

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

@@ -1,43 +0,0 @@
-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"]).astimezone().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.6/src/jaylog/settings.py

@@ -1,84 +0,0 @@
-from pathlib import Path
-from typing import Optional
-
-from pydantic import computed_field, field_validator
-from pydantic_settings import BaseSettings, SettingsConfigDict
-
-from jaylog.formatters import _HOSTNAME, _HOST_USERNAME
-
-
-class JaylogSettings(BaseSettings):
-    model_config = SettingsConfigDict(
-        env_prefix="JAYLOG_",
-        env_file=('.env.logging', '.env'),
-        env_file_encoding='utf-8',
-        secrets_dir='secrets',
-        extra="ignore"
-    )
-
-    _env_file: str | tuple | None = None
-    _secrets_dir: str | None = None
-
-    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 | None = None
-
-    secrets_dir: Path | None = None
-
-    # File handler
-    log_level: str = "INFO"
-    log_max_bytes: int = 5 * 1024 * 1024  # 5 MB
-    log_backup_count: int = 5
-    log_retention_days: int = 7
-
-    # HTTP handler
-    log_http_endpoint: Optional[str] = None
-    log_http_api_key: Optional[str] = None
-    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 | 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 | 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(
-            _env_file=self._env_file, 
-            _secrets_dir=self.secrets_dir)