refactor: fix lints

Author: Cooh12

.pre-commit-config.yaml

@@ -1,5 +1,5 @@
 default_language_version:
-  python: python3.12
+  python: python3.10
 
 repos:
   - repo: https://github.com/compilerla/conventional-pre-commit

src/asgi_monitor/integrations/aiohttp.py

@@ -14,25 +14,25 @@
 from opentelemetry.propagators.textmap import Getter
 from opentelemetry.semconv.metrics import MetricInstruments
 from opentelemetry.semconv.trace import SpanAttributes
-from opentelemetry.trace import Status, StatusCode, Tracer, TracerProvider
+from opentelemetry.trace import Status, Tracer, TracerProvider
 
 from asgi_monitor.metrics import get_latest_metrics
 from asgi_monitor.metrics.config import BaseMetricsConfig
 from asgi_monitor.metrics.manager import MetricsManager, build_metrics_manager
 
 __all__ = (
     "MetricsConfig",
-    "build_metrics_middleware",
     "get_metrics",
     "setup_metrics",
     "TracingConfig",
     "setup_tracing",
 )
 
 
-OTEL_SCHEMA = "https://opentelemetry.io/schemas/1.11.0"
+_OTEL_SCHEMA = "https://opentelemetry.io/schemas/1.11.0"
 
-_duration_attrs = [
+
+_DURATION_ATTRS = [
     SpanAttributes.HTTP_METHOD,
     SpanAttributes.HTTP_HOST,
     SpanAttributes.HTTP_SCHEME,
@@ -44,7 +44,7 @@
     SpanAttributes.HTTP_ROUTE,
 ]
 
-_active_requests_count_attrs = [
+_ACTIVE_REQUESTS_COUNT_ATTRS = [
     SpanAttributes.HTTP_METHOD,
     SpanAttributes.HTTP_HOST,
     SpanAttributes.HTTP_SCHEME,
@@ -64,39 +64,35 @@ def keys(self, carrier: dict) -> list:
         return list(carrier.keys())
 
 
-getter = AiohttpGetter()
-
-
 def _get_tracer(tracer_provider: TracerProvider | None = None) -> Tracer:
     return trace.get_tracer(
         __name__,
         tracer_provider=tracer_provider,
-        schema_url=OTEL_SCHEMA,
+        schema_url=_OTEL_SCHEMA,
     )
 
 
-def get_meter(
+def _get_meter(
     name: str,
-    version: str = "",
     meter_provider: MeterProvider | None = None,
     schema_url: str | None = None,
 ) -> Meter:
     if meter_provider is None:
         meter_provider = get_meter_provider()
-    return meter_provider.get_meter(name, version, schema_url)
+    return meter_provider.get_meter(name=name, schema_url=schema_url)
 
 
 def _parse_duration_attrs(req_attrs: dict[str, Any]) -> dict[str, Any]:
     duration_attrs = {}
-    for attr_key in _duration_attrs:
+    for attr_key in _DURATION_ATTRS:
         if req_attrs.get(attr_key) is not None:
             duration_attrs[attr_key] = req_attrs[attr_key]
     return duration_attrs
 
 
 def _parse_active_request_count_attrs(req_attrs: dict[str, Any]) -> dict[str, Any]:
     active_requests_count_attrs = {}
-    for attr_key in _active_requests_count_attrs:
+    for attr_key in _ACTIVE_REQUESTS_COUNT_ATTRS:
         if req_attrs.get(attr_key) is not None:
             active_requests_count_attrs[attr_key] = req_attrs[attr_key]
     return active_requests_count_attrs
@@ -107,19 +103,10 @@ def _get_default_span_details(request: Request) -> tuple[str, dict]:
     return span_name, {}
 
 
-def set_status_code(span: trace.Span, status_code: int) -> None:
-    try:
-        status_code = int(status_code)
-    except ValueError:
-        span.set_status(
-            Status(
-                StatusCode.ERROR,
-                "Non-integer HTTP status: " + repr(status_code),
-            )
-        )
-    else:
-        span.set_attribute(SpanAttributes.HTTP_STATUS_CODE, status_code)
-        span.set_status(Status(http_status_to_status_code(status_code, server_span=True)))
+def _set_status_code(span: trace.Span, status_code: int) -> None:
+    status_code = int(status_code)
+    span.set_attribute(SpanAttributes.HTTP_STATUS_CODE, status_code)
+    span.set_status(Status(http_status_to_status_code(status_code, server_span=True)))
 
 
 @dataclass(slots=True, frozen=True)
@@ -144,12 +131,11 @@ class TracingConfig:
     https://opentelemetry-python-contrib.readthedocs.io/en/latest/instrumentation/asgi/asgi.html
     """
 
-    exclude_urls_env_key: str = "AIOHTTP"
+    scope_span_details_extractor: Callable[[Request], tuple[str, dict[str, Any]]] = _get_default_span_details
     """
-    Key to use when checking whether a list of excluded urls is passed via ENV.
-    OpenTelemetry supports excluding urls by passing an env in the format '{exclude_urls_env_key}_EXCLUDED_URLS'.
+    Callback which should return a string and a tuple, representing the desired default span name and a dictionary
+    with any additional span attributes to set.
     """
-    scope_span_details_extractor: Callable[[Request], tuple[str, dict[str, Any]]] = _get_default_span_details
 
     meter_provider: MeterProvider | None = field(default=None)
     """Optional meter provider to use."""
@@ -186,6 +172,7 @@ async def metrics_middleware(request: Request, handler: Callable) -> Any:
         else:
             after_time = time.perf_counter()
             status_code = response.status
+
             exemplar: dict[str, str] | None = None
 
             if include_trace_exemplar:
@@ -210,22 +197,22 @@ async def metrics_middleware(request: Request, handler: Callable) -> Any:
 
 def build_tracing_middleware(config: TracingConfig) -> Callable[..., Coroutine]:
     tracer = _get_tracer(config.tracer_provider)
-    meter = get_meter(
-        name="AIOHTTP",
+    meter = _get_meter(
+        name="aiohttp",
         meter_provider=config.meter_provider,
-        schema_url=OTEL_SCHEMA,
+        schema_url=_OTEL_SCHEMA,
     )
     duration_histogram = meter.create_histogram(
         name=MetricInstruments.HTTP_SERVER_DURATION,
         unit="ms",
         description="Measures the duration of inbound HTTP requests.",
     )
-
     active_requests_counter = meter.create_up_down_counter(
         name=MetricInstruments.HTTP_SERVER_ACTIVE_REQUESTS,
         unit="requests",
         description="measures the number of concurrent HTTP requests those are currently in flight",
     )
+    getter = AiohttpGetter()
 
     @middleware
     async def tracing_middleware(request: Request, handler: Callable) -> Any:
@@ -247,9 +234,9 @@ async def tracing_middleware(request: Request, handler: Callable) -> Any:
             active_requests_counter.add(1, active_requests_count_attrs)
             try:
                 resp = await handler(request)
-                set_status_code(span, resp.status)
+                _set_status_code(span, resp.status)
             except HTTPException as ex:
-                set_status_code(span, ex.status_code)
+                _set_status_code(span, ex.status_code)
                 raise
             finally:
                 duration = max((default_timer() - start) * 1000, 0)
@@ -278,13 +265,13 @@ def setup_metrics(app: Application, config: MetricsConfig) -> None:
     metrics_middleware = build_metrics_middleware(
         metrics_manager=metrics, include_trace_exemplar=config.include_trace_exemplar
     )
-    app._middlewares.append(metrics_middleware)  # noqa: SLF001
+    app.middlewares.append(metrics_middleware)
 
     if config.include_metrics_endpoint:
         app.metrics_registry = config.registry
         app.openmetrics_format = config.openmetrics_format
-        app.router.add_get(path="/metrics", handler=get_metrics, name="Get_Prometheus_metrics")
+        app.router.add_get(path="/metrics", handler=get_metrics)
 
 
 def setup_tracing(app: Application, config: TracingConfig) -> None:
-    app._middlewares.append(build_tracing_middleware(config))  # noqa: SLF001
+    app.middlewares.append(build_tracing_middleware(config))

tests/integration/aiohttp/test_middlewares.py

@@ -1,13 +1,17 @@
 import asyncio
 import json
-from typing import Callable, cast
+from typing import TYPE_CHECKING, cast
 
+from aiohttp.pytest_plugin import AiohttpClient
 from aiohttp.test_utils import TestClient  # noqa: TCH002
 from aiohttp.web import Application, Request, Response, json_response
 from aiohttp.web_exceptions import HTTPInternalServerError
 from assertpy import assert_that
 from prometheus_client import REGISTRY
 
+if TYPE_CHECKING:
+    from opentelemetry.sdk.trace import Span
+
 from asgi_monitor.integrations.aiohttp import MetricsConfig, setup_metrics, setup_tracing
 from asgi_monitor.metrics import get_latest_metrics
 from tests.integration.factory import build_aiohttp_tracing_config
@@ -27,10 +31,10 @@ async def json_response_handler(request: Request) -> Response:
 
 
 async def raise_handler(request: Request) -> Response:
-    raise HTTPInternalServerError()
+    raise HTTPInternalServerError
 
 
-async def test_metrics(aiohttp_client: Callable) -> None:
+async def test_metrics(aiohttp_client: AiohttpClient) -> None:
     # Arrange
     expected_content_type = "text/plain; version=0.0.4; charset=utf-8"
 
@@ -59,7 +63,7 @@ async def test_metrics(aiohttp_client: Callable) -> None:
     )
 
 
-async def test_metrics_global_registry(aiohttp_client: Callable) -> None:
+async def test_metrics_global_registry(aiohttp_client: AiohttpClient) -> None:
     # Arrange
     app = Application()
 
@@ -85,7 +89,7 @@ async def test_metrics_global_registry(aiohttp_client: Callable) -> None:
     )
 
 
-async def test_metrics_get_path(aiohttp_client: Callable) -> None:
+async def test_metrics_get_path(aiohttp_client: AiohttpClient) -> None:
     # Arrange
     app = Application()
 
@@ -110,7 +114,7 @@ async def test_metrics_get_path(aiohttp_client: Callable) -> None:
     )
 
 
-async def test_metrics_with_tracing(aiohttp_client: Callable) -> None:
+async def test_metrics_with_tracing(aiohttp_client: AiohttpClient) -> None:
     # Arrange
     app = Application()
     app.router.add_get("/", index_handler)
@@ -131,7 +135,15 @@ async def test_metrics_with_tracing(aiohttp_client: Callable) -> None:
     # Assert
     assert response.status == 200
     metrics = get_latest_metrics(metrics_cfg.registry, openmetrics_format=True)
-    span = exporter.get_finished_spans()[0]
+    span = cast("tuple[Span, Span, Span]", exporter.get_finished_spans())
+    assert_that(span[0].attributes).is_equal_to(
+        {
+            "http.host": "0.0.0.0",  # noqa: S104
+            "net.host.port": 80,
+            "http.url": "http://0.0.0.0",
+            "http.status_code": 200,
+        }
+    )
     pattern = (
         r"aiohttp_request_duration_seconds_bucket\{"
         r'app_name="test",le="([\d.]+)",method="GET",path="\/"}\ 1.0 # \{TraceID="(\w+)"\} (\d+\.\d+) (\d+\.\d+)'
@@ -140,7 +152,7 @@ async def test_metrics_with_tracing(aiohttp_client: Callable) -> None:
     assert_that(metrics.payload.decode()).contains('aiohttp_app_info{app_name="test"} 1.0')
 
 
-async def test_metrics_openmetrics_with_tracing(aiohttp_client: Callable) -> None:
+async def test_metrics_openmetrics_with_tracing(aiohttp_client: AiohttpClient) -> None:
     # Arrange
     expected_content_type = "application/openmetrics-text; version=1.0.0; charset=utf-8"
 
@@ -175,7 +187,7 @@ async def test_metrics_openmetrics_with_tracing(aiohttp_client: Callable) -> Non
     assert_that(metrics_content).contains('aiohttp_app_info{app_name="test"} 1.0')
 
 
-async def test_handle_exception(aiohttp_client: Callable) -> None:
+async def test_error_metrics(aiohttp_client: AiohttpClient) -> None:
     # Arrange
     expected_content_type = "text/plain; version=0.0.4; charset=utf-8"
 
@@ -215,7 +227,7 @@ async def test_handle_exception(aiohttp_client: Callable) -> None:
         )
 
 
-async def test_json_response_handle(aiohttp_client: Callable) -> None:
+async def test_json_response_handle(aiohttp_client: AiohttpClient) -> None:
     # Arrange
     expected_content_type = "text/plain; version=0.0.4; charset=utf-8"
 
@@ -247,7 +259,7 @@ async def test_json_response_handle(aiohttp_client: Callable) -> None:
     )
 
 
-async def test_error_handle_with_tracing(aiohttp_client: Callable) -> None:
+async def test_error_handle_with_tracing(aiohttp_client: AiohttpClient) -> None:
     # Arrange
     app = Application()
     app.router.add_get("/error", zero_division_handler)
@@ -275,7 +287,7 @@ async def test_error_handle_with_tracing(aiohttp_client: Callable) -> None:
     )
 
 
-async def test_raise_handler_with_tracing(aiohttp_client: Callable) -> None:
+async def test_raise_handler_with_tracing(aiohttp_client: AiohttpClient) -> None:
     # Arrange
     app = Application()
     app.router.add_get("/raise_handler", raise_handler)
@@ -301,7 +313,7 @@ async def test_raise_handler_with_tracing(aiohttp_client: Callable) -> None:
     )
 
 
-async def test_tracing(aiohttp_client: Callable) -> None:
+async def test_tracing(aiohttp_client: AiohttpClient) -> None:
     # Arrange
     app = Application()
     app.router.add_get("/", index_handler)
@@ -313,12 +325,14 @@ async def test_tracing(aiohttp_client: Callable) -> None:
     client: TestClient = await aiohttp_client(app)
     # Act
     response = await client.get("/")
+    # Assert
     span = cast("tuple[Span, Span, Span]", exporter.get_finished_spans())
-    assert_that(span[0].attributes).is_equal_to({
-            'http.host': '0.0.0.0',
-            'net.host.port': 80,
-            'http.url': 'http://0.0.0.0',
-            'http.status_code': 200
+    assert_that(span[0].attributes).is_equal_to(
+        {
+            "http.host": "0.0.0.0",  # noqa: S104
+            "net.host.port": 80,
+            "http.url": "http://0.0.0.0",
+            "http.status_code": 200,
         }
     )
     assert response.status == 200