ref(flags): Remove organizations:minute-resolution-sessions feature flag

wedamija · claude · wedamija · commit e77edb2ea3e6 · 2026-04-10T15:21:05.000-07:00
This feature flag had `default=True` and was always on for all users.
Remove the flag registration, all frontend feature checks, and clean up
backend tests that unnecessarily wrapped with this feature.

The `getSessionsInterval` utility now always uses high-fidelity
(sub-hour) resolution for recent data, which was the existing behavior
for all users.

Co-Authored-By: Claude Opus 4.6 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/src/sentry/features/temporary.py b/src/sentry/features/temporary.py
@@ -175,8 +175,6 @@ def register_temporary_features(manager: FeatureManager) -> None:
     manager.add("organizations:mep-use-default-tags", OrganizationFeature, FeatureHandlerStrategy.FLAGPOLE, api_expose=False)
     # Enable flamegraph visualization for MetricKit hang diagnostic stack traces
     manager.add("organizations:metrickit-flamegraph", OrganizationFeature, FeatureHandlerStrategy.FLAGPOLE, api_expose=True)
-    # Enable Session Stats down to a minute resolution
-    manager.add("organizations:minute-resolution-sessions", OrganizationFeature, FeatureHandlerStrategy.INTERNAL, default=True, api_expose=True)
     # Enables higher limit for alert rules
     manager.add("organizations:more-fast-alerts", OrganizationFeature, FeatureHandlerStrategy.FLAGPOLE, api_expose=False)
     manager.add("organizations:more-slow-alerts", OrganizationFeature, FeatureHandlerStrategy.FLAGPOLE, api_expose=False)
diff --git a/static/app/components/charts/sessionsRequest.tsx b/static/app/components/charts/sessionsRequest.tsx
@@ -82,7 +82,6 @@ export class SessionsRequest extends Component<Props, State> {
       query,
       groupBy,
       interval,
-      organization,
     } = this.props;
 
     return {
@@ -96,10 +95,7 @@ export class SessionsRequest extends Component<Props, State> {
       end,
       interval: interval
         ? interval
-        : getSessionsInterval(
-            {start, end, period: statsPeriod},
-            {highFidelity: organization.features.includes('minute-resolution-sessions')}
-          ),
+        : getSessionsInterval({start, end, period: statsPeriod}),
     };
   }
 
diff --git a/static/app/components/charts/useSessionsRequest.tsx b/static/app/components/charts/useSessionsRequest.tsx
@@ -45,10 +45,7 @@ export function useSessionsRequest({
     end,
     interval: interval
       ? interval
-      : getSessionsInterval(
-          {start, end, period: statsPeriod},
-          {highFidelity: organization.features.includes('minute-resolution-sessions')}
-        ),
+      : getSessionsInterval({start, end, period: statsPeriod}),
   };
 
   const sessionQuery = useApiQuery<SessionApiResponse>(
diff --git a/static/app/utils/sessions.spec.tsx b/static/app/utils/sessions.spec.tsx
@@ -192,80 +192,52 @@ describe('utils/sessions', () => {
   });
 
   describe('getSessionsInterval', () => {
-    describe('with high fidelity', () => {
-      it('>= 60 days', () => {
-        expect(getSessionsInterval({period: '60d'}, {highFidelity: true})).toBe('1d');
-      });
-
-      it('>= 30 days', () => {
-        expect(getSessionsInterval({period: '30d'}, {highFidelity: true})).toBe('4h');
-      });
-
-      it('14 days', () => {
-        expect(getSessionsInterval({period: '14d'}, {highFidelity: true})).toBe('1h');
-      });
-
-      it('>= 6 hours', () => {
-        expect(getSessionsInterval({period: '6h'}, {highFidelity: true})).toBe('1h');
-      });
-
-      it('between 6 hours and 30 minutes', () => {
-        expect(getSessionsInterval({period: '31m'}, {highFidelity: true})).toBe('5m');
-      });
-
-      it('less or equal to 30 minutes', () => {
-        expect(getSessionsInterval({period: '30m'}, {highFidelity: true})).toBe('1m');
-      });
-
-      it('less or equal to 10 minutes', () => {
-        expect(
-          getSessionsInterval(
-            {start: '2021-10-08T12:00:00Z', end: '2021-10-08T12:05:00.000Z'},
-            {highFidelity: true}
-          )
-        ).toBe('10s');
-      });
+    it('>= 60 days', () => {
+      expect(getSessionsInterval({period: '60d'})).toBe('1d');
+      expect(
+        getSessionsInterval({
+          start: '2021-07-19T15:14:23Z',
+          end: '2021-10-19T15:14:23Z',
+        })
+      ).toBe('1d');
+    });
 
-      it('ignores high fidelity flag if start is older than 30d', () => {
-        expect(
-          getSessionsInterval(
-            {start: '2017-09-15T02:41:20Z', end: '2017-09-15T02:42:20Z'},
-            {highFidelity: true}
-          )
-        ).toBe('1h');
-      });
+    it('>= 30 days', () => {
+      expect(getSessionsInterval({period: '30d'})).toBe('4h');
     });
 
-    describe('with low fidelity', () => {
-      it('>= 60 days', () => {
-        expect(getSessionsInterval({period: '60d'})).toBe('1d');
-        expect(
-          getSessionsInterval(
-            {start: '2021-07-19T15:14:23Z', end: '2021-10-19T15:14:23Z'},
-            {highFidelity: true}
-          )
-        ).toBe('1d');
-      });
+    it('14 days', () => {
+      expect(getSessionsInterval({period: '14d'})).toBe('1h');
+    });
 
-      it('>= 30 days', () => {
-        expect(getSessionsInterval({period: '30d'})).toBe('4h');
-      });
+    it('>= 6 hours', () => {
+      expect(getSessionsInterval({period: '6h'})).toBe('1h');
+    });
 
-      it('14 days', () => {
-        expect(getSessionsInterval({period: '14d'})).toBe('1h');
-      });
+    it('between 6 hours and 30 minutes', () => {
+      expect(getSessionsInterval({period: '31m'})).toBe('5m');
+    });
 
-      it('>= 6 hours', () => {
-        expect(getSessionsInterval({period: '6h'})).toBe('1h');
-      });
+    it('less or equal to 30 minutes', () => {
+      expect(getSessionsInterval({period: '30m'})).toBe('1m');
+    });
 
-      it('between 6 hours and 30 minutes', () => {
-        expect(getSessionsInterval({period: '31m'})).toBe('1h');
-      });
+    it('less or equal to 10 minutes', () => {
+      expect(
+        getSessionsInterval({
+          start: '2021-10-08T12:00:00Z',
+          end: '2021-10-08T12:05:00.000Z',
+        })
+      ).toBe('10s');
+    });
 
-      it('less or equal to 30 minutes', () => {
-        expect(getSessionsInterval({period: '30m'})).toBe('1h');
-      });
+    it('falls back to 1h if start is older than 30d', () => {
+      expect(
+        getSessionsInterval({
+          start: '2017-09-15T02:41:20Z',
+          end: '2017-09-15T02:42:20Z',
+        })
+      ).toBe('1h');
     });
   });
 
diff --git a/static/app/utils/sessions.tsx b/static/app/utils/sessions.tsx
@@ -257,20 +257,14 @@ export function initSessionsChart(theme: Theme) {
 
 type GetSessionsIntervalOptions = {
   dailyInterval?: boolean;
-  highFidelity?: boolean;
 };
 
 export function getSessionsInterval(
   datetimeObj: DateTimeObject,
-  {highFidelity, dailyInterval}: GetSessionsIntervalOptions = {}
+  {dailyInterval}: GetSessionsIntervalOptions = {}
 ) {
   const diffInMinutes = getDiffInMinutes(datetimeObj);
 
-  if (moment(datetimeObj.start).isSameOrBefore(moment().subtract(30, 'days'))) {
-    // we cannot use sub-hour session resolution on buckets older than 30 days
-    highFidelity = false;
-  }
-
   if (dailyInterval === true && diffInMinutes > TWENTY_FOUR_HOURS) {
     return '1d';
   }
@@ -287,22 +281,23 @@ export function getSessionsInterval(
     return '1h';
   }
 
-  // limit on backend for sub-hour session resolution is set to six hours
-  if (highFidelity) {
-    if (diffInMinutes <= MINUTES_THRESHOLD_TO_DISPLAY_SECONDS) {
-      // This only works for metrics-based session stats.
-      // Backend will silently replace with '1m' for session-based stats.
-      return '10s';
-    }
+  // we cannot use sub-hour session resolution on buckets older than 30 days
+  if (moment(datetimeObj.start).isSameOrBefore(moment().subtract(30, 'days'))) {
+    return '1h';
+  }
 
-    if (diffInMinutes <= 30) {
-      return '1m';
-    }
+  // limit on backend for sub-hour session resolution is set to six hours
+  if (diffInMinutes <= MINUTES_THRESHOLD_TO_DISPLAY_SECONDS) {
+    // This only works for metrics-based session stats.
+    // Backend will silently replace with '1m' for session-based stats.
+    return '10s';
+  }
 
-    return '5m';
+  if (diffInMinutes <= 30) {
+    return '1m';
   }
 
-  return '1h';
+  return '5m';
 }
 
 // Sessions API can only round intervals to the closest hour - this is especially problematic when using sub-hour resolution.
diff --git a/static/app/views/projectDetail/charts/projectSessionsAnrRequest.tsx b/static/app/views/projectDetail/charts/projectSessionsAnrRequest.tsx
@@ -54,7 +54,6 @@ export function ProjectSessionsAnrRequest({
     const baseParams = {
       field: [yAxis, 'count_unique(user)'],
       interval: getSessionsInterval(datetime, {
-        highFidelity: organization.features.includes('minute-resolution-sessions'),
         dailyInterval: true,
       }),
       project: projects[0],
diff --git a/static/app/views/projectDetail/charts/projectSessionsChartRequest.tsx b/static/app/views/projectDetail/charts/projectSessionsChartRequest.tsx
@@ -200,15 +200,13 @@ class ProjectSessionsChartRequest extends Component<
   }
 
   queryParams({shouldFetchWithPrevious = false}): Record<string, any> {
-    const {selection, query, organization} = this.props;
+    const {selection, query} = this.props;
     const {datetime, projects, environments: environment} = selection;
 
     const baseParams = {
       field: this.field,
       groupBy: this.isCrashFreeRate ? undefined : 'session.status',
-      interval: getSessionsInterval(datetime, {
-        highFidelity: organization.features.includes('minute-resolution-sessions'),
-      }),
+      interval: getSessionsInterval(datetime),
       project: projects[0],
       environment,
       query,
diff --git a/static/app/views/releases/list/releasesAdoptionChart.tsx b/static/app/views/releases/list/releasesAdoptionChart.tsx
@@ -75,20 +75,16 @@ export function ReleasesAdoptionChart({
 
     const diffInMinutes = getDiffInMinutes(datetimeObj);
 
-    // use high fidelity intervals when available
-    // limit on backend is set to six hour
-    if (
-      organization.features.includes('minute-resolution-sessions') &&
-      diffInMinutes < 360
-    ) {
+    // limit on backend is set to six hours
+    if (diffInMinutes < 360) {
       return '10m';
     }
 
     if (diffInMinutes >= ONE_WEEK) {
       return '1d';
     }
     return '1h';
-  }, [organization, location]);
+  }, [location]);
 
   const getReleasesSeries = (response: SessionApiResponse | null) => {
     // If there are many releases, display releases with the highest number of sessions
diff --git a/tests/sentry/api/serializers/test_organization.py b/tests/sentry/api/serializers/test_organization.py
@@ -89,7 +89,6 @@ def test_simple(self) -> None:
             "integrations-ticket-rules",
             "integrations-vercel",
             "invite-members",
-            "minute-resolution-sessions",
             "open-membership",
             "relay",
             "session-replay-ui",
diff --git a/tests/snuba/api/endpoints/test_organization_sessions.py b/tests/snuba/api/endpoints/test_organization_sessions.py
@@ -307,61 +307,55 @@ def test_no_projects(self) -> None:
 
     @freeze_time(MOCK_DATETIME_PLUS_TEN_MINUTES)
     def test_minute_resolution(self) -> None:
-        with self.feature("organizations:minute-resolution-sessions"):
-            response = self.do_request(
-                {
-                    "project": [self.project1.id, self.project2.id],
-                    "statsPeriod": "30m",
-                    "interval": "10m",
-                    "field": ["sum(session)"],
-                }
-            )
-            assert response.status_code == 200, response.content
+        response = self.do_request(
+            {
+                "project": [self.project1.id, self.project2.id],
+                "statsPeriod": "30m",
+                "interval": "10m",
+                "field": ["sum(session)"],
+            }
+        )
+        assert response.status_code == 200, response.content
 
-            ten_min = 10 * 60
-            expected_start = adjust_start(
-                MOCK_DATETIME.replace(hour=12, minute=0, second=0), ten_min
-            )
-            expected_end = adjust_end(MOCK_DATETIME.replace(hour=12, minute=38, second=0), ten_min)
-
-            assert result_sorted(response.data) == {
-                "start": expected_start.strftime(SNUBA_TIME_FORMAT),
-                "end": expected_end.strftime(SNUBA_TIME_FORMAT),
-                "query": "",
-                "intervals": [
-                    *[
-                        MOCK_DATETIME.replace(hour=12, minute=min, second=0).strftime(
-                            SNUBA_TIME_FORMAT
-                        )
-                        for min in [0, 10, 20, 30]
-                    ],
-                ],
-                "groups": [
-                    {
-                        "by": {},
-                        "series": {"sum(session)": [2, 1, 1, 0]},
-                        "totals": {"sum(session)": 4},
-                    }
+        ten_min = 10 * 60
+        expected_start = adjust_start(MOCK_DATETIME.replace(hour=12, minute=0, second=0), ten_min)
+        expected_end = adjust_end(MOCK_DATETIME.replace(hour=12, minute=38, second=0), ten_min)
+
+        assert result_sorted(response.data) == {
+            "start": expected_start.strftime(SNUBA_TIME_FORMAT),
+            "end": expected_end.strftime(SNUBA_TIME_FORMAT),
+            "query": "",
+            "intervals": [
+                *[
+                    MOCK_DATETIME.replace(hour=12, minute=min, second=0).strftime(SNUBA_TIME_FORMAT)
+                    for min in [0, 10, 20, 30]
                 ],
-            }
+            ],
+            "groups": [
+                {
+                    "by": {},
+                    "series": {"sum(session)": [2, 1, 1, 0]},
+                    "totals": {"sum(session)": 4},
+                }
+            ],
+        }
 
     @freeze_time(MOCK_DATETIME_PLUS_TEN_MINUTES)
     def test_10s_resolution(self) -> None:
-        with self.feature("organizations:minute-resolution-sessions"):
-            response = self.do_request(
-                {
-                    "project": [self.project1.id],
-                    "statsPeriod": "1m",
-                    "interval": "10s",
-                    "field": ["sum(session)"],
-                }
-            )
-            assert response.status_code == 200, response.content
+        response = self.do_request(
+            {
+                "project": [self.project1.id],
+                "statsPeriod": "1m",
+                "interval": "10s",
+                "field": ["sum(session)"],
+            }
+        )
+        assert response.status_code == 200, response.content
 
-            # With the metrics backend, we should get exactly what we asked for,
-            # 6 intervals with 10 second length. However, since we add both the
-            # starting and ending interval we get 7 intervals.
-            assert len(response.data["intervals"]) == 7
+        # With the metrics backend, we should get exactly what we asked for,
+        # 6 intervals with 10 second length. However, since we add both the
+        # starting and ending interval we get 7 intervals.
+        assert len(response.data["intervals"]) == 7
 
     @freeze_time(MOCK_DATETIME)
     def test_filter_projects(self) -> None:
