lazers 0.1.0__tar.gz

lazers-0.1.0/LICENSE

@@ -0,0 +1,17 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   Copyright 2026 Emmanuel Ilori / Lazers Contributors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

lazers-0.1.0/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: lazers
+Version: 0.1.0
+Summary: Server-side Python SDK for Lazers Signal Protocol v1
+Author-email: Emmanuel Ilori <iloriemmanuel00@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/Emmydapson/lazers
+Project-URL: Repository, https://github.com/Emmydapson/lazers
+Project-URL: Issues, https://github.com/Emmydapson/lazers/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Lazers Python SDK
+
+Server-side Python SDK for Lazers Signal Protocol v1. It uses only the Python standard library and supports Python 3.10+.
+
+Repository: [https://github.com/Emmydapson/lazers](https://github.com/Emmydapson/lazers)
+
+## Installation
+
+```bash
+pip install lazers
+```
+
+## Quickstart
+
+```python
+from lazers import LazersClient
+
+client = LazersClient(
+    api_key="...",
+    endpoint="https://api.lazers.app",
+    project_id="project_1",
+    environment="production",
+    service_name="my-api",
+)
+
+client.capture_error(
+    RuntimeError("database timeout"),
+    actor={"type": "customer", "id": "cust_2048"},
+)
+
+# During shutdown:
+client.flush()
+```
+
+## Framework guidance
+
+FastAPI example: [`examples/fastapi.py`](examples/fastapi.py). Create the client once at app startup, capture in an exception handler, and call `flush()` on shutdown. For Flask, create it with the app and use `@app.errorhandler(Exception)`; for Django, initialize in app configuration and capture in middleware. Capture methods return immediately and never raise telemetry delivery errors.
+
+## Security
+
+This is a server SDK. Never embed its secret project API key in browser JavaScript, Flutter/mobile, or any client application. Those platforms need a future client-safe credential/DSN.

lazers-0.1.0/README.md

@@ -0,0 +1,41 @@
+# Lazers Python SDK
+
+Server-side Python SDK for Lazers Signal Protocol v1. It uses only the Python standard library and supports Python 3.10+.
+
+Repository: [https://github.com/Emmydapson/lazers](https://github.com/Emmydapson/lazers)
+
+## Installation
+
+```bash
+pip install lazers
+```
+
+## Quickstart
+
+```python
+from lazers import LazersClient
+
+client = LazersClient(
+    api_key="...",
+    endpoint="https://api.lazers.app",
+    project_id="project_1",
+    environment="production",
+    service_name="my-api",
+)
+
+client.capture_error(
+    RuntimeError("database timeout"),
+    actor={"type": "customer", "id": "cust_2048"},
+)
+
+# During shutdown:
+client.flush()
+```
+
+## Framework guidance
+
+FastAPI example: [`examples/fastapi.py`](examples/fastapi.py). Create the client once at app startup, capture in an exception handler, and call `flush()` on shutdown. For Flask, create it with the app and use `@app.errorhandler(Exception)`; for Django, initialize in app configuration and capture in middleware. Capture methods return immediately and never raise telemetry delivery errors.
+
+## Security
+
+This is a server SDK. Never embed its secret project API key in browser JavaScript, Flutter/mobile, or any client application. Those platforms need a future client-safe credential/DSN.

lazers-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "lazers"
+version = "0.1.0"
+description = "Server-side Python SDK for Lazers Signal Protocol v1"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "Apache-2.0"
+authors = [
+    {name = "Emmanuel Ilori", email = "iloriemmanuel00@gmail.com"}
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Operating System :: OS Independent"
+]
+
+[project.urls]
+Homepage = "https://github.com/Emmydapson/lazers"
+Repository = "https://github.com/Emmydapson/lazers"
+Issues = "https://github.com/Emmydapson/lazers/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]

lazers-0.1.0/setup.cfg

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

lazers-0.1.0/src/lazers/__init__.py

@@ -0,0 +1,3 @@
+from .client import LazersClient, sanitize, serialize_error
+
+__all__ = ["LazersClient", "sanitize", "serialize_error"]

lazers-0.1.0/src/lazers/client.py

@@ -0,0 +1,231 @@
+"""Lazers server-side Signal Protocol v1 client."""
+from __future__ import annotations
+
+import hashlib
+import json
+import threading
+import time
+import traceback
+import uuid
+from collections import deque
+from dataclasses import dataclass
+from typing import Any, Callable, Mapping
+from urllib.error import HTTPError, URLError
+from urllib.request import Request, urlopen
+
+PROTOCOL_VERSION = "1"
+SCHEMA_VERSION = "2026-07-09"
+MAX_STRING_LENGTH = 10_000
+MAX_METADATA_KEYS = 100
+MAX_DEPTH = 6
+ACTOR_TYPES = {"user", "customer", "account", "merchant", "tenant", "organization", "other"}
+SENSITIVE_KEYS = ("password", "passwd", "secret", "token", "authorization", "cookie", "api_key", "apikey", "cardnumber", "card", "cvv", "pin", "refreshtoken", "accesstoken", "body", "rawbody", "webhookpayload")
+INVALID_RELEASES = {"git-sha", "sha", "unknown", "replace-me", "placeholder", "undefined", "null"}
+Transport = Callable[[str, Mapping[str, str], bytes, float], int]
+
+@dataclass
+class _QueueItem:
+    signal: dict[str, Any]
+    attempts: int = 0
+    next_attempt_at: float = 0.0
+
+class LazersClient:
+    """Thread-safe, non-blocking server SDK. Capture failures are isolated from the host app."""
+    def __init__(self, *, api_key: str, endpoint: str, project_id: str, environment: str,
+                 service_name: str, release: str | None = None, enabled: bool = True,
+                 max_queue_size: int = 100, retry_base_delay_ms: int = 250,
+                 timeout: float = 5.0, max_retries: int = 5,
+                 transport: Transport | None = None) -> None:
+        self.api_key = api_key
+        self.endpoint = endpoint.rstrip("/")
+        self.project_id = _required(project_id, 200)
+        self.environment = _required(environment, 80)
+        self.service_name = _required(service_name, 80)
+        self.release = _valid_release(release)
+        self.enabled = enabled
+        self.max_queue_size = max(1, max_queue_size)
+        self.retry_base_delay_ms = max(0, retry_base_delay_ms)
+        self.timeout = timeout
+        self.max_retries = max(0, max_retries)
+        self.transport = transport or _default_transport
+        self._queue: deque[_QueueItem] = deque()
+        self._lock = threading.RLock()
+        self._worker: threading.Thread | None = None
+
+    def capture_signal(self, *, title: str, type: str = "custom.event", event_category: str | None = None,
+                       payload: Mapping[str, Any] | None = None, severity: str = "info", **context: Any) -> None:
+        if not self.enabled:
+            return
+        try:
+            signal = self._normalize_signal(title=title, signal_type=type,
+                event_category=event_category or _category_for_type(type), payload=payload or {},
+                severity=severity, **context)
+            with self._lock:
+                self._queue.append(_QueueItem(signal=signal, next_attempt_at=time.monotonic()))
+                while len(self._queue) > self.max_queue_size:
+                    self._queue.popleft()
+            self._start_worker()
+        except Exception:
+            # Telemetry must never affect application flow.
+            return
+
+    def capture_error(self, error: BaseException | Any, **context: Any) -> None:
+        serialized = serialize_error(error)
+        self.capture_signal(title=serialized["message"], type="error.detected", event_category="error",
+                            severity=context.pop("severity", "error"),
+                            payload={**context.pop("payload", {}), "error": serialized}, **context)
+
+    def capture_message(self, message: str, **context: Any) -> None:
+        self.capture_signal(title=message, type="custom.event", event_category="message",
+                            severity=context.pop("severity", "info"),
+                            payload={**context.pop("payload", {}), "message": message}, **context)
+
+    def capture_job_failure(self, job_name: str, error: BaseException | Any, **context: Any) -> None:
+        serialized = serialize_error(error)
+        self.capture_signal(title=f"Job failed: {job_name}", type="job.failed", event_category="job_failure",
+            severity=context.pop("severity", "error"), event_name=context.pop("event_name", "job.failure"),
+            resource=context.pop("resource", {"type": "job", "id": job_name, "name": job_name}),
+            payload={**context.pop("payload", {}), "error": serialized, "jobName": job_name}, **context)
+
+    def capture_webhook_failure(self, provider: str, error: BaseException | Any, **context: Any) -> None:
+        serialized = serialize_error(error)
+        self.capture_signal(title=f"Webhook failed: {provider}", type="integration.failed", event_category="webhook_failure",
+            severity=context.pop("severity", "error"), provider=provider,
+            source_type=context.pop("source_type", "custom"), event_name=context.pop("event_name", "webhook.failure"),
+            payload={**context.pop("payload", {}), "error": serialized, "provider": provider}, **context)
+
+    def flush(self) -> None:
+        """Best-effort synchronous drain, intended for graceful shutdown."""
+        if not self.enabled:
+            with self._lock: self._queue.clear()
+            return
+        while True:
+            with self._lock:
+                if not self._queue: return
+                item = self._queue[0]
+            if self._send(item):
+                with self._lock:
+                    if self._queue and self._queue[0] is item: self._queue.popleft()
+            else:
+                # Flush makes one bounded attempt per queued item; leave retryable items queued.
+                with self._lock:
+                    if self._queue and self._queue[0] is item: self._queue.rotate(-1)
+                return
+
+    def close(self) -> None:
+        self.flush()
+
+    def get_queue_size(self) -> int:
+        with self._lock: return len(self._queue)
+
+    def _start_worker(self) -> None:
+        with self._lock:
+            if self._worker and self._worker.is_alive(): return
+            self._worker = threading.Thread(target=self._drain_ready, name="lazers-delivery", daemon=True)
+            self._worker.start()
+
+    def _drain_ready(self) -> None:
+        while True:
+            with self._lock:
+                if not self._queue: return
+                item = self._queue[0]
+                if item.next_attempt_at > time.monotonic(): return
+            if self._send(item):
+                with self._lock:
+                    if self._queue and self._queue[0] is item: self._queue.popleft()
+            else:
+                return
+
+    def _send(self, item: _QueueItem) -> bool:
+        try:
+            status = self.transport(self.endpoint + "/signals/ingest", {
+                "Content-Type": "application/json", "x-lazers-api-key": self.api_key,
+            }, json.dumps(item.signal, separators=(",", ":")).encode(), self.timeout)
+            if 200 <= status < 300 or not _retryable_status(status): return True
+        except Exception:
+            pass
+        item.attempts += 1
+        if item.attempts >= self.max_retries: return True
+        item.next_attempt_at = time.monotonic() + min((self.retry_base_delay_ms / 1000) * 2 ** max(item.attempts - 1, 0), 30)
+        return False
+
+    def _normalize_signal(self, *, title: str, signal_type: str, event_category: str, payload: Mapping[str, Any], severity: str, **ctx: Any) -> dict[str, Any]:
+        release = _valid_release(ctx.get("release", self.release))
+        source = ctx.get("source") or {}
+        provider = source.get("provider") or ctx.get("provider") or ctx.get("source_provider") or "lazers-agent-sdk"
+        source_type = source.get("type") or ctx.get("source_type") or "agent_sdk"
+        event_name = source.get("eventName") or ctx.get("event_name") or ctx.get("source_event_name")
+        clean_payload = sanitize(payload)
+        metadata = sanitize({**(ctx.get("metadata") or {}), **({"release": release} if release else {}), "serviceName": self.service_name})
+        error = clean_payload.get("error") if isinstance(clean_payload, dict) else None
+        fingerprint = _stable(ctx["fingerprint"], 256) if ctx.get("fingerprint") else _fingerprint(
+            event_category, signal_type, provider, event_name, ctx.get("resource"), error, title)
+        result: dict[str, Any] = {
+            "protocolVersion": PROTOCOL_VERSION, "schemaVersion": SCHEMA_VERSION, "projectId": self.project_id,
+            "environment": _required(ctx.get("environment", self.environment), 80), "eventCategory": event_category,
+            "type": signal_type, "severity": severity if severity in {"info","notice","warning","error","critical"} else "info",
+            "title": _required(title, 240), "occurredAt": ctx.get("occurred_at") or ctx.get("occurredAt") or _iso_now(),
+            "fingerprint": fingerprint, "traceId": ctx.get("trace_id") or ctx.get("traceId") or f"exec_{uuid.uuid4()}",
+            "source": {"type": source_type, "provider": _required(provider, 80)}, "privacy": ctx.get("privacy") or _privacy(),
+            "payload": clean_payload, "metadata": metadata, "status": "received",
+        }
+        if event_name: result["source"]["eventName"] = _required(event_name, 160)
+        for key, aliases in {"correlationId": ("correlation_id", "correlationId"), "actor": ("actor",), "resource": ("resource",), "tags": ("tags",), "labels": ("labels",), "affectedUsers": ("affected_users", "affectedUsers"), "relatedEntities": ("related_entities", "relatedEntities")}.items():
+            value = next((ctx[a] for a in aliases if ctx.get(a) is not None), None)
+            if value is not None: result[key] = _actor(value) if key == "actor" else sanitize(value)
+        return {key: value for key, value in result.items() if value is not None}
+
+def serialize_error(error: BaseException | Any, depth: int = 0) -> dict[str, Any]:
+    if isinstance(error, BaseException):
+        result: dict[str, Any] = {"name": type(error).__name__, "message": str(error)}
+        if error.__traceback__: result["stack"] = "".join(traceback.format_exception(type(error), error, error.__traceback__))
+        code = getattr(error, "code", None) or getattr(error, "errno", None)
+        if isinstance(code, (str, int)): result["code"] = str(code)
+        cause = error.__cause__ or (None if error.__suppress_context__ else error.__context__)
+        if cause and depth < 3: result["cause"] = serialize_error(cause, depth + 1)
+        return sanitize(result)
+    return {"name": "NonError", "message": _truncate(str(error), MAX_STRING_LENGTH)}
+
+def sanitize(value: Any, depth: int = 0) -> Any:
+    if value is None or isinstance(value, (bool, int, float)): return value
+    if isinstance(value, str): return _truncate(value, MAX_STRING_LENGTH)
+    if isinstance(value, (bytes, bytearray, set)) or callable(value): return "[UNSUPPORTED_OBJECT]"
+    if depth >= MAX_DEPTH: return "[TRUNCATED]"
+    if isinstance(value, (list, tuple)): return [sanitize(v, depth + 1) for v in value[:MAX_METADATA_KEYS]]
+    if isinstance(value, Mapping):
+        return {_truncate(str(k), 160): "[REDACTED]" if _sensitive(str(k)) else sanitize(v, depth + 1)
+                for k, v in list(value.items())[:MAX_METADATA_KEYS] if v is not ...}
+    return "[UNSUPPORTED_OBJECT]"
+
+def _fingerprint(category: str, signal_type: str, provider: Any, event_name: Any, resource: Any, error: Any, title: str) -> str:
+    resource = resource if isinstance(resource, Mapping) else {}
+    error = error if isinstance(error, Mapping) else {}
+    parts = [category, signal_type, provider, event_name, resource.get("type"), resource.get("id"), error.get("name"), error.get("message", title)]
+    return hashlib.sha256("|".join(_stable(str(v), 512) for v in parts if isinstance(v, str) and v.strip()).encode()).hexdigest()
+
+def _actor(value: Any) -> Any:
+    if not isinstance(value, Mapping) or not isinstance(value.get("id"), str) or not value["id"].strip(): return None
+    result = {"type": value.get("type") if value.get("type") in ACTOR_TYPES else "other", "id": _required(value["id"], 200)}
+    if isinstance(value.get("label"), str) and value["label"].strip(): result["label"] = _truncate(value["label"].strip(), 240)
+    return result
+
+def _sensitive(key: str) -> bool:
+    key = "".join(ch for ch in key.lower() if ch.isalnum())
+    return any(token.replace("_", "") in key for token in SENSITIVE_KEYS)
+def _valid_release(value: Any) -> str | None:
+    return value.strip() if isinstance(value, str) and value.strip() and value.strip().lower() not in INVALID_RELEASES else None
+def _required(value: Any, limit: int) -> str:
+    return _truncate(str(value).strip(), limit) or "unknown"
+def _stable(value: str, limit: int) -> str:
+    return _truncate(" ".join(value.strip().lower().split()), limit)
+def _truncate(value: str, limit: int) -> str: return value[:limit]
+def _privacy() -> dict[str, Any]: return {"classification":"internal","containsPersonalData":False,"containsSecrets":False,"aiProcessingAllowed":True,"retention":"standard"}
+def _iso_now() -> str:
+    from datetime import datetime, timezone
+    return datetime.now(timezone.utc).isoformat(timespec="milliseconds").replace("+00:00", "Z")
+def _retryable_status(status: int) -> bool: return status in {408, 429} or 500 <= status <= 599
+def _default_transport(url: str, headers: Mapping[str, str], body: bytes, timeout: float) -> int:
+    request = Request(url, data=body, headers=dict(headers), method="POST")
+    try:
+        with urlopen(request, timeout=timeout) as response: return response.status
+    except HTTPError as error: return error.code

lazers-0.1.0/src/lazers.egg-info/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: lazers
+Version: 0.1.0
+Summary: Server-side Python SDK for Lazers Signal Protocol v1
+Author-email: Emmanuel Ilori <iloriemmanuel00@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/Emmydapson/lazers
+Project-URL: Repository, https://github.com/Emmydapson/lazers
+Project-URL: Issues, https://github.com/Emmydapson/lazers/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Lazers Python SDK
+
+Server-side Python SDK for Lazers Signal Protocol v1. It uses only the Python standard library and supports Python 3.10+.
+
+Repository: [https://github.com/Emmydapson/lazers](https://github.com/Emmydapson/lazers)
+
+## Installation
+
+```bash
+pip install lazers
+```
+
+## Quickstart
+
+```python
+from lazers import LazersClient
+
+client = LazersClient(
+    api_key="...",
+    endpoint="https://api.lazers.app",
+    project_id="project_1",
+    environment="production",
+    service_name="my-api",
+)
+
+client.capture_error(
+    RuntimeError("database timeout"),
+    actor={"type": "customer", "id": "cust_2048"},
+)
+
+# During shutdown:
+client.flush()
+```
+
+## Framework guidance
+
+FastAPI example: [`examples/fastapi.py`](examples/fastapi.py). Create the client once at app startup, capture in an exception handler, and call `flush()` on shutdown. For Flask, create it with the app and use `@app.errorhandler(Exception)`; for Django, initialize in app configuration and capture in middleware. Capture methods return immediately and never raise telemetry delivery errors.
+
+## Security
+
+This is a server SDK. Never embed its secret project API key in browser JavaScript, Flutter/mobile, or any client application. Those platforms need a future client-safe credential/DSN.

lazers-0.1.0/src/lazers.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+src/lazers/__init__.py
+src/lazers/client.py
+src/lazers.egg-info/PKG-INFO
+src/lazers.egg-info/SOURCES.txt
+src/lazers.egg-info/dependency_links.txt
+src/lazers.egg-info/top_level.txt
+tests/test_client.py

lazers-0.1.0/src/lazers.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

lazers-0.1.0/src/lazers.egg-info/top_level.txt

@@ -0,0 +1 @@
+lazers

lazers-0.1.0/tests/test_client.py

@@ -0,0 +1,55 @@
+import pathlib
+import sys
+import threading
+import time
+import unittest
+
+sys.path.insert(0, str(pathlib.Path(__file__).parents[1] / "src"))
+from lazers import LazersClient, sanitize, serialize_error
+
+class FakeTransport:
+    def __init__(self, statuses=None, fail=False): self.statuses, self.fail, self.requests = list(statuses or [202]), fail, []
+    def __call__(self, url, headers, body, timeout):
+        if self.fail: raise OSError("offline")
+        self.requests.append((url, headers, body))
+        return self.statuses.pop(0) if self.statuses else 202
+
+class SDKTests(unittest.TestCase):
+    def client(self, transport=None, **extra):
+        return LazersClient(api_key="key", endpoint="https://api.test/", project_id="project_1", environment=" production ", service_name=" checkout-api ", transport=transport or FakeTransport(), **extra)
+    def payload(self, client, transport):
+        client.flush(); import json; return json.loads(transport.requests[-1][2])
+    def test_protocol_and_helpers(self):
+        t=FakeTransport(); c=self.client(t); c.capture_error(ValueError("bad")); body=self.payload(c,t)
+        self.assertEqual("1", body["protocolVersion"]); self.assertEqual("error", body["eventCategory"]); self.assertEqual("ValueError", body["payload"]["error"]["name"])
+    def test_redaction_and_actor(self):
+        self.assertEqual("[REDACTED]", sanitize({"nested":{"accessToken":"x"}})["nested"]["accessToken"])
+        t=FakeTransport(); c=self.client(t); c.capture_message("x", actor={"type":"user","id":" u ","email":"no"}); body=self.payload(c,t)
+        self.assertEqual({"type":"user","id":"u"},body["actor"])
+    def test_trace_and_correlation(self):
+        t=FakeTransport(); c=self.client(t); c.capture_message("x"); body=self.payload(c,t)
+        self.assertRegex(body["traceId"], r"^exec_"); self.assertNotIn("correlationId",body)
+        c.capture_message("x", correlation_id="flow"); body=self.payload(c,t); self.assertEqual("flow",body["correlationId"])
+    def test_release_and_fingerprint(self):
+        t=FakeTransport(); c=self.client(t, release="unknown"); c.capture_error(RuntimeError("timeout")); a=self.payload(c,t)
+        self.assertNotIn("release",a["metadata"]); c.capture_error(RuntimeError("timeout")); b=self.payload(c,t)
+        self.assertEqual(a["fingerprint"],b["fingerprint"]); self.assertNotEqual(a["traceId"],b["traceId"])
+    def test_queue_oldest_drop_and_disabled(self):
+        t=FakeTransport(fail=True); c=self.client(t,max_queue_size=2); c.capture_message("one"); c.capture_message("two"); c.capture_message("three"); time.sleep(.03)
+        self.assertEqual(2,c.get_queue_size()); disabled=self.client(t,enabled=False); disabled.capture_message("none"); self.assertEqual(0,disabled.get_queue_size())
+    def test_terminal_and_retry_status(self):
+        t=FakeTransport([401]); c=self.client(t); c.capture_message("x"); time.sleep(.03); self.assertEqual(0,c.get_queue_size())
+        t=FakeTransport([500]); c=self.client(t,retry_base_delay_ms=1); c.capture_message("x"); time.sleep(.03); self.assertEqual(1,c.get_queue_size())
+    def test_error_cause_and_fixtures(self):
+        try:
+            try: raise ValueError("secret token")
+            except ValueError as cause: raise RuntimeError("outer") from cause
+        except RuntimeError as error: result=serialize_error(error)
+        self.assertEqual("RuntimeError", result["name"]); self.assertEqual("ValueError", result["cause"]["name"])
+        fixtures=pathlib.Path(__file__).parents[2] / "agent-sdk" / "fixtures"
+        self.assertEqual(10,len(list(fixtures.glob("*.json"))))
+    def test_thread_safe_capture(self):
+        t=FakeTransport(); c=self.client(t); threads=[threading.Thread(target=lambda: c.capture_message("x")) for _ in range(10)]
+        [x.start() for x in threads]; [x.join() for x in threads]; c.flush(); self.assertEqual(0,c.get_queue_size())
+
+if __name__ == "__main__": unittest.main()