Merge branch 'master' into natemoo-re/anomaly-detection-charts

Author: natemoo-re

migrations_lockfile.txt

@@ -12,5 +12,5 @@ remote_subscriptions: 0003_drop_remote_subscription
 replays: 0004_index_together
 sentry: 0773_make_group_score_nullable
 social_auth: 0002_default_auto_field
-uptime: 0016_translate_uptime_object_headers_to_lists
+uptime: 0017_unique_on_timeout
 workflow_engine: 0009_detector_type

package.json

@@ -156,7 +156,7 @@
     "react-lazyload": "^3.2.1",
     "react-mentions": "4.4.10",
     "react-popper": "^2.3.0",
-    "react-router-dom": "^6.23.0",
+    "react-router-dom": "^6.26.2",
     "react-select": "4.3.1",
     "react-sparklines": "1.7.0",
     "react-virtualized": "^9.22.5",
@@ -265,7 +265,9 @@
       "last 3 iOS major versions",
       "Firefox ESR"
     ],
-    "test": ["current node"]
+    "test": [
+      "current node"
+    ]
   },
   "volta": {
     "extends": ".volta.json"

src/sentry/integrations/github/tasks/pr_comment.py

@@ -224,9 +224,9 @@ def github_comment_workflow(pullrequest_id: int, project_id: int):
             {
                 "name": f"Root cause #{i + 1}",
                 "type": "copilot-chat",
-                "prompt": f"@sentry root cause issue {str(issue_id)} with PR URL https://github.com/{repo.name}/pull/{str(pullrequest_id)}",
+                "prompt": f"@sentry root cause issue {str(issue_id)} with PR URL https://github.com/{repo.name}/pull/{str(pr_key)}",
             }
-            for i, issue_id in enumerate(top_24_issues)
+            for i, issue_id in enumerate(top_24_issues[:3])
         ]
         if enabled_copilot
         else None

src/sentry/mediators/alert_rule_actions/creator.py

@@ -2,20 +2,20 @@
 from django.utils.functional import cached_property
 
 from sentry.coreapi import APIError
-from sentry.mediators.external_requests.alert_rule_action_requester import (
+from sentry.mediators.mediator import Mediator
+from sentry.mediators.param import Param
+from sentry.sentry_apps.external_requests.alert_rule_action_requester import (
     AlertRuleActionRequester,
     AlertRuleActionResult,
 )
-from sentry.mediators.mediator import Mediator
-from sentry.mediators.param import Param
 from sentry.sentry_apps.models.sentry_app_component import SentryAppComponent
 from sentry.sentry_apps.models.sentry_app_installation import SentryAppInstallation
 
 
 class AlertRuleActionCreator(Mediator):
     using = router.db_for_write(SentryAppComponent)
     install = Param(SentryAppInstallation)
-    fields = Param(object, default=[])  # array of dicts
+    fields = Param(list, default=[])  # array of dicts
 
     def call(self) -> AlertRuleActionResult:
         uri = self._fetch_sentry_app_uri()
@@ -32,12 +32,11 @@ def _fetch_sentry_app_uri(self):
     def _make_external_request(self, uri=None):
         if uri is None:
             raise APIError("Sentry App request url not found")
-
-        self.response = AlertRuleActionRequester.run(
+        self.response = AlertRuleActionRequester(
             install=self.install,
             uri=uri,
             fields=self.fields,
-        )
+        ).run()
 
     @cached_property
     def sentry_app(self):

src/sentry/mediators/external_requests/__init__.py

@@ -1,3 +1,2 @@
-from .alert_rule_action_requester import AlertRuleActionRequester  # NOQA
 from .issue_link_requester import IssueLinkRequester  # NOQA
 from .select_requester import SelectRequester  # NOQA

src/sentry/mediators/external_requests/issue_link_requester.py

@@ -10,10 +10,10 @@
 
 from sentry.coreapi import APIError
 from sentry.http import safe_urlread
-from sentry.mediators.external_requests.util import send_and_save_sentry_app_request, validate
 from sentry.mediators.mediator import Mediator
 from sentry.mediators.param import Param
 from sentry.models.group import Group
+from sentry.sentry_apps.external_requests.utils import send_and_save_sentry_app_request, validate
 from sentry.sentry_apps.services.app import RpcSentryAppInstallation
 from sentry.users.services.user import RpcUser
 from sentry.utils import json

src/sentry/mediators/external_requests/select_requester.py

@@ -6,9 +6,9 @@
 
 from sentry.coreapi import APIError
 from sentry.http import safe_urlread
-from sentry.mediators.external_requests.util import send_and_save_sentry_app_request, validate
 from sentry.mediators.mediator import Mediator
 from sentry.mediators.param import Param
+from sentry.sentry_apps.external_requests.utils import send_and_save_sentry_app_request, validate
 from sentry.sentry_apps.services.app import RpcSentryAppInstallation
 from sentry.utils import json
 

src/sentry/mediators/external_requests/alert_rule_action_requester.py renamed to src/sentry/sentry_apps/external_requests/alert_rule_action_requester.py

@@ -1,77 +1,50 @@
 import logging
+from dataclasses import dataclass, field
 from typing import TypedDict
 from urllib.parse import urlparse, urlunparse
 from uuid import uuid4
 
-from django.db import router
+from django.db import router, transaction
 from django.utils.functional import cached_property
 from requests import RequestException
 from requests.models import Response
 
-from sentry.mediators.external_requests.util import send_and_save_sentry_app_request
-from sentry.mediators.mediator import Mediator
-from sentry.mediators.param import Param
+from sentry.sentry_apps.external_requests.utils import send_and_save_sentry_app_request
 from sentry.sentry_apps.models.sentry_app_installation import SentryAppInstallation
+from sentry.sentry_apps.services.app.model import RpcSentryAppInstallation
 from sentry.utils import json
 
-logger = logging.getLogger("sentry.mediators.external-requests")
-
 DEFAULT_SUCCESS_MESSAGE = "Success!"
 DEFAULT_ERROR_MESSAGE = "Something went wrong!"
 
+logger = logging.getLogger("sentry.sentry_apps.external_requests")
+
 
 class AlertRuleActionResult(TypedDict):
     success: bool
     message: str
 
 
-class AlertRuleActionRequester(Mediator):
-    """
-    Makes a POST request to another service to fetch/update the values for each field in the
-    AlertRuleAction settings schema
-    """
-
-    install = Param(SentryAppInstallation)
-    uri = Param(str)
-    fields = Param(list, required=False, default=[])
-    http_method = Param(str, required=False, default="POST")
-    using = router.db_for_write(SentryAppInstallation)
-
-    def call(self):
-        return self._make_request()
-
-    def _build_url(self):
-        urlparts = list(urlparse(self.sentry_app.webhook_url))
-        urlparts[2] = self.uri
-        return urlunparse(urlparts)
-
-    def _get_response_message(self, response: Response | None, default_message: str) -> str:
-        """
-        Returns the message from the response body, if in the expected location.
-        Used to bubble up info from the Sentry App to the UI.
-        The location should be coordinated with the docs on Alert Rule Action UI Components.
-        """
-        if response is None:
-            message = default_message
-        else:
-            try:
-                message = response.json().get("message", default_message)
-            except Exception:
-                message = default_message
-
-        return f"{self.sentry_app.name}: {message}"
+@dataclass
+class AlertRuleActionRequester:
+    install: SentryAppInstallation | RpcSentryAppInstallation
+    uri: str
+    fields: list[dict[str, str]] = field(default_factory=list)
+    http_method: str | None = "POST"
 
-    def _make_request(self) -> AlertRuleActionResult:
+    def run(self) -> AlertRuleActionResult:
         try:
-            response = send_and_save_sentry_app_request(
-                self._build_url(),
-                self.sentry_app,
-                self.install.organization_id,
-                "alert_rule_action.requested",
-                headers=self._build_headers(),
-                method=self.http_method,
-                data=self.body,
-            )
+            with transaction.atomic(router.db_for_write(SentryAppInstallation)):
+                response = send_and_save_sentry_app_request(
+                    url=self._build_url(),
+                    sentry_app=self.sentry_app,
+                    org_id=self.install.organization_id,
+                    event="alert_rule_action.requested",
+                    headers=self._build_headers(),
+                    method=self.http_method,
+                    data=self.body,
+                )
+
         except RequestException as e:
             logger.info(
                 "alert_rule_action.error",
@@ -82,14 +55,20 @@ def _make_request(self) -> AlertRuleActionResult:
                     "error_message": str(e),
                 },
             )
+
             return AlertRuleActionResult(
                 success=False, message=self._get_response_message(e.response, DEFAULT_ERROR_MESSAGE)
             )
         return AlertRuleActionResult(
             success=True, message=self._get_response_message(response, DEFAULT_SUCCESS_MESSAGE)
         )
 
-    def _build_headers(self):
+    def _build_url(self) -> str:
+        urlparts = list(urlparse(self.sentry_app.webhook_url))
+        urlparts[2] = self.uri
+        return urlunparse(urlparts)
+
+    def _build_headers(self) -> dict[str, str]:
         request_uuid = uuid4().hex
 
         return {
@@ -98,6 +77,22 @@ def _build_headers(self):
             "Sentry-App-Signature": self.sentry_app.build_signature(self.body),
         }
 
+    def _get_response_message(self, response: Response | None, default_message: str) -> str:
+        """
+        Returns the message from the response body, if in the expected location.
+        Used to bubble up info from the Sentry App to the UI.
+        The location should be coordinated with the docs on Alert Rule Action UI Components.
+        """
+        if response is None:
+            message = default_message
+        else:
+            try:
+                message = response.json().get("message", default_message)
+            except Exception:
+                message = default_message
+
+        return f"{self.sentry_app.name}: {message}"
+
     @cached_property
     def body(self):
         return json.dumps(

src/sentry/mediators/external_requests/util.py renamed to src/sentry/sentry_apps/external_requests/utils.py

@@ -0,0 +1,48 @@
+# Generated by Django 5.1.1 on 2024-10-08 19:37
+
+import django.db.models.functions.comparison
+import django.db.models.functions.text
+from django.db import migrations, models
+
+from sentry.new_migrations.migrations import CheckedMigration
+
+
+class Migration(CheckedMigration):
+    # This flag is used to mark that a migration shouldn't be automatically run in production.
+    # This should only be used for operations where it's safe to run the migration after your
+    # code has deployed. So this should not be used for most operations that alter the schema
+    # of a table.
+    # Here are some things that make sense to mark as post deployment:
+    # - Large data migrations. Typically we want these to be run manually so that they can be
+    #   monitored and not block the deploy for a long period of time while they run.
+    # - Adding indexes to large tables. Since this can take a long time, we'd generally prefer to
+    #   run this outside deployments so that we don't block them. Note that while adding an index
+    #   is a schema change, it's completely safe to run the operation after the code has deployed.
+    # Once deployed, run these manually via: https://develop.sentry.dev/database-migrations/#migration-deployment
+
+    is_post_deployment = False
+
+    dependencies = [
+        ("uptime", "0016_translate_uptime_object_headers_to_lists"),
+    ]
+
+    operations = [
+        migrations.RemoveConstraint(
+            model_name="uptimesubscription",
+            name="uptime_uptimesubscription_unique_subscription_check",
+        ),
+        migrations.AddConstraint(
+            model_name="uptimesubscription",
+            constraint=models.UniqueConstraint(
+                models.F("url"),
+                models.F("interval_seconds"),
+                models.F("timeout_ms"),
+                models.F("method"),
+                django.db.models.functions.text.MD5("headers"),
+                django.db.models.functions.comparison.Coalesce(
+                    django.db.models.functions.text.MD5("body"), models.Value("")
+                ),
+                name="uptime_uptimesubscription_unique_subscription_check",
+            ),
+        ),
+    ]

src/sentry/uptime/migrations/0017_unique_on_timeout.py

@@ -71,6 +71,7 @@ class Meta:
             models.UniqueConstraint(
                 "url",
                 "interval_seconds",
+                "timeout_ms",
                 "method",
                 MD5("headers"),
                 Coalesce(MD5("body"), Value("")),

src/sentry/uptime/models.py

@@ -13,47 +13,47 @@ import type {
   Query,
 } from 'history';
 
-export interface Params {
+interface Params {
   [key: string]: string;
 }
 
-export type RoutePattern = string;
+type RoutePattern = string;
 export type RouteComponent = React.ComponentClass<any> | React.FunctionComponent<any>;
 
-export interface RouteComponents {
+interface RouteComponents {
   [name: string]: RouteComponent;
 }
 
-export interface RouterState<Q = any> {
+interface RouterState<Q = any> {
   components: RouteComponent[];
   location: Location<Q>;
   params: Params;
   routes: PlainRoute[];
 }
 
-export interface RedirectFunction {
+interface RedirectFunction {
   (location: LocationDescriptor): void;
   (state: LocationState, pathname: Pathname | Path, query?: Query): void;
 }
 
 type AnyFunction = (...args: any[]) => any;
 
-export type EnterHook = (
+type EnterHook = (
   nextState: RouterState,
   replace: RedirectFunction,
   callback?: AnyFunction
 ) => any;
 
-export type LeaveHook = (prevState: RouterState) => any;
+type LeaveHook = (prevState: RouterState) => any;
 
-export type ChangeHook = (
+type ChangeHook = (
   prevState: RouterState,
   nextState: RouterState,
   replace: RedirectFunction,
   callback?: AnyFunction
 ) => any;
 
-export type RouteHook = (nextLocation?: Location) => any;
+type RouteHook = (nextLocation?: Location) => any;
 
 type ComponentCallback = (err: any, component: RouteComponent) => any;
 type ComponentsCallback = (err: any, components: RouteComponents) => any;

static/app/types/legacyReactRouter.tsx

@@ -6,6 +6,7 @@ import {Observer} from 'mobx-react';
 import {Button} from 'sentry/components/button';
 import Confirm from 'sentry/components/confirm';
 import FieldWrapper from 'sentry/components/forms/fieldGroup/fieldWrapper';
+import HiddenField from 'sentry/components/forms/fields/hiddenField';
 import SelectField from 'sentry/components/forms/fields/selectField';
 import SentryMemberTeamSelectorField from 'sentry/components/forms/fields/sentryMemberTeamSelectorField';
 import SentryProjectSelectorField from 'sentry/components/forms/fields/sentryProjectSelectorField';
@@ -268,6 +269,7 @@ export function UptimeAlertForm({project, handleDelete, rule}: Props) {
               border: 'none',
             }}
           />
+          <HiddenField name="timeoutMs" defaultValue={10000} />
         </FormRow>
       </List>
     </Form>