chore(metrics): remove usages of span metric models

src/sentry/sentry_metrics/querying/visitors/query_expression.py

@@ -7,7 +7,6 @@
 
 from sentry.models.environment import Environment
 from sentry.models.project import Project
-from sentry.sentry_metrics.models import SpanAttributeExtractionRuleCondition
 from sentry.sentry_metrics.querying.constants import COEFFICIENT_OPERATORS
 from sentry.sentry_metrics.querying.data.mapping.base import (
     Mapper,
@@ -426,12 +425,6 @@ def _extract_unit(self, timeseries: Timeseries) -> str | None:
             if parsed_mri.entity == "c":
                 return None
 
-            if rule_id := parsed_mri.span_attribute_rule_id:
-                try:
-                    return SpanAttributeExtractionRuleCondition.objects.get(id=rule_id).config.unit
-                except SpanAttributeExtractionRuleCondition.DoesNotExist:
-                    return None
-
             return parsed_mri.unit
 
         return None

src/sentry/snuba/metrics/naming_layer/mri.py

@@ -38,12 +38,9 @@
 from enum import Enum
 from typing import cast
 
-import sentry_sdk
 from sentry_kafka_schemas.codecs import ValidationError
 
 from sentry.exceptions import InvalidParams
-from sentry.sentry_metrics.extraction_rules import SPAN_ATTRIBUTE_PREFIX
-from sentry.sentry_metrics.models import SpanAttributeExtractionRuleCondition
 from sentry.sentry_metrics.use_case_id_registry import UseCaseID
 from sentry.snuba.dataset import EntityKey
 from sentry.snuba.metrics.units import format_value_using_unit_and_op
@@ -210,15 +207,6 @@ class ParsedMRI:
     def mri_string(self) -> str:
         return f"{self.entity}:{self.namespace}/{self.name}@{self.unit}"
 
-    @property
-    def span_attribute_rule_id(self):
-        if self.name.startswith(SPAN_ATTRIBUTE_PREFIX):
-            try:
-                return int(self.name[len(SPAN_ATTRIBUTE_PREFIX) :])
-            except ValueError:
-                return None
-        return None
-
 
 @dataclass
 class ParsedMRIField:
@@ -264,24 +252,6 @@ def format_mri_field(field: str) -> str:
         parsed = parse_mri_field(field)
 
         if parsed:
-            if condition_id := parsed.mri.span_attribute_rule_id:
-                try:
-                    condition = SpanAttributeExtractionRuleCondition.objects.get(id=condition_id)
-                    config = condition.config
-                    if condition.value:
-                        filter_str = f' filtered by "{condition.value}"'
-                    else:
-                        filter_str = ""
-
-                    return f"{parsed.op}({config.span_attribute}){filter_str}"
-                except SpanAttributeExtractionRuleCondition.DoesNotExist:
-                    with sentry_sdk.new_scope() as scope:
-                        scope.set_tag("field", field)
-                        sentry_sdk.capture_message(
-                            "Trying to format MRI field for non-existent span metric."
-                        )
-                    return field
-
             return str(parsed)
 
         else:
@@ -304,22 +274,9 @@ def format_mri_field_value(field: str, value: str) -> str:
         if parsed_mri_field is None:
             return value
 
-        if condition_id := parsed_mri_field.mri.span_attribute_rule_id:
-            try:
-                condition = SpanAttributeExtractionRuleCondition.objects.get(id=condition_id)
-                unit = cast(MetricUnit, condition.config.unit)
-            except SpanAttributeExtractionRuleCondition.DoesNotExist:
-                with sentry_sdk.new_scope() as scope:
-                    scope.set_tag("field", field)
-                    sentry_sdk.capture_message(
-                        "Trying to format MRI field for non-existent span metric."
-                    )
-                return value
-
-        else:
-            unit = cast(MetricUnit, parsed_mri_field.mri.unit)
-
+        unit = cast(MetricUnit, parsed_mri_field.mri.unit)
         return format_value_using_unit_and_op(float(value), unit, parsed_mri_field.op)
+
     except InvalidParams:
         return value
 

src/sentry/testutils/factories.py

@@ -144,7 +144,6 @@
 )
 from sentry.sentry_apps.services.app.serial import serialize_sentry_app_installation
 from sentry.sentry_apps.services.hook import hook_service
-from sentry.sentry_metrics.models import SpanAttributeExtractionRuleConfig
 from sentry.signals import project_created
 from sentry.silo.base import SiloMode
 from sentry.snuba.dataset import Dataset
@@ -1219,13 +1218,6 @@ def create_sentry_app_installation_for_provider(
             sentry_app_installation=installation,
         )
 
-    @staticmethod
-    @assume_test_silo_mode(SiloMode.REGION)
-    def create_span_attribute_extraction_config(
-        dictionary: dict[str, Any], user_id: int, project: Project
-    ) -> SpanAttributeExtractionRuleConfig:
-        return SpanAttributeExtractionRuleConfig.from_dict(dictionary, user_id, project)
-
     @staticmethod
     @assume_test_silo_mode(SiloMode.CONTROL)
     def create_stacktrace_link_schema():

src/sentry/testutils/fixtures.py

@@ -346,9 +346,6 @@ def create_sentry_app_installation(self, *args, **kwargs):
     def create_sentry_app_installation_for_provider(self, *args, **kwargs):
         return Factories.create_sentry_app_installation_for_provider(*args, **kwargs)
 
-    def create_span_attribute_extraction_config(self, *args, **kwargs):
-        return Factories.create_span_attribute_extraction_config(*args, **kwargs)
-
     def create_stacktrace_link_schema(self, *args, **kwargs):
         return Factories.create_stacktrace_link_schema(*args, **kwargs)
 

tests/sentry/sentry_metrics/querying/data/test_api.py

@@ -29,7 +29,6 @@
 from sentry.snuba.metrics.naming_layer import TransactionMRI
 from sentry.testutils.cases import BaseMetricsTestCase, TestCase
 from sentry.testutils.helpers.datetime import freeze_time
-from sentry.testutils.pytest.fixtures import django_db_all
 
 pytestmark = pytest.mark.sentry_metrics
 
@@ -1411,140 +1410,6 @@ def test_query_with_basic_formula_and_coercible_units(self):
             assert meta[0][1]["unit"] == "nanosecond"
             assert meta[0][1]["scaling_factor"] is None
 
-    @django_db_all(reset_sequences=True)
-    def test_span_metrics_with_coercible_units(self):
-
-        configs = [
-            {
-                "spanAttribute": "my_duration_nano",
-                "aggregates": ["count", "p50", "p75", "p95", "p99"],
-                "unit": "nanosecond",
-                "tags": [],
-                "conditions": [
-                    {"value": ""},
-                ],
-            },
-            {
-                "spanAttribute": "my_duration_micro",
-                "aggregates": ["count", "p50", "p75", "p95", "p99"],
-                "unit": "microsecond",
-                "tags": [],
-                "conditions": [
-                    {"value": ""},
-                ],
-            },
-        ]
-        objects = []
-        for config in configs:
-            o = self.create_span_attribute_extraction_config(
-                dictionary=config, user_id=self.user.id, project=self.project
-            )
-            objects.append(o)
-
-        mri_1 = f"d:custom/span_attribute_{objects[0].conditions.all().get().id}@none"
-        mri_2 = f"d:custom/span_attribute_{objects[1].conditions.all().get().id}@none"
-        for mri, value in ((mri_1, 20), (mri_1, 10), (mri_2, 15), (mri_2, 5)):
-            self.store_metric(
-                self.project.organization.id,
-                self.project.id,
-                mri,
-                {},
-                self.ts(self.now()),
-                value,
-            )
-
-        for formula, expected_result, expected_unit_family in (
-            # (($query_2 * 1000) + 10000.0)
-            ("($query_2 + 10)", 30000.0, UnitFamily.DURATION.value),
-            # (($query_2 * 1000) + (10 * 2) * 1000)
-            ("($query_2 + (10 * 2))", 40000.0, UnitFamily.DURATION.value),
-            # (10000.0 + ($query_2 * 1000))
-            ("(10 + $query_2)", 30000.0, UnitFamily.DURATION.value),
-            # (($query_2 + 1000) + (10000.0 + 20000.0))
-            ("($query_2 + (10 + 20))", 50000.0, UnitFamily.DURATION.value),
-            # ((10000.0 + 20000.0) + ($query_2 + 1000))
-            ("((10 + 20) + $query_2)", 50000.0, UnitFamily.DURATION.value),
-            # ($query_2 * 1000 + 10000.0) + ($query_2 * 1000)
-            ("($query_2 + 10) + $query_2", 50000.0, UnitFamily.DURATION.value),
-            # ($query_2 * 1000 + 10000.0) + $query_1
-            ("($query_2 + 10) + $query_1", 30015.0, UnitFamily.DURATION.value),
-            # ($query_1 + 10) + ($query_2 * 1000)
-            ("($query_1 + 10) + $query_2", 20025.0, UnitFamily.DURATION.value),
-        ):
-            query_1 = self.mql("avg", mri_1)
-            query_2 = self.mql("sum", mri_2)
-
-            results = self.run_query(
-                mql_queries=[
-                    MQLQuery(formula, query_1=MQLQuery(query_1), query_2=MQLQuery(query_2))
-                ],
-                start=self.now() - timedelta(minutes=30),
-                end=self.now() + timedelta(hours=1, minutes=30),
-                interval=3600,
-                organization=self.project.organization,
-                projects=[self.project],
-                environments=[],
-                referrer="metrics.data.api",
-            )
-            data = results["data"]
-            assert len(data) == 1
-            assert data[0][0]["by"] == {}
-            assert data[0][0]["series"] == [None, expected_result, None]
-            assert data[0][0]["totals"] == expected_result
-            meta = results["meta"]
-            assert len(meta) == 1
-            assert meta[0][1]["unit_family"] == expected_unit_family
-            assert meta[0][1]["unit"] == "nanosecond"
-            assert meta[0][1]["scaling_factor"] is None
-
-    @django_db_all(reset_sequences=True)
-    def test_span_metrics_count_span_duration(self):
-        config = {
-            "spanAttribute": "span.duration",
-            "aggregates": ["count"],
-            "unit": "millisecond",
-            "tags": [],
-            "conditions": [
-                {"value": ""},
-            ],
-        }
-
-        o = self.create_span_attribute_extraction_config(
-            dictionary=config, user_id=self.user.id, project=self.project
-        )
-
-        mri_1 = f"c:custom/span_attribute_{o.conditions.all().get().id}@none"
-        for mri, value in ((mri_1, 1), (mri_1, 1)):
-            self.store_metric(
-                self.project.organization.id,
-                self.project.id,
-                mri,
-                {},
-                self.ts(self.now()),
-                value,
-            )
-
-        query_1 = self.mql("sum", mri_1)
-
-        results = self.run_query(
-            mql_queries=[MQLQuery(query_1)],
-            start=self.now() - timedelta(minutes=30),
-            end=self.now() + timedelta(hours=1, minutes=30),
-            interval=3600,
-            organization=self.project.organization,
-            projects=[self.project],
-            environments=[],
-            referrer="metrics.data.api",
-        )
-        data = results["data"]
-        assert len(data) == 1
-        assert data[0][0]["by"] == {}
-        assert data[0][0]["series"] == [None, 2.0, None]
-        meta = results["meta"]
-        assert len(meta) == 1
-        assert meta[0][1]["unit"] is None
-        assert meta[0][1]["scaling_factor"] is None
-
     def test_query_with_basic_formula_and_non_coercible_units(self):
         mri_1 = "d:custom/page_load@nanosecond"
         mri_2 = "d:custom/page_size@byte"

tests/snuba/metrics/naming_layer/test_mri.py

@@ -27,89 +27,3 @@ def test_format_mri_field_value(self):
         assert format_mri_field_value("sum(d:spans/exclusive_time@millisecond)", "1000") == "1 s"
         assert format_mri_field_value("invalid_mri_field", "100") == "100"
         assert format_mri_field_value(cast(str, None), "100") == "100"
-
-    def test_span_metric_mri_field(self):
-        config = {
-            "spanAttribute": "browser.name",
-            "aggregates": ["count_unique"],
-            "unit": "none",
-            "tags": [],
-            "conditions": [
-                {"value": "browser.name:Chrome or browser.name:Firefox"},
-            ],
-        }
-        project = self.create_project(organization=self.organization, name="my new project")
-        config_object = self.create_span_attribute_extraction_config(
-            dictionary=config, user_id=self.user.id, project=project
-        )
-        condition_id = config_object.conditions.get().id
-        assert (
-            format_mri_field(f"count_unique(c:custom/span_attribute_{condition_id}@none)")
-            == 'count_unique(browser.name) filtered by "browser.name:Chrome or browser.name:Firefox"'
-        )
-
-    def test_span_metric_mri_field_empty_condition(self):
-        config = {
-            "spanAttribute": "browser.name",
-            "aggregates": ["count_unique"],
-            "unit": "none",
-            "tags": [],
-            "conditions": [
-                {"value": ""},
-            ],
-        }
-        project = self.create_project(organization=self.organization, name="my new project")
-        config_object = self.create_span_attribute_extraction_config(
-            dictionary=config, user_id=self.user.id, project=project
-        )
-        condition_id = config_object.conditions.get().id
-        assert (
-            format_mri_field(f"count_unique(c:custom/span_attribute_{condition_id}@none)")
-            == "count_unique(browser.name)"
-        )
-
-    def test_span_metric_mri_field_value(self):
-        config = {
-            "spanAttribute": "my_duration",
-            "aggregates": ["avg", "min", "max", "sum"],
-            "unit": "millisecond",
-            "tags": [],
-            "conditions": [
-                {"value": "browser.name:Chrome or browser.name:Firefox"},
-            ],
-        }
-        project = self.create_project(organization=self.organization, name="my new project")
-        config_object = self.create_span_attribute_extraction_config(
-            dictionary=config, user_id=self.user.id, project=project
-        )
-        condition_id = config_object.conditions.get().id
-        assert (
-            format_mri_field_value(f"avg(c:custom/span_attribute_{condition_id}@none)", "1000")
-            == "1 s"
-        )
-
-    def test_span_metric_does_not_exist(self):
-        config = {
-            "spanAttribute": "my_duration",
-            "aggregates": ["avg", "min", "max", "sum"],
-            "unit": "millisecond",
-            "tags": [],
-            "conditions": [
-                {"value": "browser.name:Chrome or browser.name:Firefox"},
-            ],
-        }
-        project = self.create_project(organization=self.organization, name="my new project")
-        self.create_span_attribute_extraction_config(
-            dictionary=config, user_id=self.user.id, project=project
-        )
-        non_existent_id = 65537
-
-        assert (
-            format_mri_field_value(f"avg(c:custom/span_attribute_{non_existent_id}@none)", "1000")
-            == "1000"
-        )
-
-        assert (
-            format_mri_field(f"avg(c:custom/span_attribute_{non_existent_id}@none)")
-            == f"avg(c:custom/span_attribute_{non_existent_id}@none)"
-        )