devinspector 2.0.6__tar.gz → 2.3.0__tar.gz

devinspector-2.3.0/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: devinspector
+Version: 2.3.0
+Summary: SDK Python de monitoramento e auditoria em tempo real | DevInspector
+Author-email: DevInspector <suporte@devinspector.com.br>
+License: MIT
+Project-URL: Homepage, https://devinspector.com.br
+Keywords: monitoring,error-tracking,apm,audit,devinspector,fastapi,flask
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: fastapi
+Requires-Dist: fastapi; extra == "fastapi"
+Requires-Dist: starlette; extra == "fastapi"
+Provides-Extra: flask
+Requires-Dist: flask; extra == "flask"

devinspector-2.3.0/devinspector/__init__.py

@@ -0,0 +1,3 @@
+from .core import AuditCore, audit, audit_operation
+
+__all__ = ["audit", "AuditCore", "audit_operation"]

devinspector-2.3.0/devinspector/core.py

@@ -0,0 +1,393 @@
+import sys
+import json
+import time
+import queue
+import threading
+import traceback
+import urllib.request
+import asyncio
+import functools
+import contextvars
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional, Union
+
+# Variável de contexto para armazenar dados da requisição atual (APM)
+request_context = contextvars.ContextVar("request_context", default=None)
+
+class AuditCore:
+    def __init__(self):
+        self.api_key: str = "PENDING_API_KEY"
+        self.endpoint: str = "https://api.devinspector.com.br/api/ingest/track"
+        self.environment: str = "production"
+        self.initialized: bool = False
+        self._listeners_attached: bool = False
+
+        # Fila e thread em background para envio assíncrono
+        self._queue: queue.Queue = queue.Queue(maxsize=10000)
+        self._shutdown_event = threading.Event()
+        self._worker_thread = threading.Thread(target=self._worker, daemon=True)
+        self._worker_thread.start()
+
+    def init(
+        self,
+        api_key: str,
+        endpoint: Optional[str] = None,
+        environment: Optional[str] = None,
+    ) -> None:
+        if not api_key:
+            print("[AuditSDK] API Key não fornecida no init().")
+            return
+
+        self.api_key = api_key
+        if endpoint:
+            self.endpoint = endpoint
+        if environment:
+            self.environment = environment
+
+        self.initialized = True
+        self._listen_global_errors()
+
+    def is_ingest_url(self, target_url: str) -> bool:
+        """
+        Verifica dinamicamente se uma URL pertence ao servidor de ingestão do Dev Inspector.
+        Evita chamadas em loop em ambientes self-hosted (Coolify, VPS, etc).
+        """
+        if not target_url:
+            return False
+        try:
+            if self.endpoint and target_url in self.endpoint or target_url in self.endpoint:
+                if target_url in self.endpoint or self.endpoint in target_url:
+                    return True
+            from urllib.parse import urlparse
+            endpoint_obj = urlparse(self.endpoint)
+            return (
+                endpoint_obj.netloc in target_url or
+                endpoint_obj.path in target_url
+            )
+        except Exception:
+            return (
+                "devinspector.com.br" in target_url or
+                "/ingest/track" in target_url
+            )
+
+    def capture_request(
+        self,
+        method: str,
+        url: str,
+        status_code: int,
+        duration_ms: float,
+        user_agent: str = "",
+        route: str = "",
+        db_queries_count: int = 0,
+        slow_query_ms: float = 0,
+    ) -> None:
+        payload = {
+            "type": "request_metric",
+            "message": f"{method} {url} - {status_code}",
+            "method": method,
+            "url": url,
+            "statusCode": status_code,
+            "durationMs": round(duration_ms, 2),
+            "browser": user_agent,
+            "metadata": {
+                "environment": self.environment,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "route": route or url,
+                "dbQueriesCount": db_queries_count,
+                "slowQueryMs": round(slow_query_ms, 2),
+            },
+        }
+        self._enqueue(payload)
+
+    def capture_error(
+        self, error: Exception, metadata: Optional[Dict[str, Any]] = None
+    ) -> None:
+        raw_message = str(error) or "Erro Desconhecido"
+        raw_stack = "".join(traceback.format_tb(error.__traceback__)) if error.__traceback__ else str(error)
+
+        meta = metadata.copy() if metadata else {}
+        meta.update(
+            {
+                "environment": self.environment,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+            }
+        )
+
+        payload = {
+            "type": "error",
+            "message": self._truncate(raw_message, 500),
+            "stackTrace": self._truncate(raw_stack, 10000),
+            "url": "",
+            "browser": f"Python/{sys.version.split()[0]}",
+            "metadata": self._truncate(meta, 5000),
+        }
+        self._enqueue(payload)
+
+    def capture_exception(
+        self, error: Exception, metadata: Optional[Dict[str, Any]] = None
+    ) -> None:
+        self.capture_error(error, metadata)
+
+    def capture_message(
+        self, message: str, metadata: Optional[Dict[str, Any]] = None
+    ) -> None:
+        meta = metadata.copy() if metadata else {}
+        meta.update(
+            {
+                "level": "info",
+                "environment": self.environment,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+            }
+        )
+
+        payload = {
+            "type": "message",
+            "message": self._truncate(message, 500),
+            "stackTrace": "",
+            "url": "",
+            "browser": f"Python/{sys.version.split()[0]}",
+            "metadata": self._truncate(meta, 5000),
+        }
+        self._enqueue(payload)
+
+    def _listen_global_errors(self) -> None:
+        if self._listeners_attached:
+            return
+        self._listeners_attached = True
+
+        original_excepthook = sys.excepthook
+
+        def custom_excepthook(exc_type, exc_value, exc_traceback):
+            if issubclass(exc_type, KeyboardInterrupt):
+                original_excepthook(exc_type, exc_value, exc_traceback)
+                return
+
+            self.capture_error(
+                exc_value,
+                metadata={"type": "uncaught_exception", "exc_type": exc_type.__name__},
+            )
+            original_excepthook(exc_type, exc_value, exc_traceback)
+
+        sys.excepthook = custom_excepthook
+
+        if hasattr(threading, "excepthook"):
+            def custom_thread_excepthook(args):
+                self.capture_error(
+                    args.exc_value,
+                    metadata={
+                        "type": "uncaught_thread_exception",
+                        "thread": args.thread.name,
+                    },
+                )
+
+            threading.excepthook = custom_thread_excepthook
+
+    def _truncate(self, value: Any, max_length: int = 5000, seen=None) -> Any:
+        if seen is None:
+            seen = set()
+
+        if isinstance(value, str):
+            return (
+                value[:max_length] + "... [truncated]"
+                if len(value) > max_length
+                else value
+            )
+
+        if isinstance(value, dict):
+            obj_id = id(value)
+            if obj_id in seen:
+                return "[Circular Reference]"
+            seen.add(obj_id)
+
+            truncated_obj = {}
+            for k, v in value.items():
+                truncated_obj[str(k)] = self._truncate(v, max_length, seen)
+            seen.remove(obj_id)
+            return truncated_obj
+
+        if isinstance(value, (list, tuple, set)):
+            obj_id = id(value)
+            if obj_id in seen:
+                return "[Circular Reference]"
+            seen.add(obj_id)
+
+            truncated_list = [self._truncate(item, max_length, seen) for item in value]
+            seen.remove(obj_id)
+            return truncated_list
+
+        return value
+
+    def _enqueue(self, payload: dict) -> None:
+        try:
+            self._queue.put_nowait(payload)
+        except queue.Full:
+            pass
+
+    def _worker(self) -> None:
+        while not self._shutdown_event.is_set():
+            try:
+                payload = self._queue.get(timeout=0.5)
+                self._send(payload)
+                self._queue.task_done()
+            except queue.Empty:
+                continue
+
+    def _send(self, payload: dict) -> None:
+        active_key = (
+            self.api_key
+            if self.api_key and self.api_key != "PENDING_API_KEY"
+            else "dev-fallback-key"
+        )
+        data_bytes = json.dumps(payload).encode("utf-8")
+
+        req = urllib.request.Request(
+            self.endpoint,
+            data=data_bytes,
+            headers={
+                "Content-Type": "application/json",
+                "x-api-key": active_key,
+            },
+            method="POST",
+        )
+
+        try:
+            with urllib.request.urlopen(req, timeout=5):
+                pass
+        except urllib.error.HTTPError as e:
+            error_body = e.read().decode('utf-8', errors='ignore')
+            print(f"[DevInspector] HTTP {e.code} do painel: {e.reason} - Resposta: {error_body}")
+        except Exception as err:
+            print(f"[DevInspector] Falha ao enviar requisição para o painel: {err}")
+
+
+# Singleton Global
+audit = AuditCore()
+
+
+def audit_operation(name: str, threshold_ms: int = 300):
+    """
+    Decorador para monitorar funções de banco de dados ou chamadas externas.
+    Alimenta o request_context atual com a contagem de queries e lentidão.
+    Suporta tanto funções síncronas (def) quanto assíncronas (async def).
+    """
+    def decorator(func):
+        @functools.wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            ctx = request_context.get()
+            if ctx is not None:
+                ctx["queriesCount"] = ctx.get("queriesCount", 0) + 1
+            
+            start = time.perf_counter()
+            try:
+                result = await func(*args, **kwargs)
+                duration_ms = (time.perf_counter() - start) * 1000
+                
+                if duration_ms > threshold_ms and ctx is not None:
+                    ctx["slowQueries"] = max(ctx.get("slowQueries", 0), duration_ms)
+                    audit.capture_message(
+                        f"Slow Query detectada em [{name}]", 
+                        {"durationMs": round(duration_ms), "operationName": name}
+                    )
+                return result
+            except Exception as e:
+                duration_ms = (time.perf_counter() - start) * 1000
+                audit.capture_exception(e, {"operationName": name, "durationMs": round(duration_ms)})
+                raise
+
+        @functools.wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            ctx = request_context.get()
+            if ctx is not None:
+                ctx["queriesCount"] = ctx.get("queriesCount", 0) + 1
+            
+            start = time.perf_counter()
+            try:
+                result = func(*args, **kwargs)
+                duration_ms = (time.perf_counter() - start) * 1000
+                
+                if duration_ms > threshold_ms and ctx is not None:
+                    ctx["slowQueries"] = max(ctx.get("slowQueries", 0), duration_ms)
+                    audit.capture_message(
+                        f"Slow Query detectada em [{name}]", 
+                        {"durationMs": round(duration_ms), "operationName": name}
+                    )
+                return result
+            except Exception as e:
+                duration_ms = (time.perf_counter() - start) * 1000
+                audit.capture_exception(e, {"operationName": name, "durationMs": round(duration_ms)})
+                raise
+
+        return async_wrapper if asyncio.iscoroutinefunction(func) else sync_wrapper
+    return decorator
+
+
+async def core_audit_fetch(
+    url: str,
+    method: str = "GET",
+    headers: Optional[Dict[str, str]] = None,
+    data: Optional[Any] = None,
+    timeout: float = 10.0,
+    error_type: str = "network_error",
+    default_user_agent: str = "",
+) -> Any:
+    """
+    Helper centralizado de Intercepção de Fetch/Requisições HTTP para APM em Python.
+    Equivalente ao coreAuditFetch do SDK TypeScript.
+    """
+    if url and audit.is_ingest_url(url):
+        # Execução direta sem rastreamento para evitar loop
+        req = urllib.request.Request(url, data=data, headers=headers or {}, method=method)
+        with urllib.request.urlopen(req, timeout=timeout) as response:
+            return response
+
+    start = time.perf_counter()
+    try:
+        # Exemplo usando urllib síncrono ou adaptado para chamadas
+        # (Para puro asyncio, pode-se integrar com httpx caso prefira)
+        req_headers = headers or {}
+        if default_user_agent and "User-Agent" not in req_headers:
+            req_headers["User-Agent"] = default_user_agent
+
+        req = urllib.request.Request(url, data=data, headers=req_headers, method=method)
+        
+        # Executa em executor separado para não travar o loop async se chamado em contexto assíncrono
+        loop = asyncio.get_running_loop()
+        response = await loop.run_in_executor(
+            None, lambda: urllib.request.urlopen(req, timeout=timeout)
+        )
+        
+        duration_ms = (time.perf_counter() - start) * 1000
+        status_code = response.getcode()
+
+        if status_code >= 400 or duration_ms >= 300:
+            audit.capture_request(
+                method=method,
+                url=url,
+                status_code=status_code,
+                duration_ms=duration_ms,
+                route=url,
+                user_agent=req_headers.get("User-Agent", default_user_agent),
+            )
+
+        return response
+    except Exception as error:
+        duration_ms = (time.perf_counter() - start) * 1000
+        
+        status_code = 0
+        if hasattr(error, "code"):
+            status_code = error.code
+
+        audit.capture_request(
+            method=method,
+            url=url,
+            status_code=status_code,
+            duration_ms=duration_ms,
+            route=url,
+            user_agent=default_user_agent,
+        )
+
+        audit.capture_exception(
+            error if isinstance(error, Exception) else Exception(str(error)),
+            {"url": url, "method": method, "type": error_type},
+        )
+        raise error

devinspector-2.3.0/devinspector/fastapi.py

@@ -0,0 +1,73 @@
+import time
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from .core import audit, request_context
+
+class DevInspectorMiddleware(BaseHTTPMiddleware):
+    def __init__(self, app, slow_threshold_ms: int = 300):
+        super().__init__(app)
+        self.slow_threshold_ms = slow_threshold_ms
+
+    async def dispatch(self, request: Request, call_next):
+        # Ignora rotas estáticas (adicione outras se necessário)
+        if request.url.path.startswith("/uploads"):
+            return await call_next(request)
+
+        start_time = time.perf_counter()
+        status_code = 500
+
+        # 1. Inicia o contexto da requisição para o APM isolar as contagens
+        token = request_context.set({
+            "queriesCount": 0,
+            "slowQueries": 0
+        })
+
+        try:
+            response = await call_next(request)
+            status_code = response.status_code
+            return response
+        except Exception as exc:
+            if hasattr(exc, "status_code"):
+                status_code = exc.status_code
+
+            audit.capture_error(
+                exc,
+                metadata={
+                    "path": request.url.path,
+                    "method": request.method,
+                    "statusCode": status_code,
+                },
+            )
+            raise exc
+        finally:
+            duration_ms = (time.perf_counter() - start_time) * 1000
+            user_agent = request.headers.get("user-agent", "")
+
+            # 2. Resgata os dados do APM que foram injetados pelas operações do banco
+            ctx = request_context.get()
+            db_queries_count = ctx.get("queriesCount", 0) if ctx else 0
+            slow_query_ms = ctx.get("slowQueries", 0) if ctx else 0
+
+            is_error = status_code >= 400
+            is_slow = duration_ms >= self.slow_threshold_ms
+            has_slow_query = slow_query_ms > 0
+
+            # 3. 🎯 FILTRO INTELIGENTE: Só envia se for Erro, Lenta ou tiver Query Lenta
+            if is_error or is_slow or has_slow_query:
+                # Tenta extrair a rota mapeada (ex: /users/{id}) em vez da URL crua (/users/123)
+                route_path = request.scope.get("route")
+                route_name = route_path.path if hasattr(route_path, "path") else request.url.path
+
+                audit.capture_request(
+                    method=request.method,
+                    url=str(request.url),
+                    status_code=status_code,
+                    duration_ms=duration_ms,
+                    user_agent=user_agent,
+                    route=route_name,
+                    db_queries_count=db_queries_count,
+                    slow_query_ms=slow_query_ms,
+                )
+            
+            # 4. Limpa o contexto para evitar vazamento de memória em outras requisições
+            request_context.reset(token)

devinspector-2.3.0/devinspector/flask.py

@@ -0,0 +1,88 @@
+import time
+from flask import Flask, g, request
+from .core import audit, request_context
+
+
+class DevInspectorFlask:
+    def __init__(self, app: Flask = None, slow_threshold_ms: int = 300):
+        self.slow_threshold_ms = slow_threshold_ms
+        if app is not None:
+            self.init_app(app)
+
+    def init_app(self, app: Flask):
+        app.before_request(self._before_request)
+        app.after_request(self._after_request)
+        app.teardown_request(self._teardown_request)
+
+    def _before_request(self):
+        # Ignora rotas estáticas (adicione outras se necessário)
+        if request.path.startswith("/uploads"):
+            return
+
+        g._devinspector_start_time = time.perf_counter()
+
+        # 1. Inicia o contexto da requisição para isolar as contagens do APM
+        g._devinspector_ctx_token = request_context.set({
+            "queriesCount": 0,
+            "slowQueries": 0
+        })
+
+    def _after_request(self, response):
+        self._record_metric(response.status_code)
+        return response
+
+    def _teardown_request(self, exception=None):
+        if exception:
+            status_code = 500
+            if hasattr(exception, "code"):
+                status_code = exception.code
+
+            audit.capture_error(
+                exception,
+                metadata={
+                    "path": request.path,
+                    "method": request.method,
+                    "statusCode": status_code,
+                },
+            )
+            if not getattr(g, "_devinspector_metric_recorded", False):
+                self._record_metric(status_code)
+
+        # 4. Limpa o contexto ao final da requisição para evitar vazamento
+        if hasattr(g, "_devinspector_ctx_token"):
+            request_context.reset(g._devinspector_ctx_token)
+
+    def _record_metric(self, status_code: int):
+        start_time = getattr(g, "_devinspector_start_time", None)
+        if start_time is None:
+            return
+
+        duration_ms = (time.perf_counter() - start_time) * 1000
+        user_agent = request.headers.get("User-Agent", "")
+
+        # 2. Resgata os dados do APM que foram injetados pelas operações do banco
+        ctx = request_context.get()
+        db_queries_count = ctx.get("queriesCount", 0) if ctx else 0
+        slow_query_ms = ctx.get("slowQueries", 0) if ctx else 0
+
+        is_error = status_code >= 400
+        is_slow = duration_ms >= self.slow_threshold_ms
+        has_slow_query = slow_query_ms > 0
+
+        # 3. 🎯 FILTRO INTELIGENTE: Só envia se for Erro, Lenta ou tiver Query Lenta
+        if is_error or is_slow or has_slow_query:
+            # Extrai a rota com parâmetros (ex: /users/<id>) em vez da URL crua
+            route_name = request.url_rule.rule if request.url_rule else request.path
+
+            audit.capture_request(
+                method=request.method,
+                url=request.url,
+                status_code=status_code,
+                duration_ms=duration_ms,
+                user_agent=user_agent,
+                route=route_name,
+                db_queries_count=db_queries_count,
+                slow_query_ms=slow_query_ms,
+            )
+        
+        g._devinspector_metric_recorded = True

devinspector-2.3.0/devinspector.egg-info/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: devinspector
+Version: 2.3.0
+Summary: SDK Python de monitoramento e auditoria em tempo real | DevInspector
+Author-email: DevInspector <suporte@devinspector.com.br>
+License: MIT
+Project-URL: Homepage, https://devinspector.com.br
+Keywords: monitoring,error-tracking,apm,audit,devinspector,fastapi,flask
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: fastapi
+Requires-Dist: fastapi; extra == "fastapi"
+Requires-Dist: starlette; extra == "fastapi"
+Provides-Extra: flask
+Requires-Dist: flask; extra == "flask"

devinspector-2.3.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "devinspector"
+version = "2.3.0"
+description = "SDK Python de monitoramento e auditoria em tempo real | DevInspector"
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+authors = [
+    {name = "DevInspector", email = "suporte@devinspector.com.br"}
+]
+keywords = ["monitoring", "error-tracking", "apm", "audit", "devinspector", "fastapi", "flask"]
+dependencies = []
+
+# Classificadores ajudam os desenvolvedores a encontrarem seu pacote no PyPI
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: System :: Monitoring",
+]
+
+[project.optional-dependencies]
+fastapi = ["fastapi", "starlette"]
+flask = ["flask"]
+
+[project.urls]
+Homepage = "https://devinspector.com.br"
+# Documentation = "https://docs.devinspector.com.br" # Descomente se tiver

devinspector-2.0.6/PKG-INFO

@@ -1,15 +0,0 @@
-Metadata-Version: 2.4
-Name: devinspector
-Version: 2.0.6
-Summary: SDK Python de monitoramento e auditoria em tempo real | DevInspector
-Author-email: DevInspector <suporte@devinspector.com.br>
-License: MIT
-Project-URL: Homepage, https://devinspector.com.br
-Keywords: monitoring,error-tracking,audit,devinspector,fastapi,flask
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-Provides-Extra: fastapi
-Requires-Dist: fastapi; extra == "fastapi"
-Requires-Dist: starlette; extra == "fastapi"
-Provides-Extra: flask
-Requires-Dist: flask; extra == "flask"

devinspector-2.0.6/devinspector/__init__.py

@@ -1,3 +0,0 @@
-from .core import AuditCore, audit
-
-__all__ = ["audit", "AuditCore"]

devinspector-2.0.6/devinspector/core.py

@@ -1,214 +0,0 @@
-import sys
-import json
-import time
-import queue
-import threading
-import traceback
-import urllib.request
-from datetime import datetime, timezone
-from typing import Any, Dict, Optional
-
-
-class AuditCore:
-    def __init__(self):
-        self.api_key: str = "PENDING_API_KEY"
-        self.endpoint: str = "https://api.devinspector.com.br/api/ingest/track"
-        self.environment: str = "production"
-        self.initialized: bool = False
-        self._listeners_attached: bool = False
-
-        # Fila e thread em background para envio assíncrono
-        self._queue: queue.Queue = queue.Queue(maxsize=10000)
-        self._shutdown_event = threading.Event()
-        self._worker_thread = threading.Thread(target=self._worker, daemon=True)
-        self._worker_thread.start()
-
-    def init(
-        self,
-        api_key: str,
-        endpoint: Optional[str] = None,
-        environment: Optional[str] = None,
-    ) -> None:
-        if not api_key:
-            print("[AuditSDK] API Key não fornecida no init().")
-            return
-
-        self.api_key = api_key
-        if endpoint:
-            self.endpoint = endpoint
-        if environment:
-            self.environment = environment
-
-        self.initialized = True
-        self._listen_global_errors()
-
-    def capture_request(
-        self,
-        method: str,
-        url: str,
-        status_code: int,
-        duration_ms: float,
-        user_agent: str = "",
-    ) -> None:
-        payload = {
-            "type": "request_metric",
-            "message": f"{method} {url} - {status_code}",
-            "method": method,
-            "url": url,
-            "statusCode": status_code,
-            "durationMs": round(duration_ms, 2),
-            "browser": user_agent,
-            "metadata": {
-                "environment": self.environment,
-                "timestamp": datetime.now(timezone.utc).isoformat(),
-            },
-        }
-        self._enqueue(payload)
-
-    def capture_error(
-        self, error: Exception, metadata: Optional[Dict[str, Any]] = None
-    ) -> None:
-        raw_message = str(error) or "Erro Desconhecido"
-        raw_stack = "".join(traceback.format_tb(error.__traceback__))
-
-        meta = metadata.copy() if metadata else {}
-        meta.update(
-            {
-                "environment": self.environment,
-                "timestamp": datetime.now(timezone.utc).isoformat(),
-            }
-        )
-
-        payload = {
-            "type": "error",
-            "message": self._truncate(raw_message, 500),
-            "stackTrace": self._truncate(raw_stack, 10000),
-            "url": "",
-            "browser": f"Python/{sys.version.split()[0]}",
-            "metadata": self._truncate(meta, 5000),
-        }
-        self._enqueue(payload)
-
-    def capture_exception(
-        self, error: Exception, metadata: Optional[Dict[str, Any]] = None
-    ) -> None:
-        self.capture_error(error, metadata)
-
-    def capture_message(
-        self, message: str, metadata: Optional[Dict[str, Any]] = None
-    ) -> None:
-        meta = metadata.copy() if metadata else {}
-        meta.update(
-            {
-                "level": "info",
-                "environment": self.environment,
-                "timestamp": datetime.now(timezone.utc).isoformat(),
-            }
-        )
-
-        payload = {
-            "type": "message",
-            "message": self._truncate(message, 500),
-            "stackTrace": "",
-            "url": "",
-            "browser": f"Python/{sys.version.split()[0]}",
-            "metadata": self._truncate(meta, 5000),
-        }
-        self._enqueue(payload)
-
-    def _listen_global_errors(self) -> None:
-        if self._listeners_attached:
-            return
-        self._listeners_attached = True
-
-        original_excepthook = sys.excepthook
-
-        def custom_excepthook(exc_type, exc_value, exc_traceback):
-            if issubclass(exc_type, KeyboardInterrupt):
-                original_excepthook(exc_type, exc_value, exc_traceback)
-                return
-
-            self.capture_error(
-                exc_value,
-                metadata={"type": "uncaught_exception", "exc_type": exc_type.__name__},
-            )
-            original_excepthook(exc_type, exc_value, exc_traceback)
-
-        sys.excepthook = custom_excepthook
-
-        # Captura exceções em Threads secundárias (Python 3.8+)
-        if hasattr(threading, "excepthook"):
-
-            def custom_thread_excepthook(args):
-                self.capture_error(
-                    args.exc_value,
-                    metadata={
-                        "type": "uncaught_thread_exception",
-                        "thread": args.thread.name,
-                    },
-                )
-
-            threading.excepthook = custom_thread_excepthook
-
-    def _truncate(self, value: Any, max_length: int = 5000) -> Any:
-        if isinstance(value, str):
-            return (
-                value[:max_length] + "... [truncated]"
-                if len(value) > max_length
-                else value
-            )
-
-        if isinstance(value, dict):
-            return {
-                str(k): self._truncate(v, max_length) for k, v in value.items()
-            }
-
-        return value
-
-    def _enqueue(self, payload: dict) -> None:
-        try:
-            self._queue.put_nowait(payload)
-        except queue.Full:
-            pass
-
-    def _worker(self) -> None:
-        while not self._shutdown_event.is_set():
-            try:
-                payload = self._queue.get(timeout=0.5)
-                self._send(payload)
-                self._queue.task_done()
-            except queue.Empty:
-                continue
-
-    def _send(self, payload: dict) -> None:
-        active_key = (
-            self.api_key
-            if self.api_key and self.api_key != "PENDING_API_KEY"
-            else "dev-fallback-key"
-        )
-        data_bytes = json.dumps(payload).encode("utf-8")
-
-        req = urllib.request.Request(
-            self.endpoint,
-            data=data_bytes,
-            headers={
-                "Content-Type": "application/json",
-                "x-api-key": active_key,
-            },
-            method="POST",
-        )
-
-        try:
-            with urllib.request.urlopen(req, timeout=5):
-                pass
-        except urllib.error.HTTPError as e:
-            # Mostra o erro detalhado que o painel devolveu
-            error_body = e.read().decode('utf-8', errors='ignore')
-            print(f"[DevInspector] HTTP {e.code} do painel: {e.reason} - Resposta: {error_body}")
-            print(f"[DevInspector] Payload enviado que gerou o erro: {payload}")
-        except Exception as err:
-            print(f"[DevInspector] Falha ao enviar requisição para o painel: {err}")
-
-
-# Singleton Global
-audit = AuditCore()

devinspector-2.0.6/devinspector/fastapi.py

@@ -1,39 +0,0 @@
-import time
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.requests import Request
-from .core import audit
-
-
-class DevInspectorMiddleware(BaseHTTPMiddleware):
-    async def dispatch(self, request: Request, call_next):
-        start_time = time.perf_counter()
-        status_code = 500
-
-        try:
-            response = await call_next(request)
-            status_code = response.status_code
-            return response
-        except Exception as exc:
-            if hasattr(exc, "status_code"):
-                status_code = exc.status_code
-
-            audit.capture_error(
-                exc,
-                metadata={
-                    "path": request.url.path,
-                    "method": request.method,
-                    "statusCode": status_code,
-                },
-            )
-            raise exc
-        finally:
-            duration_ms = (time.perf_counter() - start_time) * 1000
-            user_agent = request.headers.get("user-agent", "")
-
-            audit.capture_request(
-                method=request.method,
-                url=str(request.url),
-                status_code=status_code,
-                duration_ms=duration_ms,
-                user_agent=user_agent,
-            )

devinspector-2.0.6/devinspector/flask.py

@@ -1,55 +0,0 @@
-import time
-from flask import Flask, g, request
-from .core import audit
-
-
-class DevInspectorFlask:
-    def __init__(self, app: Flask = None):
-        if app is not None:
-            self.init_app(app)
-
-    def init_app(self, app: Flask):
-        app.before_request(self._before_request)
-        app.after_request(self._after_request)
-        app.teardown_request(self._teardown_request)
-
-    def _before_request(self):
-        g._devinspector_start_time = time.perf_counter()
-
-    def _after_request(self, response):
-        self._record_metric(response.status_code)
-        return response
-
-    def _teardown_request(self, exception=None):
-        if exception:
-            status_code = 500
-            if hasattr(exception, "code"):
-                status_code = exception.code
-
-            audit.capture_error(
-                exception,
-                metadata={
-                    "path": request.path,
-                    "method": request.method,
-                    "statusCode": status_code,
-                },
-            )
-            if not getattr(g, "_devinspector_metric_recorded", False):
-                self._record_metric(status_code)
-
-    def _record_metric(self, status_code: int):
-        start_time = getattr(g, "_devinspector_start_time", None)
-        if start_time is None:
-            return
-
-        duration_ms = (time.perf_counter() - start_time) * 1000
-        user_agent = request.headers.get("User-Agent", "")
-
-        audit.capture_request(
-            method=request.method,
-            url=request.url,
-            status_code=status_code,
-            duration_ms=duration_ms,
-            user_agent=user_agent,
-        )
-        g._devinspector_metric_recorded = True

devinspector-2.0.6/devinspector.egg-info/PKG-INFO

@@ -1,15 +0,0 @@
-Metadata-Version: 2.4
-Name: devinspector
-Version: 2.0.6
-Summary: SDK Python de monitoramento e auditoria em tempo real | DevInspector
-Author-email: DevInspector <suporte@devinspector.com.br>
-License: MIT
-Project-URL: Homepage, https://devinspector.com.br
-Keywords: monitoring,error-tracking,audit,devinspector,fastapi,flask
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-Provides-Extra: fastapi
-Requires-Dist: fastapi; extra == "fastapi"
-Requires-Dist: starlette; extra == "fastapi"
-Provides-Extra: flask
-Requires-Dist: flask; extra == "flask"

devinspector-2.0.6/pyproject.toml

@@ -1,23 +0,0 @@
-[build-system]
-requires = ["setuptools>=61.0"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "devinspector"
-version = "2.0.6"
-description = "SDK Python de monitoramento e auditoria em tempo real | DevInspector"
-readme = "README.md"
-requires-python = ">=3.8"
-license = {text = "MIT"}
-authors = [
-    {name = "DevInspector", email = "suporte@devinspector.com.br"}
-]
-keywords = ["monitoring", "error-tracking", "audit", "devinspector", "fastapi", "flask"]
-dependencies = []
-
-[project.optional-dependencies]
-fastapi = ["fastapi", "starlette"]
-flask = ["flask"]
-
-[project.urls]
-Homepage = "https://devinspector.com.br"