Merge branch 'master' of github.com:getsentry/sentry into txiao/chore/remove-visibility-explore-aggregate-editor-flag-backend

Author: Zylphrex

src/sentry/conf/server.py

@@ -195,7 +195,6 @@ def env(
 SENTRY_HYBRIDCLOUD_DELETIONS_REDIS_CLUSTER = "default"
 SENTRY_SESSION_STORE_REDIS_CLUSTER = "default"
 SENTRY_AUTH_IDPMIGRATION_REDIS_CLUSTER = "default"
-SENTRY_SNOWFLAKE_REDIS_CLUSTER = "default"
 
 # Hosts that are allowed to use system token authentication.
 # http://en.wikipedia.org/wiki/Reserved_IP_addresses

src/sentry/features/temporary.py

@@ -329,8 +329,6 @@ def register_temporary_features(manager: FeatureManager) -> None:
     manager.add("organizations:relay-otlp-traces-endpoint", OrganizationFeature, FeatureHandlerStrategy.FLAGPOLE, api_expose=True)
     # Enables OTLP Log ingestion in Relay for an entire org.
     manager.add("organizations:relay-otel-logs-endpoint", OrganizationFeature, FeatureHandlerStrategy.FLAGPOLE, api_expose=True)
-    # Enables Vercel Log Drain ingestion in Relay for an entire org.
-    manager.add("organizations:relay-vercel-log-drain-endpoint", OrganizationFeature, FeatureHandlerStrategy.FLAGPOLE, api_expose=True)
     # Enables Prevent AI in the Sentry UI
     manager.add("organizations:prevent-ai", OrganizationFeature, FeatureHandlerStrategy.FLAGPOLE, api_expose=True)
     # Enables Prevent AI Configuration Page in the Sentry UI

src/sentry/incidents/endpoints/serializers/utils.py

@@ -1,4 +1,4 @@
-OFFSET = 10**9
+OFFSET = 10**10
 
 
 def get_fake_id_from_object_id(obj_id: int) -> int:

src/sentry/integrations/cursor/client.py

@@ -11,6 +11,7 @@
     CursorAgentLaunchRequestWebhook,
     CursorAgentLaunchResponse,
     CursorAgentSource,
+    CursorApiKeyMetadata,
 )
 from sentry.seer.autofix.utils import CodingAgentProviderType, CodingAgentState, CodingAgentStatus
 
@@ -30,6 +31,24 @@ def __init__(self, api_key: str, webhook_secret: str):
     def _get_auth_headers(self) -> dict[str, str]:
         return {"Authorization": f"Bearer {self.api_key}"}
 
+    def get_api_key_metadata(self) -> CursorApiKeyMetadata:
+        """Fetch metadata about the API key from Cursor's /v0/me endpoint."""
+        logger.info(
+            "coding_agent.cursor.get_api_key_metadata",
+            extra={"agent_type": self.__class__.__name__},
+        )
+
+        api_response = self.get(
+            "/v0/me",
+            headers={
+                "content-type": "application/json;charset=utf-8",
+                **self._get_auth_headers(),
+            },
+            timeout=30,
+        )
+
+        return CursorApiKeyMetadata.validate(api_response.json)
+
     def launch(self, webhook_url: str, request: CodingAgentLaunchRequest) -> CodingAgentState:
         """Launch coding agent with webhook callback."""
         payload = CursorAgentLaunchRequestBody(

src/sentry/integrations/cursor/integration.py

@@ -8,7 +8,8 @@
 from django.http.request import HttpRequest
 from django.http.response import HttpResponseBase
 from django.utils.translation import gettext_lazy as _
-from pydantic import BaseModel
+from pydantic import BaseModel, ValidationError
+from requests import HTTPError
 
 from sentry.integrations.base import (
     FeatureDescription,
@@ -26,7 +27,7 @@
 from sentry.integrations.services.integration import integration_service
 from sentry.integrations.services.integration.model import RpcIntegration
 from sentry.models.apitoken import generate_token
-from sentry.shared_integrations.exceptions import IntegrationConfigurationError
+from sentry.shared_integrations.exceptions import ApiError, IntegrationConfigurationError
 
 DESCRIPTION = "Connect your Sentry organization with Cursor Cloud Agents."
 
@@ -42,6 +43,8 @@ class CursorIntegrationMetadata(BaseModel):
     api_key: str
     webhook_secret: str
     domain_name: Literal["cursor.sh"] = "cursor.sh"
+    api_key_name: str | None = None
+    user_email: str | None = None
 
 
 metadata = IntegrationMetadata(
@@ -106,19 +109,44 @@ def build_integration(self, state: Mapping[str, Any]) -> IntegrationData:
             raise IntegrationConfigurationError("Missing configuration data")
 
         webhook_secret = generate_token()
+        api_key = config["api_key"]
+
+        api_key_name = None
+        user_email = None
+        try:
+            client = CursorAgentClient(api_key=api_key, webhook_secret=webhook_secret)
+            cursor_metadata = client.get_api_key_metadata()
+            api_key_name = cursor_metadata.apiKeyName
+            user_email = cursor_metadata.userEmail
+        except (HTTPError, ApiError):
+            self.get_logger().exception(
+                "cursor.build_integration.metadata_fetch_failed",
+            )
+        except ValidationError:
+            self.get_logger().exception(
+                "cursor.build_integration.metadata_validation_failed",
+            )
+
+        integration_name = (
+            f"Cursor Cloud Agent - {user_email}/{api_key_name}"
+            if user_email and api_key_name
+            else "Cursor Cloud Agent"
+        )
 
         metadata = CursorIntegrationMetadata(
             domain_name="cursor.sh",
-            api_key=config["api_key"],
+            api_key=api_key,
             webhook_secret=webhook_secret,
+            api_key_name=api_key_name,
+            user_email=user_email,
         )
 
         return {
             # NOTE(jennmueng): We need to create a unique ID for each integration installation. Because of this, new installations will yield a unique external_id and integration.
             # Why UUIDs? We use UUIDs here for each integration installation because we don't know how many times this USER-LEVEL API key will be used, or if the same org can have multiple cursor agents (in the near future)
             # or if the same user can have multiple installations across multiple orgs. So just a UUID per installation is the best approach. Re-configuring an existing installation will still maintain this external id
             "external_id": uuid.uuid4().hex,
-            "name": "Cursor Agent",
+            "name": integration_name,
             "metadata": metadata.dict(),
         }
 
@@ -170,6 +198,18 @@ def get_client(self):
             webhook_secret=self.webhook_secret,
         )
 
+    def get_dynamic_display_information(self) -> Mapping[str, Any] | None:
+        """Return metadata to display in the configurations list."""
+        metadata = CursorIntegrationMetadata.parse_obj(self.model.metadata or {})
+
+        display_info = {}
+        if metadata.api_key_name:
+            display_info["api_key_name"] = metadata.api_key_name
+        if metadata.user_email:
+            display_info["user_email"] = metadata.user_email
+
+        return display_info if display_info else None
+
     @property
     def webhook_secret(self) -> str:
         return CursorIntegrationMetadata.parse_obj(self.model.metadata).webhook_secret

src/sentry/integrations/cursor/models.py

@@ -3,6 +3,12 @@
 from pydantic import BaseModel
 
 
+class CursorApiKeyMetadata(BaseModel):
+    apiKeyName: str
+    createdAt: str
+    userEmail: str
+
+
 class CursorAgentLaunchRequestPrompt(BaseModel):
     text: str
     images: list[dict] = []

src/sentry/integrations/vercel/integration.py

@@ -2,7 +2,7 @@
 
 import logging
 from collections.abc import Mapping, Sequence
-from typing import Any, TypedDict
+from typing import Any, Self, TypedDict
 from urllib.parse import urlencode
 
 import sentry_sdk
@@ -28,6 +28,7 @@
 from sentry.pipeline.views.nested import NestedPipelineView
 from sentry.projects.services.project.model import RpcProject
 from sentry.projects.services.project_key import project_key_service
+from sentry.projects.services.project_key.model import RpcProjectKey
 from sentry.sentry_apps.logic import SentryAppCreator
 from sentry.sentry_apps.models.sentry_app_installation import SentryAppInstallation
 from sentry.sentry_apps.models.sentry_app_installation_for_provider import (
@@ -107,6 +108,7 @@ class VercelEnvVarDefinition(TypedDict):
     target: list[str]
 
 
+# TODO: Remove this function and use the new VercelEnvVarMapBuilder class instead
 def get_env_var_map(
     organization: RpcOrganization,
     project: RpcProject,
@@ -153,6 +155,107 @@ def get_env_var_map(
     }
 
 
+class VercelEnvVarMapBuilder:
+    """
+    Builder for creating Vercel environment variable maps.
+
+    env_var_map = (
+        VercelEnvVarMapBuilder()
+        .with_organization(organization)
+        .with_project(project)
+        .with_project_key(project_key)
+        .with_auth_token(auth_token)
+        .with_framework(framework)
+        .build()
+    )
+    """
+
+    def __init__(self) -> None:
+        self._organization: RpcOrganization | None = None
+        self._project: RpcProject | None = None
+        self._project_key: RpcProjectKey | None = None
+        self._auth_token: str | None = None
+        self._framework: str | None = None
+
+    def with_organization(self, organization: RpcOrganization) -> Self:
+        self._organization = organization
+        return self
+
+    def with_project(self, project: RpcProject) -> Self:
+        self._project = project
+        return self
+
+    def with_project_key(self, project_key: RpcProjectKey) -> Self:
+        self._project_key = project_key
+        return self
+
+    def with_auth_token(self, auth_token: str | None) -> Self:
+        self._auth_token = auth_token
+        return self
+
+    def with_framework(self, framework: str | None) -> Self:
+        self._framework = framework
+        return self
+
+    def build(self) -> dict[str, VercelEnvVarDefinition]:
+        if self._organization is None:
+            raise ValueError("organization is required")
+        if self._project is None:
+            raise ValueError("project is required")
+        if self._project_key is None:
+            raise ValueError("project_key is required")
+
+        is_next_js = self._framework == "nextjs"
+        dsn_env_name = "NEXT_PUBLIC_SENTRY_DSN" if is_next_js else "SENTRY_DSN"
+
+        return {
+            "SENTRY_ORG": {
+                "type": "encrypted",
+                "value": self._organization.slug,
+                "target": ["production", "preview"],
+            },
+            "SENTRY_PROJECT": {
+                "type": "encrypted",
+                "value": self._project.slug,
+                "target": ["production", "preview"],
+            },
+            dsn_env_name: {
+                "type": "encrypted",
+                "value": self._project_key.dsn_public,
+                "target": [
+                    "production",
+                    "preview",
+                    "development",  # The DSN is the only value that makes sense to have available locally via Vercel CLI's `vercel dev` command
+                ],
+            },
+            "SENTRY_AUTH_TOKEN": {
+                "type": "encrypted",
+                "value": self._auth_token,
+                "target": ["production", "preview"],
+            },
+            "VERCEL_GIT_COMMIT_SHA": {
+                "type": "system",
+                "value": "VERCEL_GIT_COMMIT_SHA",
+                "target": ["production", "preview"],
+            },
+            "SENTRY_VERCEL_LOG_DRAIN_URL": {
+                "type": "encrypted",
+                "value": f"{self._project_key.integration_endpoint}vercel/logs/",
+                "target": ["production", "preview"],
+            },
+            "SENTRY_OTLP_TRACES_URL": {
+                "type": "encrypted",
+                "value": f"{self._project_key.integration_endpoint}otlp/v1/traces",
+                "target": ["production", "preview"],
+            },
+            "SENTRY_PUBLIC_KEY": {
+                "type": "encrypted",
+                "value": self._project_key.public_key,
+                "target": ["production", "preview"],
+            },
+        }
+
+
 class VercelIntegration(IntegrationInstallation):
     @property
     def metadata(self):
@@ -264,27 +367,28 @@ def update_organization_config(self, data):
             [sentry_project_id, vercel_project_id] = mapping
             sentry_project = sentry_projects[sentry_project_id]
 
-            enabled_dsn = project_key_service.get_default_project_key(
+            project_key = project_key_service.get_default_project_key(
                 organization_id=self.organization_id, project_id=sentry_project_id
             )
-            if not enabled_dsn:
+            if not project_key:
                 raise ValidationError(
                     {"project_mappings": ["You must have an enabled DSN to continue!"]}
                 )
 
-            sentry_project_dsn = enabled_dsn.dsn_public
             vercel_project = vercel_client.get_project(vercel_project_id)
             sentry_auth_token = SentryAppInstallationToken.objects.get_token(
                 sentry_project.organization_id,
                 "vercel",
             )
 
-            env_var_map = get_env_var_map(
-                organization=self.organization,
-                project=sentry_project,
-                project_dsn=sentry_project_dsn,
-                auth_token=sentry_auth_token,
-                framework=vercel_project.get("framework"),
+            env_var_map = (
+                VercelEnvVarMapBuilder()
+                .with_organization(self.organization)
+                .with_project(sentry_project)
+                .with_project_key(project_key)
+                .with_auth_token(sentry_auth_token)
+                .with_framework(vercel_project.get("framework"))
+                .build()
             )
 
             for env_var, details in env_var_map.items():

src/sentry/notifications/notification_action/action_handler_registry/sentry_app_handler.py

@@ -33,6 +33,7 @@ class SentryAppActionHandler(ActionHandler):
 
     data_schema = {
         "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "description": "The data schema for a Sentry App Action",
         "type": "object",
         "properties": {
             "settings": {"type": ["array", "object"]},