devlite 0.1.0__tar.gz → 0.1.2__tar.gz

{devlite-0.1.0/devlite.egg-info → devlite-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devlite
-Version: 0.1.0
+Version: 0.1.2
 Summary: DevLite Python SDK — AI-powered observability with a 2-line integration. Automatic error grouping, source context, user impact tracking, and sensitive-data scrubbing built in.
 License: MIT
 Project-URL: Homepage, https://devlite.io
@@ -18,8 +18,16 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: flask
 Requires-Dist: flask>=2.0; extra == "flask"
+Provides-Extra: fastapi
+Requires-Dist: fastapi>=0.100; extra == "fastapi"
+Provides-Extra: django
+Requires-Dist: django>=4.0; extra == "django"
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
+Requires-Dist: flask>=2.0; extra == "test"
+Requires-Dist: fastapi>=0.100; extra == "test"
+Requires-Dist: django>=4.0; extra == "test"
+Requires-Dist: httpx>=0.27; extra == "test"
 Dynamic: license-file
 
 # devlite — Python SDK
@@ -31,8 +39,10 @@ This is the Python counterpart of [`@devlite/nodejs`](https://www.npmjs.com/pack
 ## Install
 
 ```bash
-pip install devlite            # core (Flask optional)
+pip install devlite            # core (Flask/FastAPI/Django optional)
 pip install "devlite[flask]"   # + Flask instrumentation
+pip install "devlite[fastapi]" # + FastAPI instrumentation
+pip install "devlite[django]"  # + Django instrumentation
 ```
 
 ## 60-second quickstart (Flask)
@@ -56,6 +66,42 @@ That's it — every HTTP request, slow endpoint, and unhandled exception is now
 
 Point `api_key`/`endpoint` at your own DevLite ingest instance (Supabase-backed) to start seeing data.
 
+## Auto-instrumentation for every framework
+
+One call per framework, with the same automatic request/slow-request/error/user tracking:
+
+**FastAPI** (any Starlette app) — call right after creating the app:
+
+```python
+from fastapi import FastAPI
+import devlite
+
+devlite.init(api_key="dl_live_xxxxx")
+
+app = FastAPI()
+devlite.instrument_fastapi(app)   # before the server starts
+```
+
+**Django** — `instrument_django()` inserts `devlite._django.InstrumentDjangoMiddleware` at the top of your `MIDDLEWARE` setting:
+
+```python
+import devlite
+
+devlite.init(api_key="dl_live_xxxxx")
+devlite.instrument_django()
+```
+
+Or add the middleware manually (must be near the top, index 0 ideally):
+
+```python
+MIDDLEWARE = [
+    "devlite._django.InstrumentDjangoMiddleware",
+    ...
+]
+```
+
+Any other framework (or plain WSGI/ASGI) still works through the manual API below.
+
 ## Manual capture API
 
 ```python
@@ -91,11 +137,19 @@ devlite.set_tag("region", "lagos")
 `set_user()` is scoped to the current request (via `contextvars`, so concurrent requests never leak each other's identity):
 
 ```python
+# Flask
 from flask import request
 
 @app.before_request
 def identify():
     devlite.set_user({"id": request.remote_addr, "email": request.headers.get("X-User-Email")})
+
+# FastAPI — inside any endpoint
+devlite.set_user({"id": "u-123", "email": "a@example.com"})
+
+# Django — inside any view
+def my_view(request):
+    devlite.set_user({"id": request.user.id, "email": request.user.email})
 ```
 
 ## Configuration options
@@ -145,7 +199,7 @@ devlite.close()
 ## Development
 
 ```bash
-pip install -e ".[flask,test]"
+pip install -e ".[flask,fastapi,django,test]"
 python -m pytest
 ```
 

devlite-0.1.0/PKG-INFO → devlite-0.1.2/README.md

@@ -1,154 +1,176 @@
-Metadata-Version: 2.4
-Name: devlite
-Version: 0.1.0
-Summary: DevLite Python SDK — AI-powered observability with a 2-line integration. Automatic error grouping, source context, user impact tracking, and sensitive-data scrubbing built in.
-License: MIT
-Project-URL: Homepage, https://devlite.io
-Project-URL: Repository, https://github.com/Ishimwe-Kevin/devlite-app
-Keywords: observability,monitoring,apm,error-tracking,error-monitoring,logging,ai,devlite
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Software Development :: Debuggers
-Classifier: Topic :: System :: Monitoring
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Provides-Extra: flask
-Requires-Dist: flask>=2.0; extra == "flask"
-Provides-Extra: test
-Requires-Dist: pytest; extra == "test"
-Dynamic: license-file
-
-# devlite — Python SDK
-
-AI-powered observability for Python. Add two lines, get automatic request tracking, error capture, error grouping, source context, user tracking, and slow-endpoint detection — no config files, no manual instrumentation, **zero runtime dependencies**.
-
-This is the Python counterpart of [`@devlite/nodejs`](https://www.npmjs.com/package/@devlite/nodejs) — both SDKs speak the same batch protocol to the [DevLite ingest API](https://github.com/Ishimwe-Kevin/devlite-app).
-
-## Install
-
-```bash
-pip install devlite            # core (Flask optional)
-pip install "devlite[flask]"   # + Flask instrumentation
-```
-
-## 60-second quickstart (Flask)
-
-```python
-from flask import Flask
-import devlite
-
-devlite.init(api_key="dl_live_xxxxx")
-
-app = Flask(__name__)
-devlite.instrument_flask(app)
-```
-
-That's it — every HTTP request, slow endpoint, and unhandled exception is now captured automatically, with:
-
-- **Grouped errors** — the same bug occurring 1,000 times shows up as one issue, not 1,000
-- **Real source code context** — the actual lines around the crash, read live from disk
-- **Automatic sensitive-data scrubbing** — emails, tokens, passwords redacted before anything leaves your process
-- **User impact tracking** — know exactly which users hit which bugs
-
-Point `api_key`/`endpoint` at your own DevLite ingest instance (Supabase-backed) to start seeing data.
-
-## Manual capture API
-
-```python
-# Capture a handled error with extra context
-devlite.capture_error(err, {"userId": "123", "action": "checkout"})
-devlite.capture_error(err, {"fingerprint": "payment-timeout"})  # force grouping key
-
-# Non-error event
-devlite.capture_message("Payment retried after timeout", "warning")
-
-# Custom metric — feeds forecasting/anomaly detection
-devlite.report_metric("order.total", 42.5, unit="USD", tags={"region": "lagos"})
-
-# Structured log line
-devlite.capture_log("checkout completed", "info", {"orderId": "ord_123", "durationMs": 250})
-
-# Trace a unit of work
-span = devlite.start_span("checkout.process", {"trace_id": "abc"})
-span.end("ok")  # "ok" | "error"
-
-# Tell DevLite about a deployment (powers before/after performance views)
-devlite.report_deployment(version="v2.1.3", commit_sha="a1b2c3d")
-
-# Breadcrumbs attach to the next captured error, improving AI root-cause
-devlite.add_breadcrumb({"type": "business_event", "note": "user started checkout"})
-
-# Tag all subsequent events
-devlite.set_tag("region", "lagos")
-```
-
-## User impact tracking
-
-`set_user()` is scoped to the current request (via `contextvars`, so concurrent requests never leak each other's identity):
-
-```python
-from flask import request
-
-@app.before_request
-def identify():
-    devlite.set_user({"id": request.remote_addr, "email": request.headers.get("X-User-Email")})
-```
-
-## Configuration options
-
-```python
-devlite.init({
-    "api_key": "dl_live_xxxxx",        # required
-    "environment": "production",        # default: $DEVLITE_ENVIRONMENT or "development"
-    "service_name": "payments-api",     # default: $DEVLITE_SERVICE_NAME or current folder
-    "release": "v2.1.3",                # e.g. git sha, shown in deployment views
-    "sample_rate": 1.0,                 # 0.0–1.0. Sampling is COHERENT: a sampled-out
-                                        # request drops its errors/spans/logs/metrics together.
-    "capture_body": False,              # capture (redacted) request headers — off by default
-    "flush_interval_ms": 5000,          # how often batched events are sent
-    "gzip": True,                       # compress request bodies (Content-Encoding: gzip)
-    "debug": False,                     # log SDK internals
-    "on_error": lambda err: print(err), # SDK-internal send failures
-})
-```
-
-All of `api_key`, `service_name`, `release`, and `endpoint` can also be set via environment variables (`DEVLITE_API_KEY`, `DEVLITE_SERVICE_NAME`, `DEVLITE_RELEASE`, `DEVLITE_ENDPOINT`).
-
-## Serverless / short-lived processes
-
-Events are batched, so call `flush()` before your function returns:
-
-```python
-devlite.flush()
-```
-
-## Graceful shutdown
-
-The SDK flushes remaining events on interpreter exit (`atexit`). If you manage shutdown yourself:
-
-```python
-devlite.close()
-```
-
-## What makes this competitive
-
-- **Automatic error grouping** — the same underlying bug, however many times it fires, is fingerprinted and grouped into one issue, instead of flooding your dashboard with duplicates.
-- **Source code context** — every captured error includes the actual lines of code around the crash, read live from disk, not just a bare stack trace.
-- **Automatic sensitive-data scrubbing** — on by default. Emails, JWTs, bearer tokens, AWS keys, credit card numbers, and any field literally named `password`/`token`/`secret` are redacted before anything leaves your process.
-- **Never blocks your app** — all sends are async (background thread), batched, and retried with backoff. If DevLite's backend is unreachable, your app keeps running.
-- **Zero dependencies** — pure Python standard library.
-
-## Development
-
-```bash
-pip install -e ".[flask,test]"
-python -m pytest
-```
-
-## License
-
-MIT
+# devlite — Python SDK
+
+AI-powered observability for Python. Add two lines, get automatic request tracking, error capture, error grouping, source context, user tracking, and slow-endpoint detection — no config files, no manual instrumentation, **zero runtime dependencies**.
+
+This is the Python counterpart of [`@devlite/nodejs`](https://www.npmjs.com/package/@devlite/nodejs) — both SDKs speak the same batch protocol to the [DevLite ingest API](https://github.com/Ishimwe-Kevin/devlite-app).
+
+## Install
+
+```bash
+pip install devlite            # core (Flask/FastAPI/Django optional)
+pip install "devlite[flask]"   # + Flask instrumentation
+pip install "devlite[fastapi]" # + FastAPI instrumentation
+pip install "devlite[django]"  # + Django instrumentation
+```
+
+## 60-second quickstart (Flask)
+
+```python
+from flask import Flask
+import devlite
+
+devlite.init(api_key="dl_live_xxxxx")
+
+app = Flask(__name__)
+devlite.instrument_flask(app)
+```
+
+That's it — every HTTP request, slow endpoint, and unhandled exception is now captured automatically, with:
+
+- **Grouped errors** — the same bug occurring 1,000 times shows up as one issue, not 1,000
+- **Real source code context** — the actual lines around the crash, read live from disk
+- **Automatic sensitive-data scrubbing** — emails, tokens, passwords redacted before anything leaves your process
+- **User impact tracking** — know exactly which users hit which bugs
+
+Point `api_key`/`endpoint` at your own DevLite ingest instance (Supabase-backed) to start seeing data.
+
+## Auto-instrumentation for every framework
+
+One call per framework, with the same automatic request/slow-request/error/user tracking:
+
+**FastAPI** (any Starlette app) — call right after creating the app:
+
+```python
+from fastapi import FastAPI
+import devlite
+
+devlite.init(api_key="dl_live_xxxxx")
+
+app = FastAPI()
+devlite.instrument_fastapi(app)   # before the server starts
+```
+
+**Django** — `instrument_django()` inserts `devlite._django.InstrumentDjangoMiddleware` at the top of your `MIDDLEWARE` setting:
+
+```python
+import devlite
+
+devlite.init(api_key="dl_live_xxxxx")
+devlite.instrument_django()
+```
+
+Or add the middleware manually (must be near the top, index 0 ideally):
+
+```python
+MIDDLEWARE = [
+    "devlite._django.InstrumentDjangoMiddleware",
+    ...
+]
+```
+
+Any other framework (or plain WSGI/ASGI) still works through the manual API below.
+
+## Manual capture API
+
+```python
+# Capture a handled error with extra context
+devlite.capture_error(err, {"userId": "123", "action": "checkout"})
+devlite.capture_error(err, {"fingerprint": "payment-timeout"})  # force grouping key
+
+# Non-error event
+devlite.capture_message("Payment retried after timeout", "warning")
+
+# Custom metric — feeds forecasting/anomaly detection
+devlite.report_metric("order.total", 42.5, unit="USD", tags={"region": "lagos"})
+
+# Structured log line
+devlite.capture_log("checkout completed", "info", {"orderId": "ord_123", "durationMs": 250})
+
+# Trace a unit of work
+span = devlite.start_span("checkout.process", {"trace_id": "abc"})
+span.end("ok")  # "ok" | "error"
+
+# Tell DevLite about a deployment (powers before/after performance views)
+devlite.report_deployment(version="v2.1.3", commit_sha="a1b2c3d")
+
+# Breadcrumbs attach to the next captured error, improving AI root-cause
+devlite.add_breadcrumb({"type": "business_event", "note": "user started checkout"})
+
+# Tag all subsequent events
+devlite.set_tag("region", "lagos")
+```
+
+## User impact tracking
+
+`set_user()` is scoped to the current request (via `contextvars`, so concurrent requests never leak each other's identity):
+
+```python
+# Flask
+from flask import request
+
+@app.before_request
+def identify():
+    devlite.set_user({"id": request.remote_addr, "email": request.headers.get("X-User-Email")})
+
+# FastAPI — inside any endpoint
+devlite.set_user({"id": "u-123", "email": "a@example.com"})
+
+# Django — inside any view
+def my_view(request):
+    devlite.set_user({"id": request.user.id, "email": request.user.email})
+```
+
+## Configuration options
+
+```python
+devlite.init({
+    "api_key": "dl_live_xxxxx",        # required
+    "environment": "production",        # default: $DEVLITE_ENVIRONMENT or "development"
+    "service_name": "payments-api",     # default: $DEVLITE_SERVICE_NAME or current folder
+    "release": "v2.1.3",                # e.g. git sha, shown in deployment views
+    "sample_rate": 1.0,                 # 0.0–1.0. Sampling is COHERENT: a sampled-out
+                                        # request drops its errors/spans/logs/metrics together.
+    "capture_body": False,              # capture (redacted) request headers — off by default
+    "flush_interval_ms": 5000,          # how often batched events are sent
+    "gzip": True,                       # compress request bodies (Content-Encoding: gzip)
+    "debug": False,                     # log SDK internals
+    "on_error": lambda err: print(err), # SDK-internal send failures
+})
+```
+
+All of `api_key`, `service_name`, `release`, and `endpoint` can also be set via environment variables (`DEVLITE_API_KEY`, `DEVLITE_SERVICE_NAME`, `DEVLITE_RELEASE`, `DEVLITE_ENDPOINT`).
+
+## Serverless / short-lived processes
+
+Events are batched, so call `flush()` before your function returns:
+
+```python
+devlite.flush()
+```
+
+## Graceful shutdown
+
+The SDK flushes remaining events on interpreter exit (`atexit`). If you manage shutdown yourself:
+
+```python
+devlite.close()
+```
+
+## What makes this competitive
+
+- **Automatic error grouping** — the same underlying bug, however many times it fires, is fingerprinted and grouped into one issue, instead of flooding your dashboard with duplicates.
+- **Source code context** — every captured error includes the actual lines of code around the crash, read live from disk, not just a bare stack trace.
+- **Automatic sensitive-data scrubbing** — on by default. Emails, JWTs, bearer tokens, AWS keys, credit card numbers, and any field literally named `password`/`token`/`secret` are redacted before anything leaves your process.
+- **Never blocks your app** — all sends are async (background thread), batched, and retried with backoff. If DevLite's backend is unreachable, your app keeps running.
+- **Zero dependencies** — pure Python standard library.
+
+## Development
+
+```bash
+pip install -e ".[flask,fastapi,django,test]"
+python -m pytest
+```
+
+## License
+
+MIT

{devlite-0.1.0 → devlite-0.1.2}/devlite/__init__.py

@@ -12,13 +12,13 @@ Public API (all Pythonic snake_case):
     init, capture_error, capture_message, report_metric, capture_log,
     start_span, report_span, report_deployment, add_breadcrumb, set_tag,
     set_user, run_with_context, start_host_metrics, instrument_flask,
-    flush, close
+    instrument_fastapi, instrument_django, flush, close
 """
 
 from ._client import Client, HostMetricsHandle, Span
 from ._context import run_with_context
 
-__version__ = "0.1.0"
+__version__ = "0.1.1"
 
 _client = None
 
@@ -115,6 +115,16 @@ def instrument_flask(app):
     return _require_client().instrument_flask(app)
 
 
+def instrument_fastapi(app):
+    """Wire automatic request/error/user tracking into a FastAPI app."""
+    return _require_client().instrument_fastapi(app)
+
+
+def instrument_django():
+    """Insert DevLite's middleware at the top of Django's MIDDLEWARE setting."""
+    return _require_client().instrument_django()
+
+
 def flush():
     """Force-send whatever is currently queued (useful in serverless)."""
     _require_client().flush()
@@ -142,6 +152,8 @@ __all__ = [
     "run_with_context",
     "start_host_metrics",
     "instrument_flask",
+    "instrument_fastapi",
+    "instrument_django",
     "flush",
     "close",
 ]

{devlite-0.1.0 → devlite-0.1.2}/devlite/_client.py

@@ -5,7 +5,7 @@ import threading
 import uuid
 
 from ._config import build_config
-from ._context import Context, get_user, now_ms, run_with_context
+from ._context import Context, get_trace_id, get_user, new_trace_id, now_ms, run_with_context
 from ._errors import build_error_event
 from ._metrics import collect_host_metrics
 from ._scrub import scrub_deep
@@ -25,7 +25,7 @@ class Span:
         self.type = "span"
         self.id = options.get("id") or _new_hex(6)
         self.name = name
-        self.trace_id = options.get("trace_id") or _new_hex(8)
+        self.trace_id = options.get("trace_id") or get_trace_id() or new_trace_id()
         self.parent_id = options.get("parent_id")
         self.tags = options.get("tags") or {}
         self.start_time = now_ms()
@@ -103,7 +103,7 @@ class Client:
         self.transport.enqueue(event)
 
     def capture_message(self, message, level="info", extra=None):
-        raw = {"type": "message", "level": level, "message": message, "extra": extra or {}, "timestamp": now_ms()}
+        raw = {"type": "message", "level": level, "message": message, "extra": extra or {}, "traceId": get_trace_id(), "timestamp": now_ms()}
         self.transport.enqueue(scrub_deep(raw) if self._should_scrub() else raw)
 
     def report_metric(self, name, value, unit=None, tags=None):
@@ -111,11 +111,11 @@ class Client:
             raise ValueError("[DevLite] report_metric() requires a string `name`.")
         if not isinstance(value, (int, float)):
             raise ValueError("[DevLite] report_metric() requires a numeric `value`.")
-        raw = {"type": "metric", "name": name, "value": value, "unit": unit or None, "tags": tags or {}, "timestamp": now_ms()}
+        raw = {"type": "metric", "name": name, "value": value, "unit": unit or None, "tags": tags or {}, "traceId": get_trace_id(), "timestamp": now_ms()}
         self.transport.enqueue(scrub_deep(raw) if self._should_scrub() else raw)
 
     def capture_log(self, message, level="info", fields=None):
-        raw = {"type": "log", "level": level, "message": message, "fields": fields or {}, "timestamp": now_ms()}
+        raw = {"type": "log", "level": level, "message": message, "fields": fields or {}, "traceId": get_trace_id(), "timestamp": now_ms()}
         self.transport.enqueue(scrub_deep(raw) if self._should_scrub() else raw)
 
     def start_span(self, name, options=None):
@@ -126,7 +126,7 @@ class Client:
             "type": "span",
             "id": _new_hex(6),
             "name": name,
-            "traceId": trace_id or _new_hex(8),
+            "traceId": trace_id or get_trace_id() or new_trace_id(),
             "parentId": parent_id,
             "tags": tags or {},
             "startTime": start_time,
@@ -164,6 +164,16 @@ class Client:
 
         return instrument_flask(app, self.transport, self.context, self.config)
 
+    def instrument_fastapi(self, app):
+        from ._fastapi import instrument_fastapi
+
+        return instrument_fastapi(app, self.transport, self.context, self.config)
+
+    def instrument_django(self):
+        from ._django import instrument_django
+
+        return instrument_django(self)
+
     def flush(self):
         self.transport.flush()
 

{devlite-0.1.0 → devlite-0.1.2}/devlite/_context.py

@@ -1,4 +1,4 @@
-"""Request-scoped context: breadcrumbs, tags, and the current user.
+"""Request-scoped context: breadcrumbs, tags, the current user, and traceId.
 
 Python equivalent of context.js + userContext.js from the Node SDK. Uses
 contextvars (the modern replacement for thread-locals) so user context set
@@ -6,6 +6,7 @@ inside one request handler never leaks across concurrent requests.
 """
 
 import contextvars
+import secrets
 import time
 
 MAX_BREADCRUMBS = 20
@@ -13,6 +14,11 @@ MAX_BREADCRUMBS = 20
 _request_store = contextvars.ContextVar("devlite_request_store", default=None)
 
 
+def new_trace_id():
+    """A fresh 16-hex-char traceId (8 bytes), matching the Node SDK."""
+    return secrets.token_hex(8)
+
+
 def _store():
     store = _request_store.get()
     if store is None:
@@ -50,6 +56,19 @@ def run_with_context(fn, seed=None):
         _request_store.set(previous)
 
 
+def reset_context():
+    """Start a fresh request context for the current thread/task.
+
+    Unlike run_with_context this does NOT restore the previous value when
+    done — the fresh store stays active for the whole request. Framework
+    middleware calls this once per request so that a stale store (left
+    behind by a previous request on a reused thread, or inherited from the
+    caller's context, e.g. by anyio portal threads) can never leak user
+    data or breadcrumbs into the current request.
+    """
+    _request_store.set({})
+
+
 def set_user(user):
     """Scope a user to the current request context. Mirrors devlite.setUser()."""
     store = _store()
@@ -69,6 +88,17 @@ def set_sampled(value):
     store["sampled"] = value
 
 
+def set_trace_id(trace_id):
+    """Scope the current request's traceId so captured events link to it."""
+    store = _store()
+    store["traceId"] = trace_id
+
+
+def get_trace_id():
+    store = _request_store.get()
+    return (store or {}).get("traceId") or None
+
+
 def is_sampled_out():
     store = _request_store.get()
     return bool(store) and store.get("sampled") is False