From f98e5b9286ed50c153581c143d3c8e68622156c3 Mon Sep 17 00:00:00 2001 From: "sentry-junior[bot]" <264270552+sentry-junior[bot]@users.noreply.github.com> Date: Tue, 6 Oct 2026 00:07:51 +0000 Subject: [PATCH 1/2] ref(workflow_engine): Use CacheMapping for release condition caches Co-Authored-By: Kyle Consalus --- .../condition/latest_release_handler.py | 44 ++----- .../handlers/condition/utils/releases.py | 110 +++++++++++------- .../test_latest_adopted_release_handler.py | 27 +++-- .../condition/test_latest_release_handler.py | 18 +-- 4 files changed, 96 insertions(+), 103 deletions(-) diff --git a/src/sentry/workflow_engine/handlers/condition/latest_release_handler.py b/src/sentry/workflow_engine/handlers/condition/latest_release_handler.py index 0b8346285bd1..0f151e734691 100644 --- a/src/sentry/workflow_engine/handlers/condition/latest_release_handler.py +++ b/src/sentry/workflow_engine/handlers/condition/latest_release_handler.py @@ -1,4 +1,4 @@ -from typing import Any, Literal, NamedTuple +from typing import Any, Literal from sentry import tagstore from sentry.models.environment import Environment @@ -8,10 +8,10 @@ from sentry.utils import metrics from sentry.workflow_engine.caches import CacheMapping from sentry.workflow_engine.handlers.condition.utils.releases import ( - get_latest_adopted_release_cache_key as latest_adopted_release_cache_key, -) -from sentry.workflow_engine.handlers.condition.utils.releases import ( - get_latest_release_cache_key as latest_release_cache_key, + LatestAdoptedReleaseCacheKey, + LatestReleaseCacheKey, + latest_adopted_release_cache, + latest_release_cache, ) from sentry.workflow_engine.models.data_condition import Condition from sentry.workflow_engine.preview import UnsupportedPreviewBehavior @@ -22,32 +22,6 @@ WorkflowEventData, ) -CACHE_TTL_SECONDS = 600 - - -class _LatestReleaseCacheKey(NamedTuple): - project_id: int - environment_id: int | None - - -class _LatestAdoptedReleaseCacheKey(NamedTuple): - project_id: int - environment_id: int - - -# Cache mappings for latest release lookups. -# Values are Release objects, or False if no release exists (to cache negative lookups). -_latest_release_cache = CacheMapping[_LatestReleaseCacheKey, Release | Literal[False]]( - lambda key: latest_release_cache_key(key.project_id, key.environment_id), - ttl_seconds=CACHE_TTL_SECONDS, -) -_latest_adopted_release_cache = CacheMapping[ - _LatestAdoptedReleaseCacheKey, Release | Literal[False] -]( - lambda key: latest_adopted_release_cache_key(key.project_id, key.environment_id), - ttl_seconds=CACHE_TTL_SECONDS, -) - def get_latest_adopted_release_for_env( environment: Environment, event: GroupEvent @@ -55,12 +29,12 @@ def get_latest_adopted_release_for_env( """ Get the latest adopted release for a project in an environment. """ - cache_key = _LatestAdoptedReleaseCacheKey(event.group.project_id, environment.id) + cache_key = LatestAdoptedReleaseCacheKey(event.group.project_id, environment.id) return _get_latest_release_for_env_impl( environment, event, only_adopted=True, - mapping=_latest_adopted_release_cache, + mapping=latest_adopted_release_cache, cache_key=cache_key, ) @@ -73,14 +47,14 @@ def get_latest_release_for_env( Get the latest release for a project in an environment. NOTE: This is independent of whether it has been adopted or not. """ - cache_key = _LatestReleaseCacheKey( + cache_key = LatestReleaseCacheKey( event.group.project_id, environment.id if environment else None ) return _get_latest_release_for_env_impl( environment, event, only_adopted=False, - mapping=_latest_release_cache, + mapping=latest_release_cache, cache_key=cache_key, ) diff --git a/src/sentry/workflow_engine/handlers/condition/utils/releases.py b/src/sentry/workflow_engine/handlers/condition/utils/releases.py index 10019fe394b4..c80ed8df884c 100644 --- a/src/sentry/workflow_engine/handlers/condition/utils/releases.py +++ b/src/sentry/workflow_engine/handlers/condition/utils/releases.py @@ -1,5 +1,5 @@ from itertools import product -from typing import Any +from typing import Any, Literal, NamedTuple from django.db.models.signals import post_delete, post_save, pre_delete @@ -9,9 +9,50 @@ from sentry.models.releases.release_project import ReleaseProject from sentry.search.utils import LatestReleaseOrders, get_first_last_release_for_group from sentry.services.eventstore.models import GroupEvent -from sentry.utils.cache import cache +from sentry.workflow_engine.caches import CacheMapping from sentry.workflow_engine.handlers.condition.utils.age import ModelAgeType +CACHE_TTL_SECONDS = 600 + + +class FirstLastReleaseCacheKey(NamedTuple): + group_id: int + release_age_type: str + order_type: LatestReleaseOrders + + +class LatestReleaseCacheKey(NamedTuple): + project_id: int + environment_id: int | None + + +class LatestAdoptedReleaseCacheKey(NamedTuple): + project_id: int + environment_id: int + + +def _latest_release_key(key: LatestReleaseCacheKey) -> str: + if key.environment_id is None: + return f"project:{key.project_id}:latest_release" + return f"project:{key.project_id}:env:{key.environment_id}:latest_release" + + +# Values are Release objects, or False if no release exists (to cache negative lookups). +first_last_release_cache = CacheMapping[FirstLastReleaseCacheKey, Release | Literal[False]]( + lambda key: ( + f"group:{key.group_id}:{key.release_age_type}:{key.order_type.name.lower()}:first_last_release" + ), + ttl_seconds=CACHE_TTL_SECONDS, +) +latest_release_cache = CacheMapping[LatestReleaseCacheKey, Release | Literal[False]]( + _latest_release_key, + ttl_seconds=CACHE_TTL_SECONDS, +) +latest_adopted_release_cache = CacheMapping[LatestAdoptedReleaseCacheKey, Release | Literal[False]]( + lambda key: f"project:{key.project_id}:env:{key.environment_id}:latest_release_adopted", + ttl_seconds=CACHE_TTL_SECONDS, +) + def get_first_last_release_for_event( event: GroupEvent, release_age_type: str, order_type: LatestReleaseOrders @@ -20,21 +61,19 @@ def get_first_last_release_for_event( Fetches the first/last release for the group associated with this group event """ group = event.group - cache_key = get_first_last_release_for_group_cache_key(group.id, release_age_type, order_type) - release = cache.get(cache_key) - if release is None: - try: - release = get_first_last_release_for_group( - group, order_type, release_age_type == ModelAgeType.NEWEST - ) - except Release.DoesNotExist: - release = None - - if release: - cache.set(cache_key, release, 600) - else: - cache.set(cache_key, False, 600) + cache_key = FirstLastReleaseCacheKey(group.id, release_age_type, order_type) + cached = first_last_release_cache.get(cache_key) + if cached is not None: + return cached or None + try: + release = get_first_last_release_for_group( + group, order_type, release_age_type == ModelAgeType.NEWEST + ) + except Release.DoesNotExist: + release = None + + first_last_release_cache.set(cache_key, release or False) return release @@ -57,30 +96,12 @@ def is_newer_release( return release_date > comparison_date -def get_first_last_release_for_group_cache_key( - group_id: int, release_age_type: str, order_type: LatestReleaseOrders -) -> str: - return f"group:{group_id}:{release_age_type}:{order_type.name.lower()}:first_last_release" - - -def get_latest_adopted_release_cache_key(project_id: int, environment_id: int) -> str: - return f"project:{project_id}:env:{environment_id}:latest_release_adopted" - - -def get_latest_release_cache_key(project_id: int, environment_id: int | None = None) -> str: - if environment_id is None: - return f"project:{project_id}:latest_release" - return f"project:{project_id}:env:{environment_id}:latest_release" - - def clear_get_first_last_release_for_group_cache(instance: GroupRelease, **kwargs: Any) -> None: model_ages_types = [ModelAgeType.NEWEST, ModelAgeType.OLDEST] order_types = [val for val in LatestReleaseOrders] - cache.delete_many( + first_last_release_cache.delete_many( [ - get_first_last_release_for_group_cache_key( - instance.group_id, model_age_type, order_type - ) + FirstLastReleaseCacheKey(instance.group_id, model_age_type, order_type) for model_age_type, order_type in product(model_ages_types, order_types) ] ) @@ -95,9 +116,9 @@ def clear_latest_adopted_release_environment_project_cache( # This can happen during deletions as release projects are removed before the release is. return - cache.delete_many( + latest_adopted_release_cache.delete_many( [ - get_latest_adopted_release_cache_key(proj_id, instance.environment_id) + LatestAdoptedReleaseCacheKey(proj_id, instance.environment_id) for proj_id in release_project_ids ] ) @@ -106,7 +127,9 @@ def clear_latest_adopted_release_environment_project_cache( # clear the cache given a Release object def clear_release_cache(instance: Release, **kwargs: Any) -> None: release_project_ids = instance.projects.values_list("id", flat=True) - cache.delete_many([get_latest_release_cache_key(proj_id) for proj_id in release_project_ids]) + latest_release_cache.delete_many( + [LatestReleaseCacheKey(proj_id, None) for proj_id in release_project_ids] + ) def clear_release_environment_project_cache(instance: ReleaseEnvironment, **kwargs: Any) -> None: @@ -116,18 +139,15 @@ def clear_release_environment_project_cache(instance: ReleaseEnvironment, **kwar # This can happen during deletions as release projects are removed before the release is. return - cache.delete_many( - [ - get_latest_release_cache_key(proj_id, instance.environment_id) - for proj_id in release_project_ids - ] + latest_release_cache.delete_many( + [LatestReleaseCacheKey(proj_id, instance.environment_id) for proj_id in release_project_ids] ) # clear the cache given a ReleaseProject object def clear_release_project_cache(instance: ReleaseProject, **kwargs: Any) -> None: proj_id = instance.project_id - cache.delete(get_latest_release_cache_key(proj_id)) + latest_release_cache.delete(LatestReleaseCacheKey(proj_id, None)) post_save.connect(clear_get_first_last_release_for_group_cache, sender=GroupRelease, weak=False) diff --git a/tests/sentry/workflow_engine/handlers/condition/test_latest_adopted_release_handler.py b/tests/sentry/workflow_engine/handlers/condition/test_latest_adopted_release_handler.py index ab8d004eb8e2..2f301e82bce9 100644 --- a/tests/sentry/workflow_engine/handlers/condition/test_latest_adopted_release_handler.py +++ b/tests/sentry/workflow_engine/handlers/condition/test_latest_adopted_release_handler.py @@ -9,11 +9,12 @@ from sentry.models.release import Release from sentry.rules.filters.latest_adopted_release_filter import LatestAdoptedReleaseFilter from sentry.search.utils import LatestReleaseOrders -from sentry.utils.cache import cache from sentry.workflow_engine.handlers.condition.utils.age import AgeComparisonType from sentry.workflow_engine.handlers.condition.utils.releases import ( - get_first_last_release_for_group_cache_key, - get_latest_adopted_release_cache_key, + FirstLastReleaseCacheKey, + LatestAdoptedReleaseCacheKey, + first_last_release_cache, + latest_adopted_release_cache, ) from sentry.workflow_engine.models.data_condition import Condition from sentry.workflow_engine.types import WorkflowEventData @@ -276,33 +277,31 @@ def test_newest_older(self) -> None: self.assert_does_not_pass(self.dc, WorkflowEventData(event=group_event_3, group=group_3)) def test_caching(self) -> None: - cache_key = get_first_last_release_for_group_cache_key( - self.group.id, "oldest", LatestReleaseOrders.SEMVER - ) - assert cache.get(cache_key) is None + cache_key = FirstLastReleaseCacheKey(self.group.id, "oldest", LatestReleaseOrders.SEMVER) + assert first_last_release_cache.get(cache_key) is None self.create_group_release(group=self.group, release=self.newest_release) self.assert_passes(self.dc, self.event_data) - assert cache.get(cache_key) is not None + assert first_last_release_cache.get(cache_key) is not None # ensure we clear the cache after creating a new release oldest_group_release = self.create_group_release( group=self.group, release=self.oldest_release ) - assert cache.get(cache_key) is None + assert first_last_release_cache.get(cache_key) is None self.assert_does_not_pass(self.dc, self.event_data) - assert cache.get(cache_key) is not None + assert first_last_release_cache.get(cache_key) is not None # ensure we clear the cache when a release is deleted oldest_group_release.delete() - assert cache.get(cache_key) is None + assert first_last_release_cache.get(cache_key) is None self.assert_passes(self.dc, self.event_data) def test_release_environment_clears_cache(self) -> None: - cache_key = get_latest_adopted_release_cache_key(self.project.id, self.prod_env.id) - cache.set(cache_key, self.oldest_release, 600) + cache_key = LatestAdoptedReleaseCacheKey(self.project.id, self.prod_env.id) + latest_adopted_release_cache.set(cache_key, self.oldest_release) self.create_release( project=self.project, @@ -311,7 +310,7 @@ def test_release_environment_clears_cache(self) -> None: adopted=self.now, ) - assert cache.get(cache_key) is None + assert latest_adopted_release_cache.get(cache_key) is None @patch("sentry.search.utils.get_first_last_release_for_group", side_effect=Release.DoesNotExist) def test_release_does_not_exist(self, mock_get_first_last_release: MagicMock) -> None: diff --git a/tests/sentry/workflow_engine/handlers/condition/test_latest_release_handler.py b/tests/sentry/workflow_engine/handlers/condition/test_latest_release_handler.py index 2ce45cf9fb78..d96a7ed81d29 100644 --- a/tests/sentry/workflow_engine/handlers/condition/test_latest_release_handler.py +++ b/tests/sentry/workflow_engine/handlers/condition/test_latest_release_handler.py @@ -8,9 +8,9 @@ from sentry.models.release import Release from sentry.rules.filters.latest_release import LatestReleaseFilter from sentry.testutils.skips import requires_snuba -from sentry.utils.cache import cache from sentry.workflow_engine.handlers.condition.utils.releases import ( - get_latest_release_cache_key as get_project_release_cache_key, + LatestReleaseCacheKey, + latest_release_cache, ) from sentry.workflow_engine.models.data_condition import Condition from sentry.workflow_engine.types import WorkflowEventData @@ -109,22 +109,22 @@ def test_caching(self) -> None: new_release.add_project(self.project) # ensure we clear the cache after creating a new release - cache_key = get_project_release_cache_key(self.event.group.project_id) - assert cache.get(cache_key) is None + cache_key = LatestReleaseCacheKey(self.event.group.project_id, None) + assert latest_release_cache.get(cache_key) is None self.assert_does_not_pass(self.dc, self.event_data) # ensure we clear the cache when a release is deleted new_release.safe_delete() - cache_key = get_project_release_cache_key(self.event.group.project_id) - assert cache.get(cache_key) is None + cache_key = LatestReleaseCacheKey(self.event.group.project_id, None) + assert latest_release_cache.get(cache_key) is None # rule should pass again because the latest release is oldRelease self.assert_passes(self.dc, self.event_data) def test_release_environment_clears_cache(self) -> None: - cache_key = get_project_release_cache_key(self.project.id, self.environment.id) - cache.set(cache_key, self.release, 600) + cache_key = LatestReleaseCacheKey(self.project.id, self.environment.id) + latest_release_cache.set(cache_key, self.release) self.create_release( project=self.project, @@ -132,7 +132,7 @@ def test_release_environment_clears_cache(self) -> None: environments=[self.environment], ) - assert cache.get(cache_key) is None + assert latest_release_cache.get(cache_key) is None def test_latest_release_with_environment(self) -> None: self.create_release( From 5dfb417b00b60c89629f718309f62f7408f3b425 Mon Sep 17 00:00:00 2001 From: "sentry-junior[bot]" <264270552+sentry-junior[bot]@users.noreply.github.com> Date: Tue, 6 Oct 2026 20:52:27 +0000 Subject: [PATCH 2/2] ref(workflow_engine): Type release_age_type as ModelAgeType --- .../workflow_engine/handlers/condition/utils/releases.py | 4 ++-- .../condition/test_latest_adopted_release_handler.py | 6 ++++-- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/src/sentry/workflow_engine/handlers/condition/utils/releases.py b/src/sentry/workflow_engine/handlers/condition/utils/releases.py index c80ed8df884c..5ed324ee4142 100644 --- a/src/sentry/workflow_engine/handlers/condition/utils/releases.py +++ b/src/sentry/workflow_engine/handlers/condition/utils/releases.py @@ -17,7 +17,7 @@ class FirstLastReleaseCacheKey(NamedTuple): group_id: int - release_age_type: str + release_age_type: ModelAgeType order_type: LatestReleaseOrders @@ -55,7 +55,7 @@ def _latest_release_key(key: LatestReleaseCacheKey) -> str: def get_first_last_release_for_event( - event: GroupEvent, release_age_type: str, order_type: LatestReleaseOrders + event: GroupEvent, release_age_type: ModelAgeType, order_type: LatestReleaseOrders ) -> Release | None: """ Fetches the first/last release for the group associated with this group event diff --git a/tests/sentry/workflow_engine/handlers/condition/test_latest_adopted_release_handler.py b/tests/sentry/workflow_engine/handlers/condition/test_latest_adopted_release_handler.py index 2f301e82bce9..5e0c82fbbdcf 100644 --- a/tests/sentry/workflow_engine/handlers/condition/test_latest_adopted_release_handler.py +++ b/tests/sentry/workflow_engine/handlers/condition/test_latest_adopted_release_handler.py @@ -9,7 +9,7 @@ from sentry.models.release import Release from sentry.rules.filters.latest_adopted_release_filter import LatestAdoptedReleaseFilter from sentry.search.utils import LatestReleaseOrders -from sentry.workflow_engine.handlers.condition.utils.age import AgeComparisonType +from sentry.workflow_engine.handlers.condition.utils.age import AgeComparisonType, ModelAgeType from sentry.workflow_engine.handlers.condition.utils.releases import ( FirstLastReleaseCacheKey, LatestAdoptedReleaseCacheKey, @@ -277,7 +277,9 @@ def test_newest_older(self) -> None: self.assert_does_not_pass(self.dc, WorkflowEventData(event=group_event_3, group=group_3)) def test_caching(self) -> None: - cache_key = FirstLastReleaseCacheKey(self.group.id, "oldest", LatestReleaseOrders.SEMVER) + cache_key = FirstLastReleaseCacheKey( + self.group.id, ModelAgeType.OLDEST, LatestReleaseOrders.SEMVER + ) assert first_last_release_cache.get(cache_key) is None self.create_group_release(group=self.group, release=self.newest_release)