get rid of anonymous class factory, do init in __init__() instead

Author: matt-codecov

sentry_sdk/integrations/rust_tracing.py

@@ -226,38 +226,34 @@ def on_record(self, span_id: str, values: str, span_state: TraceState) -> None:
             sentry_span.set_data(key, value)
 
 
-def _create_integration(
-    identifier: str,
-    initializer: Callable[[RustTracingLayer], None],
-    event_type_mapping: Callable[
-        [Dict[str, Any]], EventTypeMapping
-    ] = default_event_type_mapping,
-    span_filter: Callable[[Dict[str, Any]], bool] = default_span_filter,
-) -> object:
+class RustTracingIntegration(Integration):
     """
-    Each native extension used by a project requires its own integration, but
-    `sentry_sdk` does not expect multiple instances of the same integration. To
-    work around that, invoking `RustTracingIntegration()` actually calls this
-    factory function which creates a unique anonymous class and returns an
-    instance of it.
+    Ingests tracing data from a Rust native extension's `tracing` instrumentation.
+
+    If a project uses more than one Rust native extension, each one will need
+    its own instance of `RustTracingIntegration` with an initializer function
+    specific to that extension.
+
+    Since all of the setup for this integration requires instance-specific state
+    which is not available in `setup_once()`, setup instead happens in `__init__()`.
     """
-    origin = f"auto.native_extension.{identifier}"
-    tracing_layer = RustTracingLayer(origin, event_type_mapping, span_filter)
 
-    def setup_once() -> None:
-        initializer(tracing_layer)
-
-    anonymous_class = type(
-        "",
-        (Integration,),
-        {
-            "identifier": identifier,
-            "setup_once": setup_once,
-            "tracing_layer": tracing_layer,
-        },
-    )
-    anonymous_class_instance = anonymous_class()
-    return anonymous_class_instance
+    def __init__(
+        self,
+        identifier: str,
+        initializer: Callable[[RustTracingLayer], None],
+        event_type_mapping: Callable[
+            [Dict[str, Any]], EventTypeMapping
+        ] = default_event_type_mapping,
+        span_filter: Callable[[Dict[str, Any]], bool] = default_span_filter,
+    ):
+        self.identifier = identifier
+
+        origin = f"auto.native_extension.{identifier}"
+        self.tracing_layer = RustTracingLayer(origin, event_type_mapping, span_filter)
 
+        initializer(self.tracing_layer)
 
-RustTracingIntegration = _create_integration
+    @staticmethod
+    def setup_once() -> None:
+        pass

tests/integrations/rust_tracing/test_rust_tracing.py

@@ -61,9 +61,11 @@ def record(self, span_id: int):
         self.layer.on_record(str(span_id), """{"version": "memoized"}""", state)
 
 
-def test_on_new_span_on_close(sentry_init, reset_integrations, capture_events):
+def test_on_new_span_on_close(sentry_init, capture_events):
     rust_tracing = FakeRustTracing()
-    integration = RustTracingIntegration("test", rust_tracing.set_layer_impl)
+    integration = RustTracingIntegration(
+        "test_on_new_span_on_close", rust_tracing.set_layer_impl
+    )
     sentry_init(integrations=[integration], traces_sample_rate=1.0)
 
     events = capture_events()
@@ -84,7 +86,7 @@ def test_on_new_span_on_close(sentry_init, reset_integrations, capture_events):
     # Ensure the span metadata is wired up
     span = event["spans"][0]
     assert span["op"] == "native_extension"
-    assert span["origin"] == "auto.native_extension.test"
+    assert span["origin"] == "auto.native_extension.test_on_new_span_on_close"
     assert span["description"] == "_bindings::fibonacci"
 
     # Ensure the span was opened/closed appropriately
@@ -98,9 +100,11 @@ def test_on_new_span_on_close(sentry_init, reset_integrations, capture_events):
     assert data["version"] is None
 
 
-def test_nested_on_new_span_on_close(sentry_init, reset_integrations, capture_events):
+def test_nested_on_new_span_on_close(sentry_init, capture_events):
     rust_tracing = FakeRustTracing()
-    integration = RustTracingIntegration("test", rust_tracing.set_layer_impl)
+    integration = RustTracingIntegration(
+        "test_nested_on_new_span_on_close", rust_tracing.set_layer_impl
+    )
     sentry_init(integrations=[integration], traces_sample_rate=1.0)
 
     events = capture_events()
@@ -138,10 +142,15 @@ def test_nested_on_new_span_on_close(sentry_init, reset_integrations, capture_ev
     # Ensure the span metadata is wired up for all spans
     first_span, second_span = event["spans"]
     assert first_span["op"] == "native_extension"
-    assert first_span["origin"] == "auto.native_extension.test"
+    assert (
+        first_span["origin"] == "auto.native_extension.test_nested_on_new_span_on_close"
+    )
     assert first_span["description"] == "_bindings::fibonacci"
     assert second_span["op"] == "native_extension"
-    assert second_span["origin"] == "auto.native_extension.test"
+    assert (
+        second_span["origin"]
+        == "auto.native_extension.test_nested_on_new_span_on_close"
+    )
     assert second_span["description"] == "_bindings::fibonacci"
 
     # Ensure the spans were opened/closed appropriately
@@ -164,7 +173,9 @@ def test_nested_on_new_span_on_close(sentry_init, reset_integrations, capture_ev
 
 def test_on_new_span_without_transaction(sentry_init, reset_integrations):
     rust_tracing = FakeRustTracing()
-    integration = RustTracingIntegration("test", rust_tracing.set_layer_impl)
+    integration = RustTracingIntegration(
+        "test_on_new_span_without_transaction", rust_tracing.set_layer_impl
+    )
     sentry_init(integrations=[integration], traces_sample_rate=1.0)
 
     assert sentry_sdk.get_current_span() is None
@@ -176,10 +187,12 @@ def test_on_new_span_without_transaction(sentry_init, reset_integrations):
     assert current_span.containing_transaction is None
 
 
-def test_on_event_exception(sentry_init, reset_integrations, capture_events):
+def test_on_event_exception(sentry_init, capture_events):
     rust_tracing = FakeRustTracing()
     integration = RustTracingIntegration(
-        "test", rust_tracing.set_layer_impl, event_type_mapping=_test_event_type_mapping
+        "test_on_event_exception",
+        rust_tracing.set_layer_impl,
+        event_type_mapping=_test_event_type_mapping,
     )
     sentry_init(integrations=[integration], traces_sample_rate=1.0)
 
@@ -210,10 +223,12 @@ def test_on_event_exception(sentry_init, reset_integrations, capture_events):
     assert field_context["message"] == "Getting the 10th fibonacci number"
 
 
-def test_on_event_breadcrumb(sentry_init, reset_integrations, capture_events):
+def test_on_event_breadcrumb(sentry_init, capture_events):
     rust_tracing = FakeRustTracing()
     integration = RustTracingIntegration(
-        "test", rust_tracing.set_layer_impl, event_type_mapping=_test_event_type_mapping
+        "test_on_event_breadcrumb",
+        rust_tracing.set_layer_impl,
+        event_type_mapping=_test_event_type_mapping,
     )
     sentry_init(integrations=[integration], traces_sample_rate=1.0)
 
@@ -239,10 +254,12 @@ def test_on_event_breadcrumb(sentry_init, reset_integrations, capture_events):
     assert breadcrumbs[0]["type"] == "default"
 
 
-def test_on_event_event(sentry_init, reset_integrations, capture_events):
+def test_on_event_event(sentry_init, capture_events):
     rust_tracing = FakeRustTracing()
     integration = RustTracingIntegration(
-        "test", rust_tracing.set_layer_impl, event_type_mapping=_test_event_type_mapping
+        "test_on_event_event",
+        rust_tracing.set_layer_impl,
+        event_type_mapping=_test_event_type_mapping,
     )
     sentry_init(integrations=[integration], traces_sample_rate=1.0)
 
@@ -274,10 +291,12 @@ def test_on_event_event(sentry_init, reset_integrations, capture_events):
     assert field_context["message"] == "Getting the 10th fibonacci number"
 
 
-def test_on_event_ignored(sentry_init, reset_integrations, capture_events):
+def test_on_event_ignored(sentry_init, capture_events):
     rust_tracing = FakeRustTracing()
     integration = RustTracingIntegration(
-        "test", rust_tracing.set_layer_impl, event_type_mapping=_test_event_type_mapping
+        "test_on_event_ignored",
+        rust_tracing.set_layer_impl,
+        event_type_mapping=_test_event_type_mapping,
     )
     sentry_init(integrations=[integration], traces_sample_rate=1.0)
 
@@ -298,7 +317,7 @@ def test_on_event_ignored(sentry_init, reset_integrations, capture_events):
     assert "message" not in tx
 
 
-def test_span_filter(sentry_init, reset_integrations, capture_events):
+def test_span_filter(sentry_init, capture_events):
     def span_filter(metadata: Dict[str, object]) -> bool:
         return RustTracingLevel(metadata.get("level")) in (
             RustTracingLevel.Error,
@@ -309,7 +328,7 @@ def span_filter(metadata: Dict[str, object]) -> bool:
 
     rust_tracing = FakeRustTracing()
     integration = RustTracingIntegration(
-        "test", rust_tracing.set_layer_impl, span_filter=span_filter
+        "test_span_filter", rust_tracing.set_layer_impl, span_filter=span_filter
     )
     sentry_init(integrations=[integration], traces_sample_rate=1.0)
 
@@ -340,7 +359,7 @@ def span_filter(metadata: Dict[str, object]) -> bool:
 
 def test_record(sentry_init, reset_integrations):
     rust_tracing = FakeRustTracing()
-    integration = RustTracingIntegration("test", rust_tracing.set_layer_impl)
+    integration = RustTracingIntegration("test_record", rust_tracing.set_layer_impl)
     sentry_init(integrations=[integration], traces_sample_rate=1.0)
 
     with start_transaction():
@@ -362,7 +381,9 @@ def span_filter(metadata: Dict[str, object]) -> bool:
 
     rust_tracing = FakeRustTracing()
     integration = RustTracingIntegration(
-        "test", rust_tracing.set_layer_impl, span_filter=span_filter
+        "test_record_in_ignored_span",
+        rust_tracing.set_layer_impl,
+        span_filter=span_filter,
     )
     sentry_init(integrations=[integration], traces_sample_rate=1.0)