nati-log 2.2.7__tar.gz

nati_log-2.2.7/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 1.0
+Name: nati_log
+Version: 2.2.7
+Summary: Librería para interactuar con la API de NatiLog
+Home-page: UNKNOWN
+Author: Natalí
+Author-email: UNKNOWN
+License: UNKNOWN
+Description: UNKNOWN
+Platform: UNKNOWN

nati_log-2.2.7/nati_log/__init__.py

@@ -0,0 +1 @@
+from .client import NatiLogClient

nati_log-2.2.7/nati_log/client.py

@@ -0,0 +1,160 @@
+import requests
+import datetime
+
+
+class NatiLogClient:
+    def __init__(self, api_url, api_url_login, app_id, username, password):
+        self.api_url = api_url.rstrip("/")  # Saca la barra final si ya la tiene
+        self.api_url_login = api_url_login
+        self.app_id = app_id
+        self.app_estado = True
+        self.username = username
+        self.password = password
+        self.token = None
+        self.get_natilog_token()
+        self.actualizar_estado_aplicacion()
+
+    def get_natilog_token(self):
+        payload = {"username": self.username, "password": self.password}
+        try:
+            response = requests.post(self.api_url_login, json=payload, timeout=10)
+            response.raise_for_status()  # Lanza un error si el código de estado no es 200
+            data = response.json()
+            self.token = data.get("access") or data.get("token")
+        except requests.exceptions.RequestException as e:
+            self.token = None
+
+    def actualizar_estado_aplicacion(self):
+        if not self.token: # si no hay token, no se puede verificar el estado
+            return
+        headers = {"Authorization": f"Bearer {self.token}"} # encabezado de autorización
+        try:
+            response = requests.get(
+                f"{self.api_url}/aplicaciones/{self.app_id}",
+                headers=headers,
+                timeout=5,
+            ) # solicitud para obtener el estado de la aplicación
+            if response.status_code == 401:
+                self.get_natilog_token() # si el token ha expirado, obtener uno nuevo
+                if not self.token:
+                    return
+                headers["Authorization"] = f"Bearer {self.token}"
+                response = requests.get(
+                    f"{self.api_url}/aplicaciones/{self.app_id}",
+                    headers=headers,
+                    timeout=5,
+                )
+            response.raise_for_status() # Lanza un error si la respuesta no es 200 OK
+            data = response.json()
+            self.app_estado = data.get("estado", True)
+        except requests.exceptions.RequestException: # en caso de error, asumir que la app está activa
+            self.app_estado = True
+            # si la app está inactiva, no se registrarán eventos
+
+    def registrar_evento(self, tipo_evento, mensaje, datos=None, fecha=None):
+        """
+        Registra un evento en la API de NatiLog
+        Args:
+        tipo_evento: str - Tipo de evento (e.g., "critical", "error", "warning", "info")
+        mensaje: str - Mensaje del evento
+        datos: dict - Datos adicionales del evento (opcional)
+        fecha: str - Fecha y hora del evento en formato ISO 8601 (opcional)
+        Returns: dict - Respuesta de la API en formato JSON
+        Raises: requests.exceptions.RequestException - Si hay un error en la solicitud
+        """
+        self.actualizar_estado_aplicacion()
+        if not self.app_estado:
+            return {"detail": "Aplicación inactiva. Evento omitido."}
+
+        if fecha is None:
+            fecha = (
+                datetime.datetime.now().isoformat()
+            )  # Fecha y hora actual en formato ISO 8601
+
+        payload = {
+            "aplicacion": self.app_id,
+            "tipo_evento": tipo_evento,
+            "mensaje": mensaje,
+            "datos": datos
+            or {},  # Datos adicionales, si no hay datos, envía un diccionario vacío
+            "fecha": fecha,
+        }
+
+        if not self.token:
+            self.get_natilog_token()
+
+        headers = {"Content-Type": "application/json"}
+
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+
+        response = requests.post(
+            f"{self.api_url}/evento/", json=payload, headers=headers, timeout=5
+        )
+
+        if response.status_code == 401:
+            self.get_natilog_token()
+            if not self.token:
+                response.raise_for_status()
+            headers["Authorization"] = f"Bearer {self.token}"
+            response = requests.post(
+                f"{self.api_url}/evento/", json=payload, headers=headers, timeout=5
+            )
+
+        response.raise_for_status()  # Lanza un error si la respuesta no es 200 OK
+        return response.json()  # Devuelve la respuesta en formato JSON
+
+    def debug(self, mensaje, datos=None, fecha=None):
+        """
+        Registra un evento de tipo "debug"
+        Args:
+        mensaje: str - Mensaje del evento
+        datos: dict - Datos adicionales del evento (opcional)
+        fecha: str - Fecha y hora del evento en formato ISO 8601 (opcional)
+        Returns: dict - Respuesta de la API en formato JSON
+        """
+        return self.registrar_evento("DEBUG", mensaje, datos, fecha)
+
+    def error(self, mensaje, datos=None, fecha=None):
+        """
+        Registra un evento de tipo "error"
+        Args:
+        mensaje: str - Mensaje del evento
+        datos: dict - Datos adicionales del evento (opcional)
+        fecha: str - Fecha y hora del evento en formato ISO 8601 (opcional)
+        Returns: dict - Respuesta de la API en formato JSON
+        """
+        return self.registrar_evento("ERROR", mensaje, datos, fecha)
+
+    def warning(self, mensaje, datos=None, fecha=None):
+        """
+        Registra un evento de tipo "warning"
+        Args:
+        mensaje: str - Mensaje del evento
+        datos: dict - Datos adicionales del evento (opcional)
+        fecha: str - Fecha y hora del evento en formato ISO 8601 (opcional)
+        Returns: dict - Respuesta de la API en formato JSON
+        """
+        return self.registrar_evento("WARNING", mensaje, datos, fecha)
+
+    def info(self, mensaje, datos=None, fecha=None):
+        """
+        Registra un evento de tipo "info"
+        Args:
+        mensaje: str - Mensaje del evento
+        datos: dict - Datos adicionales del evento (opcional)
+        fecha: str - Fecha y hora del evento en formato ISO 8601 (opcional)
+        Returns: dict - Respuesta de la API en formato JSON
+        """
+        return self.registrar_evento("INFO", mensaje, datos, fecha)
+
+    def critical(self, mensaje, datos=None, fecha=None):
+        """
+        Registra un evento de tipo "critical"
+        Args:
+        mensaje: str - Mensaje del evento
+        datos: dict - Datos adicionales del evento (opcional)
+        fecha: str - Fecha y hora del evento en formato ISO 8601 (opcional)
+        Returns: dict - Respuesta de la API en formato JSON
+        """
+        return self.registrar_evento("CRITICAL", mensaje, datos, fecha)

nati_log-2.2.7/nati_log/middleware.py

@@ -0,0 +1,71 @@
+from django.conf import settings
+from .client import NatiLogClient
+
+
+class NatiLogMiddleware:
+    def __init__(self, get_response):
+        """
+        Middleware para registrar eventos automáticamente en NatiLog.
+        Args:
+        :param get_response: callable - La función para obtener la respuesta de la vista
+        """
+
+        self.get_response = get_response
+        config = getattr(settings, "NATILOG", {})
+        self.levels = config.get(
+            "EVENT_LEVELS",
+            {"DEBUG": True, "INFO": True, "WARNING": True, "ERROR": True, "CRITICAL": True},
+        )
+        self.natilog = NatiLogClient(
+            api_url=config.get("API_URL"),
+            api_url_login=config.get("API_URL_LOGIN"),
+            app_id=config.get("APP_ID"),
+            username=config.get("USERNAME"),
+            password=config.get("PASSWORD"),
+        )
+        print("NatilogClient iniziado en middleware.")
+        print(f"NATILOG config: {config}")
+
+    def __call__(self, request):
+        """
+        Procesa la solicitud y registra eventos en NatiLog.
+        Args:
+        :param request: HttpRequest - La solicitud entrante
+        :returns: HttpResponse - La respuesta generada por la vista
+        """
+        response = self.get_response(request)
+
+        if not self.natilog:
+            return response
+
+        try:
+            if self.levels.get("DEBUG", True):
+                self.natilog.debug(
+                    f"Request recibido: {request.method} {request.path}",
+                    datos={"usuario": getattr(request.user, "username", None)},
+                )
+
+            if 200 <= response.status_code < 300 and self.levels.get("INFO", True):
+                self.natilog.info(
+                    f"Request OK: {request.method} {request.path}",
+                    datos={"status_code": response.status_code},
+                )
+            elif 300 <= response.status_code < 400 and self.levels.get("WARNING", True):
+                self.natilog.warning(
+                    f"Redirect: {request.method} {request.path}",
+                    datos={"status_code": response.status_code},
+                )
+            elif 400 <= response.status_code < 500 and self.levels.get("ERROR", True):
+                self.natilog.error(
+                    f"Client Error {response.status_code}: {request.method} {request.path}",
+                    datos={"status_code": response.status_code},
+                )
+            elif response.status_code >= 500 and self.levels.get("CRITICAL", True):
+                self.natilog.critical(
+                    f"Server Error {response.status_code}: {request.method} {request.path}",
+                    datos={"status_code": response.status_code},
+                )
+        except Exception as exc:
+            print(f"Error al registrar evento en NatiLog: {exc}")
+
+        return response

nati_log-2.2.7/nati_log.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 1.0
+Name: nati-log
+Version: 2.2.7
+Summary: Librería para interactuar con la API de NatiLog
+Home-page: UNKNOWN
+Author: Natalí
+Author-email: UNKNOWN
+License: UNKNOWN
+Description: UNKNOWN
+Platform: UNKNOWN

nati_log-2.2.7/nati_log.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+pyproject.toml
+setup.py
+nati_log/__init__.py
+nati_log/client.py
+nati_log/middleware.py
+nati_log.egg-info/PKG-INFO
+nati_log.egg-info/SOURCES.txt
+nati_log.egg-info/dependency_links.txt
+nati_log.egg-info/requires.txt
+nati_log.egg-info/top_level.txt
+tests/__init__.py
+tests/settings.py
+tests/test_client.py
+tests/test_middleware.py

nati_log-2.2.7/nati_log.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

nati_log-2.2.7/nati_log.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.25.1

nati_log-2.2.7/nati_log.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+nati_log
+tests

nati_log-2.2.7/pyproject.toml

@@ -0,0 +1,11 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "nati_log"
+version = "2.2.7"
+description = "Estadísticas de logs"
+authors = [{name = "Natalí"}]
+requires-python = ">=3.8"
+dependencies = ["requests>=2.25.1"]

nati_log-2.2.7/setup.cfg

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

nati_log-2.2.7/setup.py

@@ -0,0 +1,10 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="nati_log",
+    version="2.2.7",
+    author="Natalí",
+    install_requires=["requests>=2.25.1"],
+    packages=find_packages(),
+    description="Librería para interactuar con la API de NatiLog",
+)

nati_log-2.2.7/tests/settings.py

@@ -0,0 +1,3 @@
+SECRET_KEY = "test"
+INSTALLED_APPS = ["django.contrib.contenttypes", "django.contrib.auth", "nati_log"]
+DATABASES = {"default": {"ENGINE": "django.db.backends.sqlite3", "NAME": ":memory:"}}

nati_log-2.2.7/tests/test_client.py

@@ -0,0 +1,220 @@
+# -*- coding: utf-8 -*-
+import datetime
+import pytest
+import requests
+from nati_log.client import NatiLogClient
+
+
+@pytest.fixture
+def api_urls():
+    return {
+        "api": "http://fake-api/api",
+        "login": "http://fake-api/api/auth/usuarios/login/",
+        "app": "http://fake-api/api/aplicaciones/5",
+        "evento": "http://fake-api/api/evento/",
+    }
+
+
+def _build_client(requests_mock, api_urls, app_estado=True, token="token-1"):
+    requests_mock.post(
+        api_urls["login"],
+        json={"access": token},
+        status_code=200,
+    )
+    requests_mock.get(
+        api_urls["app"],
+        json={"estado": app_estado},
+        status_code=200,
+    )
+    return NatiLogClient(
+        api_url=api_urls["api"],
+        api_url_login=api_urls["login"],
+        app_id=5,
+        username="user",
+        password="pass",
+    )
+
+
+def test_registrar_evento_success(requests_mock, api_urls):
+    client = _build_client(requests_mock, api_urls)
+    requests_mock.post(
+        api_urls["evento"],
+        json={"status": "ok"},
+        status_code=201,
+    )
+
+    resp = client.info("Evento exitoso", datos={"key": "value"})
+    assert resp == {"status": "ok"}
+
+    last = requests_mock.last_request
+    assert last.headers["Authorization"] == "Bearer token-1"
+    assert last.json()["tipo_evento"] == "INFO"
+    assert last.json()["datos"]["key"] == "value"
+
+
+def test_registrar_evento_app_inactiva_omite_envio(requests_mock, api_urls):
+    client = _build_client(requests_mock, api_urls, app_estado=False)
+
+    result = client.info("No debe enviarse")
+    assert result == {"detail": "Aplicación inactiva. Evento omitido."}
+    assert len(requests_mock.request_history) == 2  # login + estado, sin POST de evento
+
+
+def test_registrar_evento_reintenta_en_401(requests_mock, api_urls):
+    requests_mock.post(
+        api_urls["login"],
+        [
+            {"json": {"access": "token-1"}, "status_code": 200},
+            {"json": {"access": "token-2"}, "status_code": 200},
+        ],
+    )
+    requests_mock.get(api_urls["app"], json={"estado": True}, status_code=200)
+    requests_mock.post(
+        api_urls["evento"],
+        [
+            {"status_code": 401},
+            {"json": {"status": "ok"}, "status_code": 201},
+        ],
+    )
+
+    client = NatiLogClient(
+        api_url=api_urls["api"],
+        api_url_login=api_urls["login"],
+        app_id=5,
+        username="user",
+        password="pass",
+    )
+    resp = client.error("Debe reintentar")
+    assert resp == {"status": "ok"}
+
+    evento_calls = [req for req in requests_mock.request_history if req.url == api_urls["evento"]]
+    assert len(evento_calls) == 2
+    assert evento_calls[-1].headers["Authorization"] == "Bearer token-2"
+
+
+def test_registrar_evento_sin_token_levanta_http_error(requests_mock, api_urls):
+    requests_mock.post(api_urls["login"], status_code=401)
+    client = NatiLogClient(
+        api_url=api_urls["api"],
+        api_url_login=api_urls["login"],
+        app_id=5,
+        username="user",
+        password="pass",
+    )
+
+    requests_mock.post(api_urls["evento"], status_code=401)
+    with pytest.raises(requests.exceptions.HTTPError):
+        client.warning("Debe fallar")
+
+
+def test_registrar_evento_con_fecha_personalizada(requests_mock, api_urls):
+    client = _build_client(requests_mock, api_urls)
+    requests_mock.post(
+        api_urls["evento"],
+        json={"status": "ok"},
+        status_code=201,
+    )
+
+    fecha = datetime.datetime(2024, 1, 1, 12, 0, 0).isoformat()
+    client.debug("Con fecha", fecha=fecha)
+
+    last = requests_mock.last_request
+    assert last.json()["fecha"] == fecha
+    assert last.json()["tipo_evento"] == "DEBUG"
+
+
+def test_get_token_exception_deja_token_none(requests_mock, api_urls):
+    requests_mock.post(
+        api_urls["login"],
+        exc=requests.exceptions.ConnectTimeout,
+    )
+
+    client = NatiLogClient(
+        api_url=api_urls["api"],
+        api_url_login=api_urls["login"],
+        app_id=5,
+        username="user",
+        password="pass",
+    )
+    assert client.token is None
+    assert client.app_estado is True
+
+
+def test_registrar_evento_retry_sin_token_levanta_error(requests_mock, api_urls):
+    requests_mock.post(
+        api_urls["login"],
+        [
+            {"json": {"access": "token-1"}, "status_code": 200},
+            {"status_code": 500},
+        ],
+    )
+    requests_mock.get(api_urls["app"], json={"estado": True}, status_code=200)
+    requests_mock.post(api_urls["evento"], status_code=401)
+
+    client = NatiLogClient(
+        api_url=api_urls["api"],
+        api_url_login=api_urls["login"],
+        app_id=5,
+        username="user",
+        password="pass",
+    )
+
+    with pytest.raises(requests.exceptions.HTTPError):
+        client.warning("Debe fallar tras reintento sin token")
+
+
+def test_registrar_evento_critical(requests_mock, api_urls):
+    client = _build_client(requests_mock, api_urls)
+    requests_mock.post(
+        api_urls["evento"],
+        json={"status": "ok"},
+        status_code=201,
+    )
+
+    client.critical("Falla crítica")
+
+    last = requests_mock.last_request
+    assert last.json()["tipo_evento"] == "CRITICAL"
+
+
+def test_actualizar_estado_aplicacion_refresca_token(requests_mock, api_urls):
+    requests_mock.post(
+        api_urls["login"],
+        [
+            {"json": {"access": "token-1"}, "status_code": 200},
+            {"json": {"access": "token-2"}, "status_code": 200},
+        ],
+    )
+    requests_mock.get(
+        api_urls["app"],
+        [
+            {"status_code": 401},
+            {"json": {"estado": False}, "status_code": 200},
+        ],
+    )
+
+    client = NatiLogClient(
+        api_url=api_urls["api"],
+        api_url_login=api_urls["login"],
+        app_id=5,
+        username="user",
+        password="pass",
+    )
+
+    assert client.token == "token-2"
+    assert client.estado is False
+
+
+def test_actualizar_estado_aplicacion_error_mantiene_activa(requests_mock, api_urls):
+    requests_mock.post(api_urls["login"], json={"access": "token"}, status_code=200)
+    requests_mock.get(api_urls["app"], exc=requests.exceptions.ReadTimeout)
+
+    client = NatiLogClient(
+        api_url=api_urls["api"],
+        api_url_login=api_urls["login"],
+        app_id=5,
+        username="user",
+        password="pass",
+    )
+
+    assert client.estado is True

nati_log-2.2.7/tests/test_middleware.py

@@ -0,0 +1,192 @@
+# -*- coding: utf-8 -*-
+try:
+    from types import SimpleNamespace
+except ImportError:
+    class SimpleNamespace(object):
+        def __init__(self, **kwargs):
+            for key, value in kwargs.items():
+                setattr(self, key, value)
+
+import pytest
+from django.http import HttpResponse
+from django.test import RequestFactory
+from nati_log.middleware import NatiLogMiddleware
+
+
+class DummyClient(object):
+    def __init__(self):
+        self.calls = []
+
+    def debug(self, mensaje, datos=None, fecha=None):
+        self.calls.append(("debug", mensaje, datos))
+
+    def info(self, mensaje, datos=None, fecha=None):
+        self.calls.append(("info", mensaje, datos))
+
+    def warning(self, mensaje, datos=None, fecha=None):
+        self.calls.append(("warning", mensaje, datos))
+
+    def error(self, mensaje, datos=None, fecha=None):
+        self.calls.append(("error", mensaje, datos))
+
+    def critical(self, mensaje, datos=None, fecha=None):
+        self.calls.append(("critical", mensaje, datos))
+
+
+@pytest.fixture
+def rf():
+    return RequestFactory()
+
+
+def make_response(status=200):
+    resp = HttpResponse("ok")
+    resp.status_code = status
+    return resp
+
+
+def test_middleware_registra_info_por_defecto(settings, monkeypatch, rf):
+    settings.NATILOG = {
+        "API_URL": "http://fake/api",
+        "API_URL_LOGIN": "http://fake/api/auth/",
+        "APP_ID": 1,
+        "USERNAME": "user",
+        "PASSWORD": "pass",
+        "EVENT_LEVELS": {
+            "DEBUG": True,
+            "INFO": True,
+            "WARNING": True,
+            "ERROR": True,
+            "CRITICAL": True,
+        },
+    }
+    dummy = DummyClient()
+    monkeypatch.setattr("nati_log.middleware.NatiLogClient", lambda **_: dummy)
+
+    middleware = NatiLogMiddleware(lambda req: make_response(200))
+    request = rf.get("/path")
+    request.user = SimpleNamespace(username="tester")
+
+    middleware(request)
+
+    assert ("debug", "Request recibido: GET /path", {"usuario": "tester"}) in dummy.calls
+    assert any(call[0] == "info" for call in dummy.calls)
+
+
+def test_middleware_filtra_niveles(settings, monkeypatch, rf):
+    settings.NATILOG = {
+        "API_URL": "http://fake/api",
+        "API_URL_LOGIN": "http://fake/api/auth/",
+        "APP_ID": 1,
+        "USERNAME": "user",
+        "PASSWORD": "pass",
+        "EVENT_LEVELS": {
+            "DEBUG": False,
+            "INFO": False,
+            "WARNING": True,
+            "ERROR": True,
+            "CRITICAL": True,
+        },
+    }
+    dummy = DummyClient()
+    monkeypatch.setattr("nati_log.middleware.NatiLogClient", lambda **_: dummy)
+
+    middleware = NatiLogMiddleware(lambda req: make_response(302))
+    request = rf.get("/redirect")
+
+    middleware(request)
+
+    tipos = set(call[0] for call in dummy.calls)
+    assert "debug" not in tipos
+    assert "info" not in tipos
+    assert "warning" in tipos
+
+
+def test_middleware_registra_error(settings, monkeypatch, rf):
+    settings.NATILOG = {
+        "API_URL": "http://fake/api",
+        "API_URL_LOGIN": "http://fake/api/auth/",
+        "APP_ID": 1,
+        "USERNAME": "user",
+        "PASSWORD": "pass",
+        "EVENT_LEVELS": {
+            "DEBUG": True,
+            "INFO": True,
+            "WARNING": True,
+            "ERROR": True,
+            "CRITICAL": True,
+        },
+    }
+    dummy = DummyClient()
+    monkeypatch.setattr("nati_log.middleware.NatiLogClient", lambda **_: dummy)
+
+    middleware = NatiLogMiddleware(lambda req: make_response(404))
+    request = rf.get("/not-found")
+    request.user = SimpleNamespace(username="tester")
+
+    middleware(request)
+
+    assert any(call[0] == "error" for call in dummy.calls)
+
+
+def test_middleware_sin_cliente_retorna(settings, monkeypatch, rf):
+    settings.NATILOG = {
+        "API_URL": "http://fake/api",
+        "API_URL_LOGIN": "http://fake/api/auth/",
+        "APP_ID": 1,
+        "USERNAME": "user",
+        "PASSWORD": "pass",
+        "EVENT_LEVELS": {"DEBUG": True, "INFO": True, "WARNING": True, "ERROR": True, "CRITICAL": True},
+    }
+    monkeypatch.setattr("nati_log.middleware.NatiLogClient", lambda **_: None)
+
+    middleware = NatiLogMiddleware(lambda req: make_response(200))
+    request = rf.get("/noop")
+    middleware(request)
+
+
+def test_middleware_registra_critical(settings, monkeypatch, rf):
+    settings.NATILOG = {
+        "API_URL": "http://fake/api",
+        "API_URL_LOGIN": "http://fake/api/auth/",
+        "APP_ID": 1,
+        "USERNAME": "user",
+        "PASSWORD": "pass",
+        "EVENT_LEVELS": {"DEBUG": True, "INFO": True, "WARNING": True, "ERROR": True, "CRITICAL": True},
+    }
+    dummy = DummyClient()
+    monkeypatch.setattr("nati_log.middleware.NatiLogClient", lambda **_: dummy)
+
+    middleware = NatiLogMiddleware(lambda req: make_response(503))
+    request = rf.get("/boom")
+    request.user = SimpleNamespace(username="tester")
+
+    middleware(request)
+
+    assert any(call[0] == "critical" for call in dummy.calls)
+
+
+def test_middleware_registra_warning(settings, monkeypatch, rf):
+    settings.NATILOG = {
+        "API_URL": "http://fake/api",
+        "API_URL_LOGIN": "http://fake/api/auth/",
+        "APP_ID": 1,
+        "USERNAME": "user",
+        "PASSWORD": "pass",
+        "EVENT_LEVELS": {
+            "DEBUG": True,
+            "INFO": True,
+            "WARNING": True,
+            "ERROR": True,
+            "CRITICAL": True,
+        },
+    }
+    dummy = DummyClient()
+    monkeypatch.setattr("nati_log.middleware.NatiLogClient", lambda **_: dummy)
+
+    middleware = NatiLogMiddleware(lambda req: make_response(302))
+    request = rf.get("/redirect")
+    request.user = SimpleNamespace(username="tester")
+
+    middleware(request)
+
+    assert any(call[0] == "warning" for call in dummy.calls)