impulse-telemetry 0.1.0__tar.gz

impulse_telemetry-0.1.0/PKG-INFO

@@ -0,0 +1,203 @@
+Metadata-Version: 2.4
+Name: impulse-telemetry
+Version: 0.1.0
+Summary: Observability SDK for Impulse microservices
+License: MIT
+Keywords: observability,telemetry,opentelemetry,prometheus,fastapi,ml
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: opentelemetry-sdk>=1.24
+Requires-Dist: opentelemetry-exporter-otlp-proto-grpc>=1.24
+Requires-Dist: opentelemetry-propagator-b3>=1.24
+Requires-Dist: opentelemetry-instrumentation-fastapi>=0.45b0
+Requires-Dist: opentelemetry-instrumentation-requests>=0.45b0
+Requires-Dist: opentelemetry-instrumentation-httpx>=0.45b0
+Requires-Dist: prometheus-client>=0.20
+Requires-Dist: structlog>=24.0
+Provides-Extra: extras
+Requires-Dist: opentelemetry-instrumentation-sqlalchemy>=0.45b0; extra == "extras"
+Requires-Dist: opentelemetry-instrumentation-redis>=0.45b0; extra == "extras"
+Requires-Dist: opentelemetry-instrumentation-celery>=0.45b0; extra == "extras"
+Provides-Extra: ml
+Requires-Dist: pandas>=2.0; extra == "ml"
+
+# impulse_telemetry
+
+Observability SDK for Impulse microservices. One `init()` call wires up distributed tracing, Prometheus metrics, structured logging, and FastAPI middleware.
+
+## Install
+
+```bash
+pip install impulse-telemetry
+
+# With SQLAlchemy / Redis / Celery auto-instrumentation
+pip install "impulse-telemetry[extras]"
+
+# With ML data quality checks (pandas required)
+pip install "impulse-telemetry[ml]"
+```
+
+## Quickstart
+
+```python
+from fastapi import FastAPI
+from impulse_telemetry import init
+
+app = FastAPI()
+init(app, service="my-service", version="1.0.0", env="production")
+```
+
+Every HTTP request now emits RED metrics, a distributed trace, and a structured JSON log line — automatically.
+
+## `init()` parameters
+
+| Parameter | Default | Description |
+|---|---|---|
+| `app` | `None` | FastAPI app. Pass to enable HTTP middleware. |
+| `service` | **required** | Service name — appears on all telemetry. |
+| `version` | `"0.0.0"` | Semver string tagged on all telemetry. |
+| `env` | `$ENV` | `"production"` \| `"staging"` \| `"dev"` |
+| `otlp_endpoint` | `$OTEL_EXPORTER_OTLP_ENDPOINT` | OTLP Collector gRPC address. |
+| `prometheus_port` | `None` | Expose `/metrics` on this port (for workers without HTTP). |
+| `log_level` | `"INFO"` | `"DEBUG"` \| `"INFO"` \| `"WARNING"` \| `"ERROR"` |
+| `enable_ml` | `False` | Register ML-specific metric instruments. |
+
+## Logging
+
+```python
+from impulse_telemetry.logging import get_logger
+
+log = get_logger(__name__)
+log.info("prediction_served", model_id="rec-v3", latency_ms=43)
+# {"service":"my-service","trace_id":"abc..","event":"prediction_served","model_id":"rec-v3",...}
+```
+
+`trace_id` and `span_id` are injected automatically from the active OTEL span.
+
+### Per-request context
+
+Bind fields once per request — they appear on every subsequent log line for that request.
+
+```python
+from impulse_telemetry.logging import bind_request_context, clear_request_context
+
+token = bind_request_context(user_id="usr_123", request_id="req_456")
+log.info("doing_work")   # user_id + request_id injected automatically
+clear_request_context(token)
+```
+
+## Metrics
+
+Prometheus metrics are pre-registered and labeled with `service` and `env`.
+
+### Automatic (via middleware)
+
+| Metric | Type | Description |
+|---|---|---|
+| `http_requests_total` | Counter | Requests by route, method, status |
+| `http_request_errors_total` | Counter | 4xx / 5xx responses |
+| `http_request_duration_seconds` | Histogram | Request latency |
+| `http_active_requests` | Gauge | In-flight requests |
+
+### Manual
+
+```python
+from impulse_telemetry.metrics import get_metrics
+
+m = get_metrics()
+m.dependency_latency.labels(**m.labels(dependency="redis")).observe(elapsed)
+m.dependency_errors.labels(**m.labels(dependency="redis")).inc()
+```
+
+Available instruments: `rate_limiter_hits`, `rate_limiter_remaining`, `dependency_latency`, `dependency_errors`, `queue_depth`, `circuit_breaker`.
+
+## Tracing
+
+```python
+from impulse_telemetry.tracing import get_tracer, inject_headers
+
+tracer = get_tracer(__name__)
+
+with tracer.start_as_current_span("my_operation") as span:
+    span.set_attribute("key", "value")
+    headers = inject_headers({})   # propagate W3C traceparent to downstream
+    requests.get("http://other-service/api", headers=headers)
+```
+
+Auto-instrumented libraries (when installed): `requests`, `httpx`, `SQLAlchemy`, `Redis`, `Celery`.
+
+## ML Monitoring
+
+Enable at startup with `enable_ml=True`.
+
+```python
+from impulse_telemetry.ml import MLMonitor
+
+monitor = MLMonitor(model_id="rec-v3", user_id=user_id)
+```
+
+### Inference tracing
+
+```python
+# Context manager
+with monitor.inference(features=df) as span:
+    result = model.predict(df)
+    span.record_output(result)
+
+# Decorator
+@monitor.trace
+def predict(features):
+    return model.predict(features)
+```
+
+Both record inference latency, error count, and run data quality checks (missing values, schema violations) automatically.
+
+### Drift & performance metrics
+
+```python
+# Call from batch evaluation jobs
+monitor.record_drift("age", score=0.18, metric="psi")
+monitor.record_performance(rmse=0.042, precision=0.87, recall=0.81)
+```
+
+### ML metric instruments
+
+| Metric | Type | Description |
+|---|---|---|
+| `ml_inference_duration_seconds` | Histogram | Per-model inference latency |
+| `ml_inference_requests_total` | Counter | Inference count |
+| `ml_inference_errors_total` | Counter | Inference errors |
+| `ml_missing_feature_rate` | Gauge | Missing values per column |
+| `ml_schema_violations_total` | Counter | Schema violation count |
+| `ml_feature_drift` | Gauge | Feature drift score |
+| `ml_prediction_drift` | Gauge | Prediction drift score |
+| `ml_rmse` | Gauge | Rolling RMSE |
+| `ml_precision` | Gauge | Rolling precision |
+| `ml_recall` | Gauge | Rolling recall |
+
+## Background workers
+
+For services without an HTTP server, expose metrics on a dedicated port:
+
+```python
+init(service="ingest-worker", prometheus_port=9090)
+# Prometheus scrapes localhost:9090/metrics
+```
+
+## Environment variables
+
+| Variable | Description |
+|---|---|
+| `OTEL_EXPORTER_OTLP_ENDPOINT` | OTLP Collector gRPC address |
+| `ENV` | Deployment environment (`production`, `staging`, `dev`) |
+
+## See also
+
+[examples.py](examples.py) — minimal, runnable code for every feature.

impulse_telemetry-0.1.0/README.md

@@ -0,0 +1,173 @@
+# impulse_telemetry
+
+Observability SDK for Impulse microservices. One `init()` call wires up distributed tracing, Prometheus metrics, structured logging, and FastAPI middleware.
+
+## Install
+
+```bash
+pip install impulse-telemetry
+
+# With SQLAlchemy / Redis / Celery auto-instrumentation
+pip install "impulse-telemetry[extras]"
+
+# With ML data quality checks (pandas required)
+pip install "impulse-telemetry[ml]"
+```
+
+## Quickstart
+
+```python
+from fastapi import FastAPI
+from impulse_telemetry import init
+
+app = FastAPI()
+init(app, service="my-service", version="1.0.0", env="production")
+```
+
+Every HTTP request now emits RED metrics, a distributed trace, and a structured JSON log line — automatically.
+
+## `init()` parameters
+
+| Parameter | Default | Description |
+|---|---|---|
+| `app` | `None` | FastAPI app. Pass to enable HTTP middleware. |
+| `service` | **required** | Service name — appears on all telemetry. |
+| `version` | `"0.0.0"` | Semver string tagged on all telemetry. |
+| `env` | `$ENV` | `"production"` \| `"staging"` \| `"dev"` |
+| `otlp_endpoint` | `$OTEL_EXPORTER_OTLP_ENDPOINT` | OTLP Collector gRPC address. |
+| `prometheus_port` | `None` | Expose `/metrics` on this port (for workers without HTTP). |
+| `log_level` | `"INFO"` | `"DEBUG"` \| `"INFO"` \| `"WARNING"` \| `"ERROR"` |
+| `enable_ml` | `False` | Register ML-specific metric instruments. |
+
+## Logging
+
+```python
+from impulse_telemetry.logging import get_logger
+
+log = get_logger(__name__)
+log.info("prediction_served", model_id="rec-v3", latency_ms=43)
+# {"service":"my-service","trace_id":"abc..","event":"prediction_served","model_id":"rec-v3",...}
+```
+
+`trace_id` and `span_id` are injected automatically from the active OTEL span.
+
+### Per-request context
+
+Bind fields once per request — they appear on every subsequent log line for that request.
+
+```python
+from impulse_telemetry.logging import bind_request_context, clear_request_context
+
+token = bind_request_context(user_id="usr_123", request_id="req_456")
+log.info("doing_work")   # user_id + request_id injected automatically
+clear_request_context(token)
+```
+
+## Metrics
+
+Prometheus metrics are pre-registered and labeled with `service` and `env`.
+
+### Automatic (via middleware)
+
+| Metric | Type | Description |
+|---|---|---|
+| `http_requests_total` | Counter | Requests by route, method, status |
+| `http_request_errors_total` | Counter | 4xx / 5xx responses |
+| `http_request_duration_seconds` | Histogram | Request latency |
+| `http_active_requests` | Gauge | In-flight requests |
+
+### Manual
+
+```python
+from impulse_telemetry.metrics import get_metrics
+
+m = get_metrics()
+m.dependency_latency.labels(**m.labels(dependency="redis")).observe(elapsed)
+m.dependency_errors.labels(**m.labels(dependency="redis")).inc()
+```
+
+Available instruments: `rate_limiter_hits`, `rate_limiter_remaining`, `dependency_latency`, `dependency_errors`, `queue_depth`, `circuit_breaker`.
+
+## Tracing
+
+```python
+from impulse_telemetry.tracing import get_tracer, inject_headers
+
+tracer = get_tracer(__name__)
+
+with tracer.start_as_current_span("my_operation") as span:
+    span.set_attribute("key", "value")
+    headers = inject_headers({})   # propagate W3C traceparent to downstream
+    requests.get("http://other-service/api", headers=headers)
+```
+
+Auto-instrumented libraries (when installed): `requests`, `httpx`, `SQLAlchemy`, `Redis`, `Celery`.
+
+## ML Monitoring
+
+Enable at startup with `enable_ml=True`.
+
+```python
+from impulse_telemetry.ml import MLMonitor
+
+monitor = MLMonitor(model_id="rec-v3", user_id=user_id)
+```
+
+### Inference tracing
+
+```python
+# Context manager
+with monitor.inference(features=df) as span:
+    result = model.predict(df)
+    span.record_output(result)
+
+# Decorator
+@monitor.trace
+def predict(features):
+    return model.predict(features)
+```
+
+Both record inference latency, error count, and run data quality checks (missing values, schema violations) automatically.
+
+### Drift & performance metrics
+
+```python
+# Call from batch evaluation jobs
+monitor.record_drift("age", score=0.18, metric="psi")
+monitor.record_performance(rmse=0.042, precision=0.87, recall=0.81)
+```
+
+### ML metric instruments
+
+| Metric | Type | Description |
+|---|---|---|
+| `ml_inference_duration_seconds` | Histogram | Per-model inference latency |
+| `ml_inference_requests_total` | Counter | Inference count |
+| `ml_inference_errors_total` | Counter | Inference errors |
+| `ml_missing_feature_rate` | Gauge | Missing values per column |
+| `ml_schema_violations_total` | Counter | Schema violation count |
+| `ml_feature_drift` | Gauge | Feature drift score |
+| `ml_prediction_drift` | Gauge | Prediction drift score |
+| `ml_rmse` | Gauge | Rolling RMSE |
+| `ml_precision` | Gauge | Rolling precision |
+| `ml_recall` | Gauge | Rolling recall |
+
+## Background workers
+
+For services without an HTTP server, expose metrics on a dedicated port:
+
+```python
+init(service="ingest-worker", prometheus_port=9090)
+# Prometheus scrapes localhost:9090/metrics
+```
+
+## Environment variables
+
+| Variable | Description |
+|---|---|
+| `OTEL_EXPORTER_OTLP_ENDPOINT` | OTLP Collector gRPC address |
+| `ENV` | Deployment environment (`production`, `staging`, `dev`) |
+
+## See also
+
+[examples.py](examples.py) — minimal, runnable code for every feature.

impulse_telemetry-0.1.0/impulse_telemetry.egg-info/PKG-INFO

@@ -0,0 +1,203 @@
+Metadata-Version: 2.4
+Name: impulse-telemetry
+Version: 0.1.0
+Summary: Observability SDK for Impulse microservices
+License: MIT
+Keywords: observability,telemetry,opentelemetry,prometheus,fastapi,ml
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: opentelemetry-sdk>=1.24
+Requires-Dist: opentelemetry-exporter-otlp-proto-grpc>=1.24
+Requires-Dist: opentelemetry-propagator-b3>=1.24
+Requires-Dist: opentelemetry-instrumentation-fastapi>=0.45b0
+Requires-Dist: opentelemetry-instrumentation-requests>=0.45b0
+Requires-Dist: opentelemetry-instrumentation-httpx>=0.45b0
+Requires-Dist: prometheus-client>=0.20
+Requires-Dist: structlog>=24.0
+Provides-Extra: extras
+Requires-Dist: opentelemetry-instrumentation-sqlalchemy>=0.45b0; extra == "extras"
+Requires-Dist: opentelemetry-instrumentation-redis>=0.45b0; extra == "extras"
+Requires-Dist: opentelemetry-instrumentation-celery>=0.45b0; extra == "extras"
+Provides-Extra: ml
+Requires-Dist: pandas>=2.0; extra == "ml"
+
+# impulse_telemetry
+
+Observability SDK for Impulse microservices. One `init()` call wires up distributed tracing, Prometheus metrics, structured logging, and FastAPI middleware.
+
+## Install
+
+```bash
+pip install impulse-telemetry
+
+# With SQLAlchemy / Redis / Celery auto-instrumentation
+pip install "impulse-telemetry[extras]"
+
+# With ML data quality checks (pandas required)
+pip install "impulse-telemetry[ml]"
+```
+
+## Quickstart
+
+```python
+from fastapi import FastAPI
+from impulse_telemetry import init
+
+app = FastAPI()
+init(app, service="my-service", version="1.0.0", env="production")
+```
+
+Every HTTP request now emits RED metrics, a distributed trace, and a structured JSON log line — automatically.
+
+## `init()` parameters
+
+| Parameter | Default | Description |
+|---|---|---|
+| `app` | `None` | FastAPI app. Pass to enable HTTP middleware. |
+| `service` | **required** | Service name — appears on all telemetry. |
+| `version` | `"0.0.0"` | Semver string tagged on all telemetry. |
+| `env` | `$ENV` | `"production"` \| `"staging"` \| `"dev"` |
+| `otlp_endpoint` | `$OTEL_EXPORTER_OTLP_ENDPOINT` | OTLP Collector gRPC address. |
+| `prometheus_port` | `None` | Expose `/metrics` on this port (for workers without HTTP). |
+| `log_level` | `"INFO"` | `"DEBUG"` \| `"INFO"` \| `"WARNING"` \| `"ERROR"` |
+| `enable_ml` | `False` | Register ML-specific metric instruments. |
+
+## Logging
+
+```python
+from impulse_telemetry.logging import get_logger
+
+log = get_logger(__name__)
+log.info("prediction_served", model_id="rec-v3", latency_ms=43)
+# {"service":"my-service","trace_id":"abc..","event":"prediction_served","model_id":"rec-v3",...}
+```
+
+`trace_id` and `span_id` are injected automatically from the active OTEL span.
+
+### Per-request context
+
+Bind fields once per request — they appear on every subsequent log line for that request.
+
+```python
+from impulse_telemetry.logging import bind_request_context, clear_request_context
+
+token = bind_request_context(user_id="usr_123", request_id="req_456")
+log.info("doing_work")   # user_id + request_id injected automatically
+clear_request_context(token)
+```
+
+## Metrics
+
+Prometheus metrics are pre-registered and labeled with `service` and `env`.
+
+### Automatic (via middleware)
+
+| Metric | Type | Description |
+|---|---|---|
+| `http_requests_total` | Counter | Requests by route, method, status |
+| `http_request_errors_total` | Counter | 4xx / 5xx responses |
+| `http_request_duration_seconds` | Histogram | Request latency |
+| `http_active_requests` | Gauge | In-flight requests |
+
+### Manual
+
+```python
+from impulse_telemetry.metrics import get_metrics
+
+m = get_metrics()
+m.dependency_latency.labels(**m.labels(dependency="redis")).observe(elapsed)
+m.dependency_errors.labels(**m.labels(dependency="redis")).inc()
+```
+
+Available instruments: `rate_limiter_hits`, `rate_limiter_remaining`, `dependency_latency`, `dependency_errors`, `queue_depth`, `circuit_breaker`.
+
+## Tracing
+
+```python
+from impulse_telemetry.tracing import get_tracer, inject_headers
+
+tracer = get_tracer(__name__)
+
+with tracer.start_as_current_span("my_operation") as span:
+    span.set_attribute("key", "value")
+    headers = inject_headers({})   # propagate W3C traceparent to downstream
+    requests.get("http://other-service/api", headers=headers)
+```
+
+Auto-instrumented libraries (when installed): `requests`, `httpx`, `SQLAlchemy`, `Redis`, `Celery`.
+
+## ML Monitoring
+
+Enable at startup with `enable_ml=True`.
+
+```python
+from impulse_telemetry.ml import MLMonitor
+
+monitor = MLMonitor(model_id="rec-v3", user_id=user_id)
+```
+
+### Inference tracing
+
+```python
+# Context manager
+with monitor.inference(features=df) as span:
+    result = model.predict(df)
+    span.record_output(result)
+
+# Decorator
+@monitor.trace
+def predict(features):
+    return model.predict(features)
+```
+
+Both record inference latency, error count, and run data quality checks (missing values, schema violations) automatically.
+
+### Drift & performance metrics
+
+```python
+# Call from batch evaluation jobs
+monitor.record_drift("age", score=0.18, metric="psi")
+monitor.record_performance(rmse=0.042, precision=0.87, recall=0.81)
+```
+
+### ML metric instruments
+
+| Metric | Type | Description |
+|---|---|---|
+| `ml_inference_duration_seconds` | Histogram | Per-model inference latency |
+| `ml_inference_requests_total` | Counter | Inference count |
+| `ml_inference_errors_total` | Counter | Inference errors |
+| `ml_missing_feature_rate` | Gauge | Missing values per column |
+| `ml_schema_violations_total` | Counter | Schema violation count |
+| `ml_feature_drift` | Gauge | Feature drift score |
+| `ml_prediction_drift` | Gauge | Prediction drift score |
+| `ml_rmse` | Gauge | Rolling RMSE |
+| `ml_precision` | Gauge | Rolling precision |
+| `ml_recall` | Gauge | Rolling recall |
+
+## Background workers
+
+For services without an HTTP server, expose metrics on a dedicated port:
+
+```python
+init(service="ingest-worker", prometheus_port=9090)
+# Prometheus scrapes localhost:9090/metrics
+```
+
+## Environment variables
+
+| Variable | Description |
+|---|---|
+| `OTEL_EXPORTER_OTLP_ENDPOINT` | OTLP Collector gRPC address |
+| `ENV` | Deployment environment (`production`, `staging`, `dev`) |
+
+## See also
+
+[examples.py](examples.py) — minimal, runnable code for every feature.

impulse_telemetry-0.1.0/impulse_telemetry.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+impulse_telemetry.egg-info/PKG-INFO
+impulse_telemetry.egg-info/SOURCES.txt
+impulse_telemetry.egg-info/dependency_links.txt
+impulse_telemetry.egg-info/requires.txt
+impulse_telemetry.egg-info/top_level.txt
+tests/test_logging.py
+tests/test_metrics.py
+tests/test_middleware.py
+tests/test_ml.py
+tests/test_tracing.py

impulse_telemetry-0.1.0/impulse_telemetry.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

impulse_telemetry-0.1.0/impulse_telemetry.egg-info/requires.txt

@@ -0,0 +1,16 @@
+opentelemetry-sdk>=1.24
+opentelemetry-exporter-otlp-proto-grpc>=1.24
+opentelemetry-propagator-b3>=1.24
+opentelemetry-instrumentation-fastapi>=0.45b0
+opentelemetry-instrumentation-requests>=0.45b0
+opentelemetry-instrumentation-httpx>=0.45b0
+prometheus-client>=0.20
+structlog>=24.0
+
+[extras]
+opentelemetry-instrumentation-sqlalchemy>=0.45b0
+opentelemetry-instrumentation-redis>=0.45b0
+opentelemetry-instrumentation-celery>=0.45b0
+
+[ml]
+pandas>=2.0

impulse_telemetry-0.1.0/impulse_telemetry.egg-info/top_level.txt

@@ -0,0 +1 @@
+

impulse_telemetry-0.1.0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "impulse-telemetry"
+version = "0.1.0"
+description = "Observability SDK for Impulse microservices"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+keywords = ["observability", "telemetry", "opentelemetry", "prometheus", "fastapi", "ml"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: System :: Monitoring",
+]
+
+dependencies = [
+    "opentelemetry-sdk>=1.24",
+    "opentelemetry-exporter-otlp-proto-grpc>=1.24",
+    "opentelemetry-propagator-b3>=1.24",
+    "opentelemetry-instrumentation-fastapi>=0.45b0",
+    "opentelemetry-instrumentation-requests>=0.45b0",
+    "opentelemetry-instrumentation-httpx>=0.45b0",
+    "prometheus-client>=0.20",
+    "structlog>=24.0",
+]
+
+[project.optional-dependencies]
+# For services using DBs, caches, queues
+extras = [
+    "opentelemetry-instrumentation-sqlalchemy>=0.45b0",
+    "opentelemetry-instrumentation-redis>=0.45b0",
+    "opentelemetry-instrumentation-celery>=0.45b0",
+]
+# For ML services using data quality checks
+ml = ["pandas>=2.0"]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["impulse_telemetry*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+# asyncio_mode = "auto"  # uncomment if async tests are added later

impulse_telemetry-0.1.0/setup.cfg

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

impulse_telemetry-0.1.0/tests/test_logging.py

@@ -0,0 +1,57 @@
+"""
+Tests for impulse_telemetry.logging
+
+Covers: get_logger, bind_request_context, clear_request_context, get_request_context.
+"""
+
+from impulse_telemetry.logging import get_logger, bind_request_context, clear_request_context
+from impulse_telemetry.logging.context import get_request_context
+
+
+def test_get_logger_returns_bound_logger():
+    log = get_logger(__name__)
+    assert log is not None
+
+
+def test_log_does_not_raise():
+    log = get_logger(__name__)
+    log.info("test_event", key="value")
+    log.warning("test_warning", code=42)
+    log.error("test_error", reason="none")
+
+
+def test_bind_injects_fields():
+    token = bind_request_context(user_id="u1", request_id="r1")
+    ctx = get_request_context()
+    assert ctx["user_id"] == "u1"
+    assert ctx["request_id"] == "r1"
+    clear_request_context(token)
+
+
+def test_clear_restores_previous_context():
+    token = bind_request_context(user_id="u1")
+    clear_request_context(token)
+    ctx = get_request_context()
+    assert "user_id" not in ctx
+
+
+def test_context_empty_by_default():
+    ctx = get_request_context()
+    assert isinstance(ctx, dict)
+    # No stale fields from previous tests (each test gets its own call stack)
+
+
+def test_nested_context_bind():
+    outer = bind_request_context(user_id="outer")
+    inner = bind_request_context(user_id="inner", extra="yes")
+
+    ctx = get_request_context()
+    assert ctx["user_id"] == "inner"
+    assert ctx["extra"] == "yes"
+
+    clear_request_context(inner)
+    ctx = get_request_context()
+    assert ctx["user_id"] == "outer"
+    assert "extra" not in ctx
+
+    clear_request_context(outer)

impulse_telemetry-0.1.0/tests/test_metrics.py

@@ -0,0 +1,68 @@
+"""
+Tests for impulse_telemetry.metrics
+
+Covers: get_metrics singleton, labels(), system instruments, ML instruments.
+"""
+
+import pytest
+from impulse_telemetry.metrics import get_metrics
+from impulse_telemetry.metrics.registry import Metrics
+
+
+def test_get_metrics_returns_instance(app):
+    m = get_metrics()
+    assert isinstance(m, Metrics)
+
+
+def test_get_metrics_is_singleton(app):
+    assert get_metrics() is get_metrics()
+
+
+def test_labels_merges_defaults(app):
+    m = get_metrics()
+    labels = m.labels(route="/predict", status="200")
+    assert labels["service"] == "test-svc"
+    assert labels["env"] == "dev"
+    assert labels["route"] == "/predict"
+    assert labels["status"] == "200"
+
+
+def test_labels_defaults_only(app):
+    m = get_metrics()
+    labels = m.labels()
+    assert set(labels.keys()) == {"service", "env"}
+
+
+def test_system_instruments_present(app):
+    sys = get_metrics().system
+    assert sys.requests_total is not None
+    assert sys.errors_total is not None
+    assert sys.request_latency is not None
+    assert sys.active_requests is not None
+    assert sys.dependency_latency is not None
+    assert sys.dependency_errors is not None
+
+
+def test_ml_instruments_present(app):
+    ml = get_metrics().ml
+    assert ml is not None
+    assert ml.inference_latency is not None
+    assert ml.inference_total is not None
+    assert ml.inference_errors is not None
+    assert ml.feature_drift is not None
+    assert ml.missing_feature_rate is not None
+    assert ml.rmse is not None
+    assert ml.precision is not None
+    assert ml.recall is not None
+
+
+def test_counter_increment_does_not_raise(app):
+    m = get_metrics()
+    m.system.requests_total.labels(
+        **m.labels(route="/test", method="GET", status="200")
+    ).inc()
+
+
+def test_gauge_set_does_not_raise(app):
+    m = get_metrics()
+    m.system.queue_depth.labels(**m.labels(queue_name="default")).set(5)

impulse_telemetry-0.1.0/tests/test_middleware.py

@@ -0,0 +1,52 @@
+"""
+Tests for impulse_telemetry.middleware
+
+Covers: RED metrics recording, X-Trace-Id header injection,
+health-check path skipping, route pattern matching.
+"""
+
+
+def test_200_response(client):
+    resp = client.get("/ping")
+    assert resp.status_code == 200
+
+
+def test_400_response(client):
+    resp = client.get("/fail")
+    assert resp.status_code == 400
+
+
+def test_trace_id_header_on_success(client):
+    resp = client.get("/ping")
+    # X-Trace-Id is injected by ImpulseMiddleware when an active span exists.
+    # With FastAPIInstrumentor wired up, a span is always created per request.
+    assert "x-trace-id" in resp.headers
+
+
+def test_trace_id_is_32_char_hex(client):
+    resp = client.get("/ping")
+    trace_id = resp.headers.get("x-trace-id", "")
+    assert len(trace_id) == 32
+    assert all(c in "0123456789abcdef" for c in trace_id)
+
+
+def test_request_id_header_forwarded(client):
+    resp = client.get("/ping", headers={"x-request-id": "req-abc"})
+    assert resp.status_code == 200
+
+
+def test_health_check_paths_are_skipped(client):
+    # These paths exist in _SKIP — middleware calls call_next without recording metrics.
+    # They 404 because we didn't register them as routes, which is fine;
+    # the important thing is that get_metrics() is not called for them.
+    for path in ("/healthz", "/readyz", "/livez"):
+        resp = client.get(path)
+        assert resp.status_code == 404   # route not found, not a middleware error
+
+
+def test_route_pattern_used_not_raw_url(client):
+    # /users/123 and /users/456 should both match route pattern /users/{user_id}
+    resp1 = client.get("/users/123")
+    resp2 = client.get("/users/456")
+    assert resp1.status_code == 200
+    assert resp2.status_code == 200

impulse_telemetry-0.1.0/tests/test_ml.py

@@ -0,0 +1,94 @@
+"""
+Tests for impulse_telemetry.ml
+
+Covers: MLMonitor.inference() context manager, @trace decorator,
+record_drift, record_performance, data quality checks, error handling.
+"""
+
+import pytest
+from impulse_telemetry.ml import MLMonitor
+
+
+@pytest.fixture(scope="module")
+def monitor(app):  # app ensures init(enable_ml=True) ran first
+    return MLMonitor(model_id="test-model", user_id="test-user")
+
+
+def test_inference_context_manager(monitor):
+    with monitor.inference() as span:
+        assert span is not None
+
+
+def test_inference_span_set(monitor):
+    with monitor.inference() as span:
+        span.set("custom_attr", "hello")
+
+
+def test_inference_record_output_list(monitor):
+    with monitor.inference() as span:
+        span.record_output([0.1, 0.9, 0.5])
+
+
+def test_inference_record_output_no_len(monitor):
+    # record_output is best-effort — scalars should not raise
+    with monitor.inference() as span:
+        span.record_output(0.42)
+
+
+def test_inference_propagates_exception(monitor):
+    with pytest.raises(ValueError, match="boom"):
+        with monitor.inference():
+            raise ValueError("boom")
+
+
+def test_trace_decorator(monitor):
+    @monitor.trace
+    def predict(x):
+        return x * 2
+
+    assert predict(5) == 10
+
+
+def test_trace_decorator_propagates_exception(monitor):
+    @monitor.trace
+    def bad():
+        raise RuntimeError("fail")
+
+    with pytest.raises(RuntimeError):
+        bad()
+
+
+def test_record_drift_does_not_raise(monitor):
+    monitor.record_drift("age", score=0.18)
+    monitor.record_drift("income", score=0.05, metric="kl")
+
+
+def test_record_performance_does_not_raise(monitor):
+    monitor.record_performance(rmse=0.042, precision=0.87, recall=0.81)
+
+
+def test_record_performance_partial(monitor):
+    monitor.record_performance(rmse=0.1)
+    monitor.record_performance(precision=0.9)
+
+
+def test_inference_with_clean_dataframe(monitor):
+    pd = pytest.importorskip("pandas")
+    df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+    with monitor.inference(features=df) as span:
+        span.record_output([0.1, 0.2, 0.3])
+
+
+def test_inference_with_missing_values_warns(monitor):
+    pd = pytest.importorskip("pandas")
+    df = pd.DataFrame({"a": [1, None, 3], "b": [None, None, 6]})
+    # Missing values are recorded as metrics + logged as warnings — should not raise
+    with monitor.inference(features=df):
+        pass
+
+
+def test_inference_with_empty_dataframe(monitor):
+    pd = pytest.importorskip("pandas")
+    df = pd.DataFrame()
+    with monitor.inference(features=df):
+        pass

impulse_telemetry-0.1.0/tests/test_tracing.py

@@ -0,0 +1,66 @@
+"""
+Tests for impulse_telemetry.tracing
+
+Covers: current_span_context, inject_headers, get_tracer.
+Uses a local TracerProvider + InMemorySpanExporter so tests are
+self-contained and don't require an OTLP collector.
+"""
+
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
+
+from impulse_telemetry.tracing import get_tracer, current_span_context, inject_headers
+
+
+def _local_tracer():
+    """Create an isolated tracer backed by an in-memory exporter."""
+    exporter = InMemorySpanExporter()
+    provider = TracerProvider()
+    provider.add_span_processor(SimpleSpanProcessor(exporter))
+    return provider.get_tracer("test"), exporter
+
+
+def test_no_active_span_returns_empty_strings():
+    ctx = current_span_context()
+    assert ctx == {"trace_id": "", "span_id": ""}
+
+
+def test_active_span_returns_hex_ids():
+    tracer, _ = _local_tracer()
+    with tracer.start_as_current_span("op"):
+        ctx = current_span_context()
+    assert len(ctx["trace_id"]) == 32
+    assert len(ctx["span_id"]) == 16
+    assert all(c in "0123456789abcdef" for c in ctx["trace_id"])
+    assert all(c in "0123456789abcdef" for c in ctx["span_id"])
+
+
+def test_inject_headers_adds_traceparent():
+    tracer, _ = _local_tracer()
+    with tracer.start_as_current_span("op"):
+        headers = inject_headers({})
+    assert "traceparent" in headers
+
+
+def test_inject_headers_no_span_returns_empty():
+    headers = inject_headers({})
+    # No active span — propagator injects nothing (or a zero traceparent)
+    assert isinstance(headers, dict)
+
+
+def test_get_tracer_returns_tracer():
+    tracer = get_tracer(__name__)
+    assert tracer is not None
+
+
+def test_span_can_set_attributes():
+    tracer, exporter = _local_tracer()
+    with tracer.start_as_current_span("op") as span:
+        span.set_attribute("key", "value")
+        span.set_attribute("count", 42)
+
+    finished = exporter.get_finished_spans()
+    assert len(finished) == 1
+    assert finished[0].attributes["key"] == "value"
+    assert finished[0].attributes["count"] == 42