012 remove signoz
This commit is contained in:
Раис Юсупалиев
@@ -13,9 +13,3 @@ repository:
|
||||
adapter:
|
||||
cdek_client_id: "yaml-id"
|
||||
cdek_client_secret: "yaml-secret"
|
||||
|
||||
observability:
|
||||
service_name: "from-config-yaml"
|
||||
|
||||
alerts:
|
||||
telegram_enabled: false
|
||||
|
||||
-10
@@ -10,13 +10,3 @@ business_logic:
|
||||
repository:
|
||||
redis_dsn: "redis://localhost:6379/0"
|
||||
price_cache_ttl_seconds: 900
|
||||
|
||||
adapter:
|
||||
cdek_base_url: "https://api.cdek.ru/v2"
|
||||
cdek_client_id: "id"
|
||||
cdek_client_secret: "secret"
|
||||
|
||||
observability:
|
||||
service_name: "g2s-aggregator"
|
||||
otlp_endpoint: ""
|
||||
log_level: "INFO"
|
||||
@@ -13,9 +13,3 @@ repository:
|
||||
adapter:
|
||||
cdek_client_id: "test-id"
|
||||
cdek_client_secret: "test-secret"
|
||||
|
||||
observability:
|
||||
service_name: "from-config-test-yaml"
|
||||
|
||||
alerts:
|
||||
telegram_enabled: false
|
||||
|
||||
@@ -1,93 +0,0 @@
|
||||
import pytest
|
||||
from pydantic import ValidationError
|
||||
|
||||
from app.config import AlertsConfig, Settings
|
||||
|
||||
|
||||
def _clear_alert_env(monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
for name in (
|
||||
"G2S_ALERTS__TELEGRAM_ENABLED",
|
||||
"G2S_ALERTS__TELEGRAM_BOT_TOKEN",
|
||||
"G2S_ALERTS__TELEGRAM_CHAT_ID",
|
||||
):
|
||||
monkeypatch.delenv(name, raising=False)
|
||||
|
||||
|
||||
def test_alerts_settings_are_loaded_from_yaml(tmp_path, monkeypatch) -> None:
|
||||
_clear_alert_env(monkeypatch)
|
||||
config_file = tmp_path / "config.yaml"
|
||||
config_file.write_text(
|
||||
"""
|
||||
alerts:
|
||||
telegram_enabled: true
|
||||
telegram_bot_token: "bot-token"
|
||||
telegram_chat_id: "-100777"
|
||||
provider_5xx:
|
||||
error_count: 7
|
||||
window_minutes: 6
|
||||
provider_p99_latency:
|
||||
threshold_ms: 5200
|
||||
window_minutes: 11
|
||||
provider_unavailable:
|
||||
duration_minutes: 8
|
||||
""".strip(),
|
||||
encoding="utf-8",
|
||||
)
|
||||
monkeypatch.setenv("G2S_CONFIG_FILE", str(config_file))
|
||||
|
||||
settings = Settings()
|
||||
|
||||
assert settings.alerts.telegram_enabled is True
|
||||
assert settings.alerts.telegram_bot_token == "bot-token"
|
||||
assert settings.alerts.telegram_chat_id == "-100777"
|
||||
assert settings.alerts.provider_5xx.error_count == 7
|
||||
assert settings.alerts.provider_5xx.window_minutes == 6
|
||||
assert settings.alerts.provider_p99_latency.threshold_ms == 5200
|
||||
assert settings.alerts.provider_p99_latency.window_minutes == 11
|
||||
assert settings.alerts.provider_unavailable.duration_minutes == 8
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("yaml_body", "error_message"),
|
||||
[
|
||||
(
|
||||
"""
|
||||
alerts:
|
||||
telegram_enabled: true
|
||||
telegram_chat_id: "-100777"
|
||||
""".strip(),
|
||||
"alerts.telegram_bot_token is required when alerts.telegram_enabled=true",
|
||||
),
|
||||
(
|
||||
"""
|
||||
alerts:
|
||||
telegram_enabled: true
|
||||
telegram_bot_token: "bot-token"
|
||||
""".strip(),
|
||||
"alerts.telegram_chat_id is required when alerts.telegram_enabled=true",
|
||||
),
|
||||
],
|
||||
)
|
||||
def test_enabled_telegram_requires_credentials(
|
||||
tmp_path,
|
||||
monkeypatch,
|
||||
yaml_body: str,
|
||||
error_message: str,
|
||||
) -> None:
|
||||
_clear_alert_env(monkeypatch)
|
||||
config_file = tmp_path / "config.yaml"
|
||||
config_file.write_text(yaml_body, encoding="utf-8")
|
||||
monkeypatch.setenv("G2S_CONFIG_FILE", str(config_file))
|
||||
|
||||
with pytest.raises(ValidationError, match=error_message):
|
||||
Settings()
|
||||
|
||||
|
||||
def test_alert_condition_defaults_match_required_thresholds() -> None:
|
||||
alerts = AlertsConfig()
|
||||
|
||||
assert alerts.provider_5xx.error_count == 5
|
||||
assert alerts.provider_5xx.window_minutes == 5
|
||||
assert alerts.provider_p99_latency.threshold_ms == 5000
|
||||
assert alerts.provider_p99_latency.window_minutes == 10
|
||||
assert alerts.provider_unavailable.duration_minutes == 5
|
||||
@@ -8,8 +8,8 @@ from app.config import Settings, get_settings
|
||||
|
||||
PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
||||
TEST_CONFIG_FILE = PROJECT_ROOT / "config.test.yaml"
|
||||
MISSING_ALERTS_CONFIG_FILE = (
|
||||
PROJECT_ROOT / "tests" / "config" / "fixtures" / "config.missing_alerts.yaml"
|
||||
MISSING_REQUIRED_SECTION_CONFIG_FILE = (
|
||||
PROJECT_ROOT / "tests" / "config" / "fixtures" / "config.missing_adapter.yaml"
|
||||
)
|
||||
DEFAULT_CONFIG_FILE_FIXTURE = (
|
||||
PROJECT_ROOT / "tests" / "config" / "fixtures" / "config.default.yaml"
|
||||
@@ -56,24 +56,21 @@ def test_configuration_sections_are_loaded_from_yaml_file(
|
||||
assert settings.adapter.cdek_retry_backoff_seconds == 0.2
|
||||
assert settings.adapter.cdek_timeout_seconds == 10.0
|
||||
assert settings.adapter.cdek_cache_ttl_seconds == 900
|
||||
assert settings.observability.service_name == "g2s-aggregator-tests"
|
||||
assert settings.observability.otlp_endpoint == ""
|
||||
assert settings.observability.log_level == "INFO"
|
||||
assert settings.alerts.telegram_enabled is False
|
||||
assert settings.alerts.telegram_bot_token is None
|
||||
assert settings.alerts.telegram_chat_id is None
|
||||
|
||||
|
||||
def test_get_settings_fails_when_required_yaml_section_is_missing(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
_use_runtime_config_files(monkeypatch, test_config_file=MISSING_ALERTS_CONFIG_FILE)
|
||||
_use_runtime_config_files(
|
||||
monkeypatch,
|
||||
test_config_file=MISSING_REQUIRED_SECTION_CONFIG_FILE,
|
||||
)
|
||||
|
||||
with pytest.raises(ValidationError) as error:
|
||||
get_settings()
|
||||
|
||||
locations = {tuple(item["loc"]) for item in error.value.errors()}
|
||||
assert ("alerts",) in locations
|
||||
assert ("adapter",) in locations
|
||||
get_settings.cache_clear()
|
||||
|
||||
|
||||
@@ -101,5 +98,5 @@ def test_get_settings_uses_config_test_yaml_in_pytest_environment(
|
||||
|
||||
assert settings.service.provider_timeout_seconds == 17.0
|
||||
assert settings.controller.api_prefix == "/from-config-test-yaml"
|
||||
assert settings.observability.service_name == "from-config-test-yaml"
|
||||
assert settings.adapter.cdek_client_id == "test-id"
|
||||
get_settings.cache_clear()
|
||||
|
||||
@@ -1,101 +0,0 @@
|
||||
import asyncio
|
||||
from uuid import UUID
|
||||
|
||||
import httpx
|
||||
|
||||
from app.config import Settings
|
||||
from app.controllers.v1.delivery import get_aggregator_service
|
||||
from app.main import create_app
|
||||
from app.schemas.request import DeliveryRequest
|
||||
|
||||
|
||||
class StubAggregatorService:
|
||||
def __init__(self) -> None:
|
||||
self.calls: list[DeliveryRequest] = []
|
||||
|
||||
async def get_all_prices(self, request: DeliveryRequest) -> list[object]:
|
||||
self.calls.append(request)
|
||||
return []
|
||||
|
||||
|
||||
def _build_payload() -> dict[str, object]:
|
||||
return {
|
||||
"entity": "individual",
|
||||
"from_city": "Moscow",
|
||||
"to_city": "Kazan",
|
||||
"weight_kg": 2.5,
|
||||
"length_cm": 30.0,
|
||||
"width_cm": 20.0,
|
||||
"height_cm": 10.0,
|
||||
}
|
||||
|
||||
|
||||
def _build_app(
|
||||
*,
|
||||
request_id_header: str,
|
||||
service: StubAggregatorService,
|
||||
) -> tuple[object, StubAggregatorService]:
|
||||
settings = Settings(
|
||||
controller={"request_id_header": request_id_header},
|
||||
observability={
|
||||
"service_name": "g2s-tests",
|
||||
"otlp_endpoint": "",
|
||||
"log_level": "INFO",
|
||||
},
|
||||
)
|
||||
app = create_app(settings=settings)
|
||||
|
||||
async def override_service() -> StubAggregatorService:
|
||||
return service
|
||||
|
||||
app.dependency_overrides[get_aggregator_service] = override_service
|
||||
return app, service
|
||||
|
||||
|
||||
def test_request_id_is_generated_per_request_and_returned_in_header() -> None:
|
||||
app, service = _build_app(
|
||||
request_id_header="X-Request-ID",
|
||||
service=StubAggregatorService(),
|
||||
)
|
||||
|
||||
async def run_requests() -> tuple[httpx.Response, httpx.Response]:
|
||||
transport = httpx.ASGITransport(app=app)
|
||||
async with httpx.AsyncClient(
|
||||
transport=transport,
|
||||
base_url="http://testserver",
|
||||
) as client:
|
||||
first = await client.post("/api/v1/delivery/price", json=_build_payload())
|
||||
second = await client.post("/api/v1/delivery/price", json=_build_payload())
|
||||
return first, second
|
||||
|
||||
first_response, second_response = asyncio.run(run_requests())
|
||||
|
||||
assert first_response.status_code == 200
|
||||
assert second_response.status_code == 200
|
||||
first_request_id = first_response.headers["X-Request-ID"]
|
||||
second_request_id = second_response.headers["X-Request-ID"]
|
||||
assert UUID(first_request_id).version == 4
|
||||
assert UUID(second_request_id).version == 4
|
||||
assert first_request_id != second_request_id
|
||||
assert len(service.calls) == 2
|
||||
|
||||
|
||||
def test_request_id_uses_configured_header_name() -> None:
|
||||
app, _ = _build_app(
|
||||
request_id_header="X-Correlation-ID",
|
||||
service=StubAggregatorService(),
|
||||
)
|
||||
|
||||
async def run_request() -> httpx.Response:
|
||||
transport = httpx.ASGITransport(app=app)
|
||||
async with httpx.AsyncClient(
|
||||
transport=transport,
|
||||
base_url="http://testserver",
|
||||
) as client:
|
||||
return await client.post("/api/v1/delivery/price", json=_build_payload())
|
||||
|
||||
response = asyncio.run(run_request())
|
||||
|
||||
assert response.status_code == 200
|
||||
assert "X-Correlation-ID" in response.headers
|
||||
assert "X-Request-ID" not in response.headers
|
||||
@@ -1,50 +0,0 @@
|
||||
import structlog
|
||||
from opentelemetry.sdk.resources import Resource
|
||||
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 structlog.testing import LogCapture
|
||||
from structlog.contextvars import bind_contextvars, clear_contextvars
|
||||
|
||||
from app.observability.logging import add_trace_context
|
||||
from app.observability.tracing import get_tracer, reset_tracing_for_tests, setup_tracing
|
||||
|
||||
|
||||
def test_logging_context_includes_request_id_and_trace_id() -> None:
|
||||
reset_tracing_for_tests()
|
||||
span_exporter = InMemorySpanExporter()
|
||||
tracer_provider = TracerProvider(resource=Resource.create({"service.name": "tests"}))
|
||||
tracer_provider.add_span_processor(SimpleSpanProcessor(span_exporter))
|
||||
setup_tracing(
|
||||
service_name="tests",
|
||||
otlp_endpoint="",
|
||||
tracer_provider=tracer_provider,
|
||||
)
|
||||
|
||||
log_capture = LogCapture()
|
||||
structlog.configure(
|
||||
processors=[
|
||||
structlog.contextvars.merge_contextvars,
|
||||
add_trace_context,
|
||||
log_capture,
|
||||
],
|
||||
logger_factory=structlog.stdlib.LoggerFactory(),
|
||||
wrapper_class=structlog.make_filtering_bound_logger(20),
|
||||
cache_logger_on_first_use=False,
|
||||
)
|
||||
logger = structlog.get_logger("test-logger")
|
||||
|
||||
clear_contextvars()
|
||||
bind_contextvars(request_id="req-test-id")
|
||||
with get_tracer(__name__).start_as_current_span("test-span"):
|
||||
logger.info("request_log")
|
||||
|
||||
assert len(log_capture.entries) == 1
|
||||
entry = log_capture.entries[0]
|
||||
assert entry["event"] == "request_log"
|
||||
assert entry["request_id"] == "req-test-id"
|
||||
assert len(entry["trace_id"]) == 32
|
||||
assert len(entry["span_id"]) == 16
|
||||
|
||||
clear_contextvars()
|
||||
reset_tracing_for_tests()
|
||||
@@ -1,204 +0,0 @@
|
||||
import asyncio
|
||||
from decimal import Decimal
|
||||
from typing import Any
|
||||
|
||||
import httpx
|
||||
from opentelemetry.sdk.metrics import MeterProvider
|
||||
from opentelemetry.sdk.metrics.export import InMemoryMetricReader
|
||||
|
||||
from app.config import Settings
|
||||
from app.controllers.v1.delivery import get_aggregator_service
|
||||
from app.observability.metrics import reset_metrics_for_tests, setup_metrics
|
||||
from app.schemas.request import DeliveryEntity, DeliveryRequest
|
||||
from app.schemas.response import DeliveryPrice
|
||||
from app.services.aggregator import AggregatorService, AggregatorServiceError
|
||||
|
||||
|
||||
class ToggleAggregatorService:
|
||||
def __init__(self) -> None:
|
||||
self.should_fail = False
|
||||
|
||||
async def get_all_prices(self, request: DeliveryRequest) -> list[DeliveryPrice]:
|
||||
_ = request
|
||||
if self.should_fail:
|
||||
raise AggregatorServiceError("failed")
|
||||
return []
|
||||
|
||||
|
||||
class StubProvider:
|
||||
def __init__(self, name: str, *, fail: bool) -> None:
|
||||
self.name = name
|
||||
self.fail = fail
|
||||
self.cache_ttl_seconds = 120
|
||||
|
||||
async def get_price(self, request: DeliveryRequest) -> DeliveryPrice:
|
||||
_ = request
|
||||
if self.fail:
|
||||
raise RuntimeError("provider unavailable")
|
||||
return DeliveryPrice(
|
||||
provider=self.name,
|
||||
service_name="economy",
|
||||
price=Decimal("99.90"),
|
||||
currency="RUB",
|
||||
delivery_days_min=2,
|
||||
delivery_days_max=3,
|
||||
)
|
||||
|
||||
|
||||
class StubCache:
|
||||
async def get(self, key: str) -> object | None:
|
||||
_ = key
|
||||
return None
|
||||
|
||||
async def set(self, key: str, value: object, ttl: int | None = None) -> None:
|
||||
_ = key, value, ttl
|
||||
|
||||
|
||||
class StubCacheHit:
|
||||
def __init__(self, payload: object) -> None:
|
||||
self.payload = payload
|
||||
|
||||
async def get(self, key: str) -> object | None:
|
||||
_ = key
|
||||
return self.payload
|
||||
|
||||
async def set(self, key: str, value: object, ttl: int | None = None) -> None:
|
||||
_ = key, value, ttl
|
||||
|
||||
|
||||
def _build_payload() -> dict[str, object]:
|
||||
return {
|
||||
"entity": "individual",
|
||||
"from_city": "Moscow",
|
||||
"to_city": "Kazan",
|
||||
"weight_kg": 2.5,
|
||||
"length_cm": 30.0,
|
||||
"width_cm": 20.0,
|
||||
"height_cm": 10.0,
|
||||
}
|
||||
|
||||
|
||||
def _build_request() -> DeliveryRequest:
|
||||
return DeliveryRequest(
|
||||
entity=DeliveryEntity.INDIVIDUAL,
|
||||
from_city="Moscow",
|
||||
to_city="Kazan",
|
||||
weight_kg=2.5,
|
||||
length_cm=30.0,
|
||||
width_cm=20.0,
|
||||
height_cm=10.0,
|
||||
)
|
||||
|
||||
|
||||
def _iter_data_points(metrics_data: Any, metric_name: str) -> list[Any]:
|
||||
points: list[Any] = []
|
||||
if metrics_data is None:
|
||||
return points
|
||||
for resource_metric in metrics_data.resource_metrics:
|
||||
for scope_metric in resource_metric.scope_metrics:
|
||||
for metric in scope_metric.metrics:
|
||||
if metric.name == metric_name:
|
||||
points.extend(metric.data.data_points)
|
||||
return points
|
||||
|
||||
|
||||
def test_metrics_export_requests_errors_latency_and_provider_availability() -> None:
|
||||
reset_metrics_for_tests()
|
||||
metric_reader = InMemoryMetricReader()
|
||||
meter_provider = MeterProvider(metric_readers=[metric_reader])
|
||||
setup_metrics(
|
||||
service_name="g2s-tests",
|
||||
otlp_endpoint="",
|
||||
meter_provider=meter_provider,
|
||||
)
|
||||
|
||||
from app.main import create_app
|
||||
|
||||
toggle_service = ToggleAggregatorService()
|
||||
app = create_app(
|
||||
settings=Settings(
|
||||
observability={
|
||||
"service_name": "g2s-tests",
|
||||
"otlp_endpoint": "",
|
||||
"log_level": "INFO",
|
||||
}
|
||||
)
|
||||
)
|
||||
|
||||
async def override_service() -> ToggleAggregatorService:
|
||||
return toggle_service
|
||||
|
||||
app.dependency_overrides[get_aggregator_service] = override_service
|
||||
|
||||
async def run_requests() -> tuple[httpx.Response, httpx.Response]:
|
||||
transport = httpx.ASGITransport(app=app, raise_app_exceptions=False)
|
||||
async with httpx.AsyncClient(
|
||||
transport=transport,
|
||||
base_url="http://testserver",
|
||||
) as client:
|
||||
success = await client.post("/api/v1/delivery/price", json=_build_payload())
|
||||
toggle_service.should_fail = True
|
||||
failure = await client.post("/api/v1/delivery/price", json=_build_payload())
|
||||
return success, failure
|
||||
|
||||
success_response, failure_response = asyncio.run(run_requests())
|
||||
assert success_response.status_code == 200
|
||||
assert failure_response.status_code == 503
|
||||
|
||||
availability_service = AggregatorService(
|
||||
providers=[
|
||||
StubProvider("available-provider", fail=False),
|
||||
StubProvider("unavailable-provider", fail=True),
|
||||
],
|
||||
cache=StubCache(),
|
||||
)
|
||||
asyncio.run(availability_service.get_all_prices(_build_request()))
|
||||
|
||||
metrics_data = metric_reader.get_metrics_data()
|
||||
request_points = _iter_data_points(metrics_data, "http.server.request.count")
|
||||
error_points = _iter_data_points(metrics_data, "http.server.error.count")
|
||||
latency_points = _iter_data_points(metrics_data, "http.server.request.latency")
|
||||
availability_points = _iter_data_points(metrics_data, "delivery.provider.availability")
|
||||
|
||||
assert sum(point.value for point in request_points) == 2
|
||||
assert sum(point.value for point in error_points) == 1
|
||||
assert sum(point.count for point in latency_points) == 2
|
||||
assert sum(point.count for point in availability_points) == 2
|
||||
assert sorted(point.sum for point in availability_points) == [0.0, 1.0]
|
||||
|
||||
reset_metrics_for_tests()
|
||||
|
||||
|
||||
def test_provider_availability_not_recorded_on_cache_hit() -> None:
|
||||
reset_metrics_for_tests()
|
||||
metric_reader = InMemoryMetricReader()
|
||||
meter_provider = MeterProvider(metric_readers=[metric_reader])
|
||||
setup_metrics(
|
||||
service_name="g2s-tests",
|
||||
otlp_endpoint="",
|
||||
meter_provider=meter_provider,
|
||||
)
|
||||
|
||||
cached_price = DeliveryPrice(
|
||||
provider="cached-provider",
|
||||
service_name="economy",
|
||||
price=Decimal("95.50"),
|
||||
currency="RUB",
|
||||
delivery_days_min=2,
|
||||
delivery_days_max=3,
|
||||
).model_dump(mode="json")
|
||||
provider = StubProvider("cached-provider", fail=True)
|
||||
service = AggregatorService(
|
||||
providers=[provider],
|
||||
cache=StubCacheHit(cached_price),
|
||||
)
|
||||
|
||||
result = asyncio.run(service.get_all_prices(_build_request()))
|
||||
assert len(result) == 1
|
||||
assert result[0].provider == "cached-provider"
|
||||
|
||||
metrics_data = metric_reader.get_metrics_data()
|
||||
availability_points = _iter_data_points(metrics_data, "delivery.provider.availability")
|
||||
assert availability_points == []
|
||||
|
||||
reset_metrics_for_tests()
|
||||
@@ -1,160 +0,0 @@
|
||||
import asyncio
|
||||
from decimal import Decimal
|
||||
|
||||
import httpx
|
||||
from fastapi import FastAPI
|
||||
from opentelemetry.instrumentation.httpx import HTTPXClientInstrumentor
|
||||
from opentelemetry.sdk.resources import Resource
|
||||
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 opentelemetry.trace import SpanKind
|
||||
|
||||
from app.observability.tracing import (
|
||||
instrument_fastapi_app,
|
||||
instrument_httpx_client,
|
||||
reset_tracing_for_tests,
|
||||
setup_tracing,
|
||||
)
|
||||
from app.schemas.request import DeliveryEntity, DeliveryRequest
|
||||
from app.schemas.response import DeliveryPrice
|
||||
from app.services.aggregator import AggregatorService
|
||||
|
||||
|
||||
class StubProvider:
|
||||
name = "stub-provider"
|
||||
cache_ttl_seconds = 120
|
||||
|
||||
async def get_price(self, request: DeliveryRequest) -> DeliveryPrice:
|
||||
_ = request
|
||||
return DeliveryPrice(
|
||||
provider=self.name,
|
||||
service_name="economy",
|
||||
price=Decimal("100.10"),
|
||||
currency="RUB",
|
||||
delivery_days_min=2,
|
||||
delivery_days_max=4,
|
||||
)
|
||||
|
||||
|
||||
class StubCache:
|
||||
async def get(self, key: str) -> object | None:
|
||||
_ = key
|
||||
return None
|
||||
|
||||
async def set(self, key: str, value: object, ttl: int | None = None) -> None:
|
||||
_ = key, value, ttl
|
||||
|
||||
|
||||
def _build_request() -> DeliveryRequest:
|
||||
return DeliveryRequest(
|
||||
entity=DeliveryEntity.INDIVIDUAL,
|
||||
from_city="Moscow",
|
||||
to_city="Kazan",
|
||||
weight_kg=1.5,
|
||||
length_cm=10.0,
|
||||
width_cm=20.0,
|
||||
height_cm=30.0,
|
||||
)
|
||||
|
||||
|
||||
def test_manual_spans_capture_required_attributes() -> None:
|
||||
reset_tracing_for_tests()
|
||||
span_exporter = InMemorySpanExporter()
|
||||
tracer_provider = TracerProvider(resource=Resource.create({"service.name": "tests"}))
|
||||
tracer_provider.add_span_processor(SimpleSpanProcessor(span_exporter))
|
||||
setup_tracing(
|
||||
service_name="tests",
|
||||
otlp_endpoint="",
|
||||
tracer_provider=tracer_provider,
|
||||
)
|
||||
|
||||
service = AggregatorService(providers=[StubProvider()], cache=StubCache())
|
||||
asyncio.run(service.get_all_prices(_build_request()))
|
||||
|
||||
spans = span_exporter.get_finished_spans()
|
||||
span_by_name = {span.name: span for span in spans}
|
||||
|
||||
assert "AggregatorService.get_all_prices" in span_by_name
|
||||
assert "DeliveryProvider.get_price" in span_by_name
|
||||
assert "PriceCache.get" in span_by_name
|
||||
assert "PriceCache.set" in span_by_name
|
||||
|
||||
service_span = span_by_name["AggregatorService.get_all_prices"]
|
||||
assert service_span.attributes["from_city"] == "Moscow"
|
||||
assert service_span.attributes["to_city"] == "Kazan"
|
||||
assert service_span.attributes["weight_kg"] == 1.5
|
||||
assert service_span.attributes["tariffs_found"] == 1
|
||||
|
||||
provider_span = span_by_name["DeliveryProvider.get_price"]
|
||||
assert provider_span.attributes["provider"] == "stub-provider"
|
||||
assert provider_span.attributes["cache_hit"] is False
|
||||
assert provider_span.attributes["from_city"] == "Moscow"
|
||||
assert provider_span.attributes["to_city"] == "Kazan"
|
||||
assert provider_span.attributes["weight_kg"] == 1.5
|
||||
|
||||
cache_span = span_by_name["PriceCache.get"]
|
||||
assert cache_span.attributes["cache_hit"] is False
|
||||
|
||||
reset_tracing_for_tests()
|
||||
|
||||
|
||||
def test_fastapi_and_httpx_instrumentation_emit_server_and_client_spans() -> None:
|
||||
reset_tracing_for_tests()
|
||||
span_exporter = InMemorySpanExporter()
|
||||
tracer_provider = TracerProvider(resource=Resource.create({"service.name": "tests"}))
|
||||
tracer_provider.add_span_processor(SimpleSpanProcessor(span_exporter))
|
||||
setup_tracing(
|
||||
service_name="tests",
|
||||
otlp_endpoint="",
|
||||
tracer_provider=tracer_provider,
|
||||
)
|
||||
|
||||
app = FastAPI()
|
||||
|
||||
@app.get("/proxy")
|
||||
async def proxy() -> dict[str, int]:
|
||||
def handler(request: httpx.Request) -> httpx.Response:
|
||||
_ = request
|
||||
return httpx.Response(status_code=200, json={"ok": True})
|
||||
|
||||
transport = httpx.MockTransport(handler)
|
||||
async with httpx.AsyncClient(
|
||||
transport=transport,
|
||||
base_url="https://provider.test",
|
||||
) as client:
|
||||
HTTPXClientInstrumentor.instrument_client(client, tracer_provider=tracer_provider)
|
||||
response = await client.get("/quote")
|
||||
return {"status_code": response.status_code}
|
||||
|
||||
instrument_fastapi_app(app)
|
||||
instrument_httpx_client()
|
||||
|
||||
async def run_request() -> httpx.Response:
|
||||
transport = httpx.ASGITransport(app=app)
|
||||
async with httpx.AsyncClient(
|
||||
transport=transport,
|
||||
base_url="http://testserver",
|
||||
) as client:
|
||||
return await client.get("/proxy")
|
||||
|
||||
response = asyncio.run(run_request())
|
||||
assert response.status_code == 200
|
||||
|
||||
spans = span_exporter.get_finished_spans()
|
||||
assert any(span.kind == SpanKind.SERVER for span in spans)
|
||||
assert any(span.kind == SpanKind.CLIENT for span in spans)
|
||||
assert any(
|
||||
(
|
||||
"provider.test/quote"
|
||||
in (
|
||||
span.attributes.get("http.url")
|
||||
or span.attributes.get("url.full")
|
||||
or ""
|
||||
)
|
||||
)
|
||||
for span in spans
|
||||
if span.kind == SpanKind.CLIENT
|
||||
)
|
||||
|
||||
reset_tracing_for_tests()
|
||||
@@ -18,12 +18,12 @@ def test_compose_defines_required_services() -> None:
|
||||
compose = _load_compose()
|
||||
services = compose.get("services")
|
||||
assert isinstance(services, dict)
|
||||
assert {"app", "redis", "signoz"}.issubset(services.keys())
|
||||
assert {"app", "redis"}.issubset(services.keys())
|
||||
|
||||
|
||||
def test_smoke_command_sequence_is_documented() -> None:
|
||||
readme = INFRA_README.read_text(encoding="utf-8")
|
||||
|
||||
assert "docker compose config" in readme
|
||||
assert "docker compose up -d redis signoz" in readme
|
||||
assert "docker compose up -d redis" in readme
|
||||
assert "docker compose ps" in readme
|
||||
|
||||
Reference in New Issue
Block a user