jaylog 0.3.2__tar.gz → 0.3.3__tar.gz

{jaylog-0.3.2 → jaylog-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: jaylog
-Version: 0.3.2
+Version: 0.3.3
 Summary: Customized Python logging library with file rotation and HTTP forwarding
 Author: Gpocas
 Author-email: Gpocas <gpocas01@gmail.com>
@@ -48,3 +48,15 @@ logger = get_logger()
 
 logger.info("Olá, jaylog!")
 ```
+
+## Certificado TLS (HTTPS)
+
+`JAYLOG_LOG_HTTP_VERIFY` controla a verificação do certificado em todos os envios HTTP (logs, host, métricas, heartbeat e agendas):
+
+| Valor | Efeito |
+|---|---|
+| `true` (`1`, `yes`, `on`) | Verifica com o bundle padrão do `requests` (`certifi`, ou `REQUESTS_CA_BUNDLE` se definida) |
+| `/caminho/corp-ca.pem` | Verifica com esse CA bundle — use para proxy corporativo com inspeção TLS. O caminho precisa existir: senão `JaylogSettings()` falha na inicialização |
+| `false` (`0`, `no`, `off`) | Não verifica (inseguro); o jaylog avisa no stderr |
+
+> **0.3.x:** o padrão ainda é `false` por compatibilidade e passa a ser `true` na **0.4.0**. Para antecipar, defina `JAYLOG_LOG_HTTP_VERIFY=true` ou o caminho do bundle corporativo.

jaylog-0.3.3/README.md

@@ -0,0 +1,42 @@
+# jaylog
+
+Biblioteca de logging para Python com rotação de arquivos, saída colorida no console, envio HTTP para um endpoint remoto e registro automático do ambiente de execução (host reporting).
+
+📖 **Documentação completa:** https://gpocas.github.io/jaylog-book
+
+## Instalação
+
+```bash
+pip install -U --no-cache-dir jaylog
+```
+
+## Uso rápido
+
+__*.env.logging*__
+```env
+JAYLOG_APP_NAME=meu-bot
+JAYLOG_LOG_DIR=C:\logs
+```
+
+__*main.py*__
+```python
+from jaylog import JaylogSettings, configure, get_logger
+
+configure(JaylogSettings())
+
+logger = get_logger()
+
+logger.info("Olá, jaylog!")
+```
+
+## Certificado TLS (HTTPS)
+
+`JAYLOG_LOG_HTTP_VERIFY` controla a verificação do certificado em todos os envios HTTP (logs, host, métricas, heartbeat e agendas):
+
+| Valor | Efeito |
+|---|---|
+| `true` (`1`, `yes`, `on`) | Verifica com o bundle padrão do `requests` (`certifi`, ou `REQUESTS_CA_BUNDLE` se definida) |
+| `/caminho/corp-ca.pem` | Verifica com esse CA bundle — use para proxy corporativo com inspeção TLS. O caminho precisa existir: senão `JaylogSettings()` falha na inicialização |
+| `false` (`0`, `no`, `off`) | Não verifica (inseguro); o jaylog avisa no stderr |
+
+> **0.3.x:** o padrão ainda é `false` por compatibilidade e passa a ser `true` na **0.4.0**. Para antecipar, defina `JAYLOG_LOG_HTTP_VERIFY=true` ou o caminho do bundle corporativo.

jaylog-0.3.3/pyproject.toml

@@ -0,0 +1,58 @@
+[project]
+name = "jaylog"
+version = "0.3.3"
+description = "Customized Python logging library with file rotation and HTTP forwarding"
+readme = "README.md"
+classifiers = [
+    "Topic :: Software Development :: Build Tools",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Natural Language :: Portuguese (Brazilian)",
+    "Development Status :: 5 - Production/Stable",
+]
+requires-python = ">=3.10,<3.14"
+dependencies = [
+    "pydantic>=2.0,<3.0",
+    "pydantic-settings>=2.0,<3.0",
+    "requests>=2.32,<3.0",
+    "pillow>=11.0,<13.0",
+    "psutil>=5.9.6,<8",
+]
+
+[[project.authors]]
+name = "Gpocas"
+email = "gpocas01@gmail.com"
+
+[project.urls]
+repository = "https://github.com/Gpocas/jaylog"
+"Bug Tracker" = "https://github.com/Gpocas/jaylog/issues"
+
+[dependency-groups]
+dev = [
+    "pytest>=8,<9",
+    "ruff>=0.6",
+]
+
+[build-system]
+requires = ["uv_build>=0.10.8,<0.11.0"]
+build-backend = "uv_build"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-q"
+
+[tool.ruff]
+line-length = 100
+src = [
+    "src",
+    "tests",
+]
+
+[tool.ruff.lint]
+select = [
+    "E",
+    "F",
+    "I",
+    "UP",
+    "B",
+]
+ignore = ["E501"]

jaylog-0.3.2/pyproject.toml → jaylog-0.3.3/pyproject.toml.orig

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

jaylog-0.3.3/src/jaylog/_http.py

@@ -0,0 +1,139 @@
+"""
+Transporte HTTP compartilhado pelos clientes do jaylog (log, host, métricas,
+heartbeat e agendas): verificação TLS, proxy, headers de protocolo e o aviso do
+urllib3 sobre requisições não verificadas.
+
+Tudo que diz respeito a ``verify`` mora aqui para que a troca do padrão (0.4.0)
+aconteça num único lugar.
+"""
+
+import re
+import threading
+import warnings
+from pathlib import Path
+from urllib.parse import urlsplit
+
+import requests
+import urllib3
+
+from jaylog._version import PROTOCOL_VERSION, __version__
+from jaylog.runtime import RUN_ID
+
+#: ``False`` na 0.3.x por compatibilidade (ver ``JaylogSettings.log_http_verify``);
+#: passa a ser ``True`` na 0.4.0. É o padrão de *todos* os clientes HTTP.
+DEFAULT_VERIFY: bool = False
+
+# Os mesmos conjuntos que o pydantic aceita para ``bool``.
+_TRUE_VALUES = frozenset({"1", "on", "t", "true", "y", "yes"})
+_FALSE_VALUES = frozenset({"0", "off", "f", "false", "n", "no"})
+
+
+def parse_verify(value: object) -> bool | str:
+    """
+    Normaliza o valor de ``log_http_verify``.
+
+    Vindo de variável de ambiente tudo é texto, e o ``requests`` trata qualquer
+    ``str`` como caminho de CA bundle: ``"true"`` virava
+    ``OSError: invalid path: true`` em toda requisição. Aqui os textos booleanos
+    viram ``bool`` e o resto precisa ser um caminho existente (arquivo PEM ou
+    diretório preparado com ``c_rehash``), para que o erro apareça na
+    configuração e não em silêncio no envio.
+    """
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, Path):
+        value = str(value)
+    if not isinstance(value, str):
+        raise ValueError(
+            f"log_http_verify deve ser true, false ou o caminho de um CA bundle; "
+            f"recebido {type(value).__name__}"
+        )
+
+    text = value.strip()
+    if text.lower() in _TRUE_VALUES:
+        return True
+    if text.lower() in _FALSE_VALUES:
+        return False
+    if not text:
+        raise ValueError("log_http_verify vazio; use true, false ou o caminho de um CA bundle")
+
+    path = Path(text).expanduser()
+    if not path.exists():
+        raise ValueError(f"log_http_verify: CA bundle não encontrado: {path}")
+    return str(path)
+
+
+def jaylog_headers(api_key: str) -> dict[str, str]:
+    """Headers de autenticação e protocolo enviados em todo POST do jaylog."""
+    return {
+        "x-api-key": api_key,
+        "x-jaylog-version": __version__,
+        "x-jaylog-protocol": str(PROTOCOL_VERSION),
+        "x-jaylog-run-id": RUN_ID,
+    }
+
+
+def proxies_for(proxy: str | None) -> dict[str, str] | None:
+    """Mapa de proxies do ``requests`` para um único proxy (ou ``None``)."""
+    return {"http": proxy, "https": proxy} if proxy else None
+
+
+def prepare_session(api_key: str, proxy: str | None = None, session=None):
+    """
+    Sessão com os headers do jaylog e o proxy já aplicados.
+
+    ``verify`` **não** é fixado na sessão de propósito: com ``session.verify``
+    o ``requests`` deixa ``REQUESTS_CA_BUNDLE`` sobrepor um ``False`` explícito.
+    Os clientes passam ``verify=`` em cada ``post()``.
+    """
+    if session is None:
+        session = requests.Session()
+    session.headers.update(jaylog_headers(api_key))
+    proxies = proxies_for(proxy)
+    if proxies:
+        session.proxies.update(proxies)
+    return session
+
+
+_silenced_hosts: set[str] = set()
+_silence_lock = threading.Lock()
+
+
+def silence_insecure_warning(endpoint: str | None, verify: bool | str) -> None:
+    """
+    Silencia o ``InsecureRequestWarning`` do urllib3 só para o host do endpoint,
+    e só quando a verificação está desligada.
+
+    Substitui o ``warnings.catch_warnings()`` que envolvia cada POST: ele troca
+    ``warnings.filters`` do processo inteiro e não é thread-safe — com cinco
+    threads do jaylog fazendo isso ao mesmo tempo, os filtros da aplicação
+    podiam ser perdidos ou ficar com o "ignore" vazado. Aqui é um filtro
+    permanente, instalado uma vez, restrito à mensagem do host do jaylog: o
+    aviso continua valendo para qualquer outro destino da aplicação.
+
+    Chamado na construção dos clientes, não no envio.
+    """
+    if verify is not False or not endpoint:
+        return
+    host = urlsplit(endpoint).hostname
+    if not host:
+        return
+    with _silence_lock:
+        if host in _silenced_hosts:
+            return
+        _silenced_hosts.add(host)
+        warnings.filterwarnings(
+            "ignore",
+            message=re.escape(f"Unverified HTTPS request is being made to host '{host}'"),
+            category=urllib3.exceptions.InsecureRequestWarning,
+        )
+
+
+__all__ = [
+    "DEFAULT_VERIFY",
+    "jaylog_headers",
+    "parse_verify",
+    "prepare_session",
+    "proxies_for",
+    "silence_insecure_warning",
+]

{jaylog-0.3.2 → jaylog-0.3.3}/src/jaylog/handlers/http_handler.py

@@ -1,15 +1,10 @@
 import json
 import logging
-import warnings
 
-import requests
-import urllib3
-
-from jaylog._version import PROTOCOL_VERSION, __version__
+from jaylog._http import DEFAULT_VERIFY, prepare_session, silence_insecure_warning
 from jaylog.context import record_entry, record_screenshot
 from jaylog.diagnostics import emit as debug
 from jaylog.host import reporter
-from jaylog.runtime import RUN_ID
 
 #: O backend sinaliza por header que não conhece este `run_id` — normalmente
 #: porque o log correu na frente do POST de host. Ver `reporter.request_resend`.
@@ -52,18 +47,14 @@ class JaylogHttpHandler(logging.Handler):
         api_key: str,
         timeout: float = 5.0,
         proxy: str | None = None,
-        verify: bool | str = False,
+        verify: bool | str = DEFAULT_VERIFY,
     ) -> None:
         super().__init__()
         self.endpoint = endpoint
         self.timeout = timeout
         self.verify = verify
-        self.proxy = {"http": proxy, "https": proxy} if proxy else None
-        self._session = requests.Session()
-        self._session.headers["x-api-key"] = api_key
-        self._session.headers["x-jaylog-version"] = __version__
-        self._session.headers["x-jaylog-protocol"] = str(PROTOCOL_VERSION)
-        self._session.headers["x-jaylog-run-id"] = RUN_ID
+        self._session = prepare_session(api_key, proxy)
+        silence_insecure_warning(endpoint, verify)
 
     def mapLogRecord(self, record: logging.LogRecord) -> dict:
         # Único ponto do programa que pede screenshot: é o único com para onde
@@ -75,8 +66,6 @@ class JaylogHttpHandler(logging.Handler):
     def emit(self, record: logging.LogRecord) -> None:
         try:
             diagnostic_record = bool(getattr(record, "jaylog_diagnostic", False))
-            if self.proxy:
-                self._session.proxies.update(self.proxy)
 
             fields = self.mapLogRecord(record)
             if not diagnostic_record:
@@ -86,14 +75,12 @@ class JaylogHttpHandler(logging.Handler):
                     f"serviço={record.name}; nível={record.levelname}; "
                     f"captura_anexada={fields.get('log_img') is not None}",
                 )
-            with warnings.catch_warnings():
-                warnings.simplefilter("ignore", urllib3.exceptions.InsecureRequestWarning)
-                response = self._session.post(
-                    self.endpoint,
-                    files=_to_multipart(fields),
-                    timeout=self.timeout,
-                    verify=self.verify,
-                )
+            response = self._session.post(
+                self.endpoint,
+                files=_to_multipart(fields),
+                timeout=self.timeout,
+                verify=self.verify,
+            )
             if not diagnostic_record:
                 debug(
                     "http",

{jaylog-0.3.2 → jaylog-0.3.3}/src/jaylog/host/heartbeat_reporter.py

@@ -19,13 +19,11 @@ Sem buffer e sem backoff próprio: o ciclo já é de 60 s, e o único beat que i
 import sys
 import threading
 import time
-import warnings
 from dataclasses import dataclass
 
 import requests
-import urllib3
 
-from jaylog._version import PROTOCOL_VERSION, __version__
+from jaylog._http import jaylog_headers, proxies_for, silence_insecure_warning
 from jaylog.diagnostics import emit as debug
 from jaylog.host import reporter as host_reporter
 from jaylog.runtime import RUN_ID
@@ -48,8 +46,9 @@ class HeartbeatTarget:
     interval: float = _DEFAULT_INTERVAL
     timeout: float = 5.0
     proxy: str | None = None
-    #: seguro por padrão; quem decide o valor real é o `log_http_verify` do item,
-    #: passado por `configure()` (hoje `False` por compatibilidade, `True` na 0.4.0)
+    #: seguro por padrão: o valor real vem do `log_http_verify` do item, sempre
+    #: passado por `configure()`. Não usa `DEFAULT_VERIFY` (False na 0.3.x) para
+    #: não rebaixar um padrão que já era seguro.
     verify: bool | str = True
 
 
@@ -104,6 +103,8 @@ class JaylogHeartbeatReporter:
 
     def register(self, targets: list[HeartbeatTarget]) -> None:
         """Substitui os alvos e descarta todo o estado anterior."""
+        for target in targets:
+            silence_insecure_warning(target.endpoint, target.verify)
         with self._lock:
             self._generation += 1
             self._targets = {t.service: t for t in targets}
@@ -241,17 +242,13 @@ class JaylogHeartbeatReporter:
             self._session = requests.Session()
         kwargs: dict = {
             "json": {"run_id": RUN_ID, "service": target.service},
-            "headers": {
-                "x-api-key": target.api_key,
-                "x-jaylog-version": __version__,
-                "x-jaylog-protocol": str(PROTOCOL_VERSION),
-                "x-jaylog-run-id": RUN_ID,
-            },
+            "headers": jaylog_headers(target.api_key),
             "timeout": timeout,
             "verify": target.verify,
         }
-        if target.proxy:
-            kwargs["proxies"] = {"http": target.proxy, "https": target.proxy}
+        proxies = proxies_for(target.proxy)
+        if proxies:
+            kwargs["proxies"] = proxies
 
         try:
             debug(
@@ -259,9 +256,7 @@ class JaylogHeartbeatReporter:
                 f"requisição HTTP iniciada; método=POST; endpoint={target.endpoint}; "
                 f"serviço={target.service}; timeout={timeout:g}s",
             )
-            with warnings.catch_warnings():
-                warnings.simplefilter("ignore", urllib3.exceptions.InsecureRequestWarning)
-                response = self._session.post(target.endpoint, **kwargs)
+            response = self._session.post(target.endpoint, **kwargs)
         except Exception as exc:
             debug(
                 "heartbeat",

{jaylog-0.3.2 → jaylog-0.3.3}/src/jaylog/host/metrics_reporter.py

@@ -15,13 +15,9 @@ amostras no buffer para o próximo ciclo; o buffer é limitado a 1 h.
 import sys
 import threading
 import time
-import warnings
 from collections import deque
 
-import requests
-import urllib3
-
-from jaylog._version import PROTOCOL_VERSION, __version__
+from jaylog._http import DEFAULT_VERIFY, prepare_session, silence_insecure_warning
 from jaylog.diagnostics import emit as debug
 from jaylog.host import reporter as host_reporter
 from jaylog.runtime import RUN_ID
@@ -67,7 +63,7 @@ class JaylogMetricsReporter:
         interval: float = 60.0,
         timeout: float = 5.0,
         proxy: str | None = None,
-        verify: bool | str = False,
+        verify: bool | str = DEFAULT_VERIFY,
         session=None,
         sampler=None,
         clock=time.time,
@@ -93,13 +89,8 @@ class JaylogMetricsReporter:
         self._stop = threading.Event()
         self._thread: threading.Thread | None = None
 
-        self._session = session if session is not None else requests.Session()
-        self._session.headers["x-api-key"] = api_key
-        self._session.headers["x-jaylog-version"] = __version__
-        self._session.headers["x-jaylog-protocol"] = str(PROTOCOL_VERSION)
-        self._session.headers["x-jaylog-run-id"] = RUN_ID
-        if proxy:
-            self._session.proxies.update({"http": proxy, "https": proxy})
+        self._session = prepare_session(api_key, proxy, session)
+        silence_insecure_warning(endpoint, verify)
 
     # ------------------------------------------------------------------
     # ciclo de vida
@@ -199,14 +190,12 @@ class JaylogMetricsReporter:
                 f"requisição HTTP iniciada; método=POST; endpoint={self.endpoint}; "
                 f"serviço={self.service}; amostras={len(batch)}; timeout={effective_timeout:g}s",
             )
-            with warnings.catch_warnings():
-                warnings.simplefilter("ignore", urllib3.exceptions.InsecureRequestWarning)
-                response = self._session.post(
-                    self.endpoint,
-                    json=body,
-                    timeout=effective_timeout,
-                    verify=self.verify,
-                )
+            response = self._session.post(
+                self.endpoint,
+                json=body,
+                timeout=effective_timeout,
+                verify=self.verify,
+            )
         except Exception as exc:
             debug(
                 "metrics",

{jaylog-0.3.2 → jaylog-0.3.3}/src/jaylog/host/reporter.py

@@ -20,15 +20,10 @@ precisar ser dono do reporter.
 import sys
 import threading
 import time
-import warnings
 
-import requests
-import urllib3
-
-from jaylog._version import PROTOCOL_VERSION, __version__
+from jaylog._http import DEFAULT_VERIFY, prepare_session, silence_insecure_warning
 from jaylog.diagnostics import emit
 from jaylog.host.payload import build_host_payload
-from jaylog.runtime import RUN_ID
 
 #: Pausas entre tentativas: ~10 min de insistência no total. Depois disso o
 #: reporter dorme num Event até que alguém peça reenvio — continuar batendo
@@ -69,7 +64,7 @@ class JaylogHostReporter:
         *,
         timeout: float = 10.0,
         proxy: str | None = None,
-        verify: bool | str = False,
+        verify: bool | str = DEFAULT_VERIFY,
         session=None,
         backoff=DEFAULT_BACKOFF,
         payload_factory=None,
@@ -102,13 +97,8 @@ class JaylogHostReporter:
         # portanto 0.0 não representa com segurança “nunca reenviado”.
         self._last_resend: float | None = None
 
-        self._session = session if session is not None else requests.Session()
-        self._session.headers["x-api-key"] = api_key
-        self._session.headers["x-jaylog-version"] = __version__
-        self._session.headers["x-jaylog-protocol"] = str(PROTOCOL_VERSION)
-        self._session.headers["x-jaylog-run-id"] = RUN_ID
-        if proxy:
-            self._session.proxies.update({"http": proxy, "https": proxy})
+        self._session = prepare_session(api_key, proxy, session)
+        silence_insecure_warning(endpoint, verify)
 
     # ------------------------------------------------------------------
     # ciclo de vida
@@ -218,14 +208,12 @@ class JaylogHostReporter:
                 f"recurso={self.noun}; serviço={self.service}",
                 self.label,
             )
-            with warnings.catch_warnings():
-                warnings.simplefilter("ignore", urllib3.exceptions.InsecureRequestWarning)
-                response = self._session.post(
-                    self.endpoint,
-                    json=payload,
-                    timeout=self.timeout,
-                    verify=self.verify,
-                )
+            response = self._session.post(
+                self.endpoint,
+                json=payload,
+                timeout=self.timeout,
+                verify=self.verify,
+            )
         except Exception as exc:
             _debug(
                 f"requisição HTTP falhou; endpoint={self.endpoint}; "

{jaylog-0.3.2 → jaylog-0.3.3}/src/jaylog/logger.py

@@ -127,17 +127,37 @@ def _warn_insecure_transport(items: list[JaylogSettings]) -> None:
     if _insecure_transport_warned:
         return
     for item in items:
-        endpoint = item.log_http_endpoint or ""
-        if endpoint.startswith("https://") and item.log_http_verify is False:
-            _insecure_transport_warned = True
-            print(
+        if item.log_http_verify is not False or not _has_https_endpoint(item):
+            continue
+        _insecure_transport_warned = True
+        if "log_http_verify" in item.model_fields_set:
+            message = (
+                "[jaylog] verificação do certificado TLS DESATIVADA por "
+                "configuração (JAYLOG_LOG_HTTP_VERIFY=false). Os envios ficam "
+                "expostos a interceptação; prefira "
+                "JAYLOG_LOG_HTTP_VERIFY=/caminho/ca-bundle.pem."
+            )
+        else:
+            message = (
                 "[jaylog] o certificado TLS do endpoint de log NÃO está sendo "
                 "verificado (padrão atual). Defina "
                 "JAYLOG_LOG_HTTP_VERIFY=/caminho/ca-bundle.pem (ou =true) para "
-                "habilitar. O padrão passa a ser 'true' na 0.4.0.",
-                file=sys.stderr,
+                "habilitar. O padrão passa a ser 'true' na 0.4.0."
             )
-            return
+        print(message, file=sys.stderr)
+        return
+
+
+def _has_https_endpoint(item: JaylogSettings) -> bool:
+    """Algum POST deste item (log, host, métricas, heartbeat, agendas) usa HTTPS?"""
+    endpoints = (
+        item.log_http_endpoint,
+        item.effective_host_endpoint,
+        item.effective_host_metrics_endpoint,
+        item.effective_host_heartbeat_endpoint,
+        item.effective_host_schedule_endpoint,
+    )
+    return any((endpoint or "").lower().startswith("https://") for endpoint in endpoints)
 
 
 def _host_payload_factory(settings: JaylogSettings):

{jaylog-0.3.2 → jaylog-0.3.3}/src/jaylog/settings.py

@@ -3,6 +3,7 @@ from pathlib import Path
 from pydantic import computed_field, field_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
+from jaylog._http import DEFAULT_VERIFY, parse_verify
 from jaylog.diagnostics import parse_handlers
 from jaylog.host import identity
 
@@ -109,16 +110,22 @@ class JaylogSettings(BaseSettings):
     # Screenshot (log_img field) — desativar com JAYLOG_LOG_SCREENSHOT_ENABLED=false
     log_screenshot_enabled: bool = False
 
-    # Verificação do certificado TLS no envio HTTP. Aceita bool ou o caminho de
-    # um CA bundle (`requests` entende os dois).
+    # Verificação do certificado TLS no envio HTTP: `true`, `false` ou o caminho
+    # de um CA bundle. Vale para todos os POSTs (log, host, métricas, heartbeat e
+    # agendas). Ver `jaylog._http.parse_verify` para os valores aceitos.
     #
     # O padrão continua `False` na 0.3.x: virar `True` derrubaria, no dia do
     # upgrade, todo bot atrás de proxy corporativo com inspeção TLS — uma
     # biblioteca de log não pode quebrar a aplicação que ela observa. É dívida
-    # consciente, com data: o padrão vira `True` na 0.4.0. Quem já tem o bundle
-    # corporativo pode antecipar com
-    # `JAYLOG_LOG_HTTP_VERIFY=/caminho/corp-ca.pem`.
-    log_http_verify: bool | str = False
+    # consciente, com data: o padrão vira `True` na 0.4.0
+    # (`jaylog._http.DEFAULT_VERIFY`). Quem já tem o bundle corporativo pode
+    # antecipar com `JAYLOG_LOG_HTTP_VERIFY=/caminho/corp-ca.pem`.
+    log_http_verify: bool | str = DEFAULT_VERIFY
+
+    @field_validator("log_http_verify", mode="before")
+    @classmethod
+    def _parse_log_http_verify(cls, value: object) -> bool | str:
+        return parse_verify(value)
 
     # ------------------------------------------------------------------
     # Registro de ambiente (host) — enviado uma vez por processo/serviço

jaylog-0.3.2/README.md

@@ -1,30 +0,0 @@
-# jaylog
-
-Biblioteca de logging para Python com rotação de arquivos, saída colorida no console, envio HTTP para um endpoint remoto e registro automático do ambiente de execução (host reporting).
-
-📖 **Documentação completa:** https://gpocas.github.io/jaylog-book
-
-## Instalação
-
-```bash
-pip install -U --no-cache-dir jaylog
-```
-
-## Uso rápido
-
-__*.env.logging*__
-```env
-JAYLOG_APP_NAME=meu-bot
-JAYLOG_LOG_DIR=C:\logs
-```
-
-__*main.py*__
-```python
-from jaylog import JaylogSettings, configure, get_logger
-
-configure(JaylogSettings())
-
-logger = get_logger()
-
-logger.info("Olá, jaylog!")
-```