logbrew-fastapi 0.1.7__tar.gz → 0.1.9__tar.gz

{logbrew_fastapi-0.1.7 → logbrew_fastapi-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: logbrew-fastapi
-Version: 0.1.7
+Version: 0.1.9
 Summary: FastAPI integration for capturing LogBrew request spans and exceptions.
 Author: LogBrew
 License-Expression: MIT
@@ -19,7 +19,9 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: fastapi>=0.111.1
-Requires-Dist: logbrew-sdk<0.2.0,>=0.1.6
+Requires-Dist: logbrew-sdk<0.2.0,>=0.1.9
+Provides-Extra: celery
+Requires-Dist: logbrew-sdk[celery]<0.2.0,>=0.1.9; extra == "celery"
 
 # logbrew-fastapi
 
@@ -65,7 +67,7 @@ def health() -> dict[str, bool]:
     return {"ok": True}
 ```
 
-`init_logbrew()` records successful requests as spans and unhandled handler exceptions as issues plus error spans. It owns a real `HttpTransport`, uses the core SDK's bounded background delivery, and performs a final exact flush after the app's own default or custom FastAPI lifespan teardown. Network delivery never blocks the request path.
+`init_logbrew()` records successful requests as spans and unhandled handler exceptions as issues plus error spans. Exception issues include first-class exception type, `fastapi.middleware` mechanism, unhandled state, and up to 32 sanitized newest-first traceback frames. The frame projection contains basename and bounded code identity only; it omits raw traceback text, source code, local variables, and absolute paths. Exception messages keep the integration's existing `str(error)` behavior, so applications should avoid sensitive values in exception text. It owns a real `HttpTransport`, uses the core SDK's bounded background delivery, and performs a final exact flush after the app's own default or custom FastAPI lifespan teardown. Network delivery never blocks the request path.
 
 The returned runtime exposes content-free delivery diagnostics:
 
@@ -186,7 +188,31 @@ def checkout(order_id: str) -> dict[str, object]:
 
 Run `python -m logbrew_fastapi.examples dependency-spans` to see a local request span parenting SQLite, cache, and queue child spans from an installed package. LogBrew does not patch database drivers, cache clients, queue frameworks, or broker metadata globally, and the helpers avoid SQL values, cache keys/values, queue bodies, headers, baggage, and tracestate.
 
-Request duration metrics are opt-in. Set `capture_request_metrics=True` to emit an explicit `http.server.duration` histogram for completed requests:
+## Celery background jobs
+
+Install the optional Celery path when a FastAPI service publishes or processes Celery jobs:
+
+```bash
+python3 -m pip install "logbrew-fastapi[celery]"
+```
+
+The base FastAPI install stays Celery-free. The extra installs the compatible core Celery integration, which you attach only to the Celery app your service owns:
+
+```python
+from celery import Celery
+from logbrew_sdk import instrument_celery_app_with_logbrew_spans
+
+celery_app = Celery("checkout")
+celery_telemetry = instrument_celery_app_with_logbrew_spans(
+    celery_app,
+    client=client,
+    metadata={"service": "checkout-worker"},
+)
+```
+
+Producer and worker spans share W3C trace context. An unexpected final task failure emits one trace-correlated issue with task name and exception type only; retries and exception types declared through `task.throws` stay span-only. Task IDs, arguments, results, headers, exception messages, and stack traces are excluded. Uninstall direct instrumentation after tasks drain and before shutting down its client. Separate prefork workers need child-owned clients; follow the [core Celery lifecycle and encrypted persistence setup](https://github.com/LogBrewCo/sdk/tree/main/python/logbrew_py#automatic-celery-spans) instead of sharing the FastAPI process client across forks.
+
+Request duration metrics are opt-in. Set `capture_request_metrics=True` to emit an explicit `http.server.duration` histogram for completed requests. Each generated metric carries the stable description `Duration of one completed server request.` so its purpose remains clear in investigations:
 
 ```python
 logbrew = init_logbrew(

{logbrew_fastapi-0.1.7 → logbrew_fastapi-0.1.9}/README.md

@@ -42,7 +42,7 @@ def health() -> dict[str, bool]:
     return {"ok": True}
 ```
 
-`init_logbrew()` records successful requests as spans and unhandled handler exceptions as issues plus error spans. It owns a real `HttpTransport`, uses the core SDK's bounded background delivery, and performs a final exact flush after the app's own default or custom FastAPI lifespan teardown. Network delivery never blocks the request path.
+`init_logbrew()` records successful requests as spans and unhandled handler exceptions as issues plus error spans. Exception issues include first-class exception type, `fastapi.middleware` mechanism, unhandled state, and up to 32 sanitized newest-first traceback frames. The frame projection contains basename and bounded code identity only; it omits raw traceback text, source code, local variables, and absolute paths. Exception messages keep the integration's existing `str(error)` behavior, so applications should avoid sensitive values in exception text. It owns a real `HttpTransport`, uses the core SDK's bounded background delivery, and performs a final exact flush after the app's own default or custom FastAPI lifespan teardown. Network delivery never blocks the request path.
 
 The returned runtime exposes content-free delivery diagnostics:
 
@@ -163,7 +163,31 @@ def checkout(order_id: str) -> dict[str, object]:
 
 Run `python -m logbrew_fastapi.examples dependency-spans` to see a local request span parenting SQLite, cache, and queue child spans from an installed package. LogBrew does not patch database drivers, cache clients, queue frameworks, or broker metadata globally, and the helpers avoid SQL values, cache keys/values, queue bodies, headers, baggage, and tracestate.
 
-Request duration metrics are opt-in. Set `capture_request_metrics=True` to emit an explicit `http.server.duration` histogram for completed requests:
+## Celery background jobs
+
+Install the optional Celery path when a FastAPI service publishes or processes Celery jobs:
+
+```bash
+python3 -m pip install "logbrew-fastapi[celery]"
+```
+
+The base FastAPI install stays Celery-free. The extra installs the compatible core Celery integration, which you attach only to the Celery app your service owns:
+
+```python
+from celery import Celery
+from logbrew_sdk import instrument_celery_app_with_logbrew_spans
+
+celery_app = Celery("checkout")
+celery_telemetry = instrument_celery_app_with_logbrew_spans(
+    celery_app,
+    client=client,
+    metadata={"service": "checkout-worker"},
+)
+```
+
+Producer and worker spans share W3C trace context. An unexpected final task failure emits one trace-correlated issue with task name and exception type only; retries and exception types declared through `task.throws` stay span-only. Task IDs, arguments, results, headers, exception messages, and stack traces are excluded. Uninstall direct instrumentation after tasks drain and before shutting down its client. Separate prefork workers need child-owned clients; follow the [core Celery lifecycle and encrypted persistence setup](https://github.com/LogBrewCo/sdk/tree/main/python/logbrew_py#automatic-celery-spans) instead of sharing the FastAPI process client across forks.
+
+Request duration metrics are opt-in. Set `capture_request_metrics=True` to emit an explicit `http.server.duration` histogram for completed requests. Each generated metric carries the stable description `Duration of one completed server request.` so its purpose remains clear in investigations:
 
 ```python
 logbrew = init_logbrew(

{logbrew_fastapi-0.1.7 → logbrew_fastapi-0.1.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "logbrew-fastapi"
-version = "0.1.7"
+version = "0.1.9"
 description = "FastAPI integration for capturing LogBrew request spans and exceptions."
 readme = "README.md"
 license = "MIT"
@@ -27,9 +27,12 @@ classifiers = [
 ]
 dependencies = [
   "fastapi>=0.111.1",
-  "logbrew-sdk>=0.1.6,<0.2.0"
+  "logbrew-sdk>=0.1.9,<0.2.0"
 ]
 
+[project.optional-dependencies]
+celery = ["logbrew-sdk[celery]>=0.1.9,<0.2.0"]
+
 [project.urls]
 Repository = "https://github.com/LogBrewCo/sdk"
 

{logbrew_fastapi-0.1.7 → logbrew_fastapi-0.1.9}/src/logbrew_fastapi/__init__.py

@@ -24,6 +24,7 @@ from logbrew_sdk import (
     Transport,
     TransportError,
     TransportResponse,
+    create_issue_attributes_from_exception,
     create_logbrew_trace_context,
     get_active_logbrew_trace,
     parse_traceparent,
@@ -320,6 +321,7 @@ def create_request_metric_attributes(
         duration_value = 0.0
     return {
         "name": metric_name,
+        "description": "Duration of one completed server request.",
         "kind": "histogram",
         "value": duration_value,
         "unit": "ms",
@@ -416,19 +418,21 @@ def capture_exception(
 
     issue_event_id = event_id or f"evt_fastapi_issue_{uuid.uuid4().hex}"
     trace_context = trace or request_logbrew_trace(request) or get_active_logbrew_trace()
+    captured_at = timestamp or utc_timestamp()
     client.issue(
         issue_event_id,
-        timestamp or utc_timestamp(),
-        {
-            "title": f"{request_name(request)} failed",
-            "level": "error",
-            "message": str(exc) or exc.__class__.__name__,
-            "metadata": {
+        captured_at,
+        create_issue_attributes_from_exception(
+            exc,
+            title=f"{request_name(request)} failed",
+            mechanism="fastapi.middleware",
+            handled=False,
+            metadata={
                 **request_metadata(request, status_code=500, service_name=service_name),
                 "exception_type": exc.__class__.__name__,
                 **trace_metadata(trace_context),
             },
-        },
+        ),
     )
     return issue_event_id
 

{logbrew_fastapi-0.1.7 → logbrew_fastapi-0.1.9}/src/logbrew_fastapi.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: logbrew-fastapi
-Version: 0.1.7
+Version: 0.1.9
 Summary: FastAPI integration for capturing LogBrew request spans and exceptions.
 Author: LogBrew
 License-Expression: MIT
@@ -19,7 +19,9 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: fastapi>=0.111.1
-Requires-Dist: logbrew-sdk<0.2.0,>=0.1.6
+Requires-Dist: logbrew-sdk<0.2.0,>=0.1.9
+Provides-Extra: celery
+Requires-Dist: logbrew-sdk[celery]<0.2.0,>=0.1.9; extra == "celery"
 
 # logbrew-fastapi
 
@@ -65,7 +67,7 @@ def health() -> dict[str, bool]:
     return {"ok": True}
 ```
 
-`init_logbrew()` records successful requests as spans and unhandled handler exceptions as issues plus error spans. It owns a real `HttpTransport`, uses the core SDK's bounded background delivery, and performs a final exact flush after the app's own default or custom FastAPI lifespan teardown. Network delivery never blocks the request path.
+`init_logbrew()` records successful requests as spans and unhandled handler exceptions as issues plus error spans. Exception issues include first-class exception type, `fastapi.middleware` mechanism, unhandled state, and up to 32 sanitized newest-first traceback frames. The frame projection contains basename and bounded code identity only; it omits raw traceback text, source code, local variables, and absolute paths. Exception messages keep the integration's existing `str(error)` behavior, so applications should avoid sensitive values in exception text. It owns a real `HttpTransport`, uses the core SDK's bounded background delivery, and performs a final exact flush after the app's own default or custom FastAPI lifespan teardown. Network delivery never blocks the request path.
 
 The returned runtime exposes content-free delivery diagnostics:
 
@@ -186,7 +188,31 @@ def checkout(order_id: str) -> dict[str, object]:
 
 Run `python -m logbrew_fastapi.examples dependency-spans` to see a local request span parenting SQLite, cache, and queue child spans from an installed package. LogBrew does not patch database drivers, cache clients, queue frameworks, or broker metadata globally, and the helpers avoid SQL values, cache keys/values, queue bodies, headers, baggage, and tracestate.
 
-Request duration metrics are opt-in. Set `capture_request_metrics=True` to emit an explicit `http.server.duration` histogram for completed requests:
+## Celery background jobs
+
+Install the optional Celery path when a FastAPI service publishes or processes Celery jobs:
+
+```bash
+python3 -m pip install "logbrew-fastapi[celery]"
+```
+
+The base FastAPI install stays Celery-free. The extra installs the compatible core Celery integration, which you attach only to the Celery app your service owns:
+
+```python
+from celery import Celery
+from logbrew_sdk import instrument_celery_app_with_logbrew_spans
+
+celery_app = Celery("checkout")
+celery_telemetry = instrument_celery_app_with_logbrew_spans(
+    celery_app,
+    client=client,
+    metadata={"service": "checkout-worker"},
+)
+```
+
+Producer and worker spans share W3C trace context. An unexpected final task failure emits one trace-correlated issue with task name and exception type only; retries and exception types declared through `task.throws` stay span-only. Task IDs, arguments, results, headers, exception messages, and stack traces are excluded. Uninstall direct instrumentation after tasks drain and before shutting down its client. Separate prefork workers need child-owned clients; follow the [core Celery lifecycle and encrypted persistence setup](https://github.com/LogBrewCo/sdk/tree/main/python/logbrew_py#automatic-celery-spans) instead of sharing the FastAPI process client across forks.
+
+Request duration metrics are opt-in. Set `capture_request_metrics=True` to emit an explicit `http.server.duration` histogram for completed requests. Each generated metric carries the stable description `Duration of one completed server request.` so its purpose remains clear in investigations:
 
 ```python
 logbrew = init_logbrew(

logbrew_fastapi-0.1.9/src/logbrew_fastapi.egg-info/requires.txt

@@ -0,0 +1,5 @@
+fastapi>=0.111.1
+logbrew-sdk<0.2.0,>=0.1.9
+
+[celery]
+logbrew-sdk[celery]<0.2.0,>=0.1.9

{logbrew_fastapi-0.1.7 → logbrew_fastapi-0.1.9}/tests/test_fastapi_integration.py

@@ -234,6 +234,7 @@ class FastAPIIntegrationTests(unittest.TestCase):
         self.assertEqual([event["type"] for event in payload["events"]], ["metric"])
         metric = payload["events"][0]["attributes"]
         self.assertEqual(metric["name"], "http.server.duration")
+        self.assertEqual(metric["description"], "Duration of one completed server request.")
         self.assertEqual(metric["kind"], "histogram")
         self.assertGreaterEqual(metric["value"], 0)
         self.assertEqual(metric["unit"], "ms")
@@ -379,6 +380,15 @@ class FastAPIIntegrationTests(unittest.TestCase):
         span = payload["events"][1]["attributes"]
         self.assertEqual(issue["title"], "GET /boom failed")
         self.assertEqual(issue["message"], "broken handler")
+        self.assertEqual(
+            issue["exception"],
+            {
+                "type": "RuntimeError",
+                "mechanism": {"type": "fastapi.middleware", "handled": False},
+            },
+        )
+        self.assertEqual(issue["stackFrames"][0]["filename"], "test_fastapi_integration.py")
+        self.assertEqual(issue["stackFrames"][0]["function"], "boom")
         self.assertEqual(issue["metadata"]["exception_type"], "RuntimeError")
         self.assertEqual(span["status"], "error")
         self.assertEqual(span["metadata"]["status_code"], 500)

logbrew_fastapi-0.1.7/src/logbrew_fastapi.egg-info/requires.txt

@@ -1,2 +0,0 @@
-fastapi>=0.111.1
-logbrew-sdk<0.2.0,>=0.1.6