feat: implementation

Author: jianyuan

src/sentry/integrations/gitlab/integration.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import logging
 from collections.abc import Callable, Mapping
 from typing import Any
 from urllib.parse import urlparse
@@ -21,9 +22,17 @@
 )
 from sentry.integrations.services.repository.model import RpcRepository
 from sentry.integrations.source_code_management.commit_context import (
+    OPEN_PR_MAX_FILES_CHANGED,
+    OPEN_PR_MAX_LINES_CHANGED,
+    OPEN_PR_METRICS_BASE,
     CommitContextIntegration,
+    OpenPRCommentWorkflow,
     PRCommentWorkflow,
+    PullRequestFile,
+    PullRequestIssue,
+    _open_pr_comment_log,
 )
+from sentry.integrations.source_code_management.language_parsers import PATCH_PARSERS
 from sentry.integrations.source_code_management.repository import RepositoryIntegration
 from sentry.models.group import Group
 from sentry.models.organization import Organization
@@ -36,17 +45,21 @@
     IntegrationProviderError,
 )
 from sentry.snuba.referrer import Referrer
-from sentry.types.referrer_ids import GITLAB_PR_BOT_REFERRER
+from sentry.templatetags.sentry_helpers import small_count
+from sentry.types.referrer_ids import GITLAB_OPEN_PR_BOT_REFERRER, GITLAB_PR_BOT_REFERRER
 from sentry.users.models.identity import Identity
 from sentry.utils import metrics
 from sentry.utils.hashlib import sha1_text
 from sentry.utils.http import absolute_uri
+from sentry.utils.patch_set import patch_to_file_modifications
 from sentry.web.helpers import render_to_response
 
 from .client import GitLabApiClient, GitLabSetupApiClient
 from .issues import GitlabIssuesSpec
 from .repository import GitlabRepositoryProvider
 
+logger = logging.getLogger("sentry.integrations.gitlab")
+
 DESCRIPTION = """
 Connect your Sentry organization to an organization in your GitLab instance or gitlab.com, enabling the following features:
 """
@@ -203,6 +216,9 @@ def search_issues(self, query: str | None, **kwargs) -> list[dict[str, Any]]:
     def get_pr_comment_workflow(self) -> PRCommentWorkflow:
         return GitlabPRCommentWorkflow(integration=self)
 
+    def get_open_pr_comment_workflow(self) -> OpenPRCommentWorkflow:
+        return GitlabOpenPRCommentWorkflow(integration=self)
+
 
 MERGED_PR_COMMENT_BODY_TEMPLATE = """\
 ## Suspect Issues
@@ -257,6 +273,217 @@ def get_comment_data(
         }
 
 
+OPEN_PR_COMMENT_BODY_TEMPLATE = """\
+## 🔍 Existing Issues For Review
+Your merge request is modifying functions with the following pre-existing issues:
+
+{issue_tables}"""
+
+OPEN_PR_ISSUE_TABLE_TEMPLATE = """\
+📄 File: **{filename}**
+
+| Function | Unhandled Issue |
+| :------- | :----- |
+{issue_rows}"""
+
+OPEN_PR_ISSUE_TABLE_TOGGLE_TEMPLATE = """\
+<details>
+<summary><b>📄 File: {filename} (Click to Expand)</b></summary>
+
+| Function | Unhandled Issue |
+| :------- | :----- |
+{issue_rows}
+</details>"""
+
+OPEN_PR_ISSUE_DESCRIPTION_LENGTH = 52
+
+
+class GitlabOpenPRCommentWorkflow(OpenPRCommentWorkflow):
+    integration: GitlabIntegration
+    organization_option_key = "sentry:gitlab_open_pr_bot"
+    referrer = Referrer.GITLAB_PR_COMMENT_BOT
+    referrer_id = GITLAB_OPEN_PR_BOT_REFERRER
+
+    def safe_for_comment(self, repo: Repository, pr: PullRequest) -> list[dict[str, Any]]:
+        client = self.integration.get_client()
+
+        try:
+            diffs = client.get_pr_diffs(repo=repo, pr=pr)
+        except ApiError as e:
+            logger.info(
+                _open_pr_comment_log(
+                    integration_name=self.integration.integration_name, suffix="api_error"
+                )
+            )
+            if e.code == 404:
+                metrics.incr(
+                    OPEN_PR_METRICS_BASE.format(
+                        integration=self.integration.integration_name, key="api_error"
+                    ),
+                    tags={"type": "missing_pr", "code": e.code},
+                )
+            else:
+                metrics.incr(
+                    OPEN_PR_METRICS_BASE.format(
+                        integration=self.integration.integration_name, key="api_error"
+                    ),
+                    tags={"type": "unknown_api_error", "code": e.code},
+                )
+                logger.exception(
+                    _open_pr_comment_log(
+                        integration_name=self.integration.integration_name,
+                        suffix="unknown_api_error",
+                    ),
+                    extra={"error": str(e)},
+                )
+            return []
+
+        changed_file_count = 0
+        changed_lines_count = 0
+        filtered_diffs = []
+
+        patch_parsers = PATCH_PARSERS
+
+        for diff in diffs:
+            filename = diff["new_path"]
+            # we only count the file if it's modified and if the file extension is in the list of supported file extensions
+            # we cannot look at deleted or newly added files because we cannot extract functions from the diffs
+
+            if filename.split(".")[-1] not in patch_parsers:
+                continue
+
+            try:
+                file_modifications = patch_to_file_modifications(diff["diff"])
+            except Exception:
+                logger.exception(
+                    _open_pr_comment_log(
+                        integration_name=self.integration.integration_name,
+                        suffix="patch_parsing_error",
+                    ),
+                )
+                continue
+
+            if not file_modifications.modified:
+                continue
+
+            changed_file_count += len(file_modifications.modified)
+            changed_lines_count += sum(
+                modification.lines_modified for modification in file_modifications.modified
+            )
+
+            filtered_diffs.append(diff)
+
+            if changed_file_count > OPEN_PR_MAX_FILES_CHANGED:
+                metrics.incr(
+                    OPEN_PR_METRICS_BASE.format(
+                        integration=self.integration.integration_name, key="rejected_comment"
+                    ),
+                    tags={"reason": "too_many_files"},
+                )
+                return []
+            if changed_lines_count > OPEN_PR_MAX_LINES_CHANGED:
+                metrics.incr(
+                    OPEN_PR_METRICS_BASE.format(
+                        integration=self.integration.integration_name, key="rejected_comment"
+                    ),
+                    tags={"reason": "too_many_lines"},
+                )
+                return []
+
+        return filtered_diffs
+
+    def get_pr_files_safe_for_comment(
+        self, repo: Repository, pr: PullRequest
+    ) -> list[PullRequestFile]:
+        pr_diffs = self.safe_for_comment(repo=repo, pr=pr)
+
+        if len(pr_diffs) == 0:
+            logger.info(
+                _open_pr_comment_log(
+                    integration_name=self.integration.integration_name,
+                    suffix="not_safe_for_comment",
+                ),
+                extra={"file_count": len(pr_diffs)},
+            )
+            metrics.incr(
+                OPEN_PR_METRICS_BASE.format(
+                    integration=self.integration.integration_name, key="error"
+                ),
+                tags={"type": "unsafe_for_comment"},
+            )
+            return []
+
+        pr_files = [
+            PullRequestFile(filename=diff["new_path"], patch=diff["diff"]) for diff in pr_diffs
+        ]
+
+        logger.info(
+            _open_pr_comment_log(
+                integration_name=self.integration.integration_name,
+                suffix="pr_filenames",
+            ),
+            extra={"count": len(pr_files)},
+        )
+
+        return pr_files
+
+    def get_comment_data(self, comment_body: str) -> dict[str, Any]:
+        return {
+            "body": comment_body,
+        }
+
+    @staticmethod
+    def format_comment_url(url: str, referrer: str) -> str:
+        return url + "?referrer=" + referrer
+
+    @staticmethod
+    def format_open_pr_comment(issue_tables: list[str]) -> str:
+        return OPEN_PR_COMMENT_BODY_TEMPLATE.format(issue_tables="\n".join(issue_tables))
+
+    @staticmethod
+    def format_open_pr_comment_subtitle(title_length, subtitle):
+        # the title length + " " + subtitle should be <= 52
+        subtitle_length = OPEN_PR_ISSUE_DESCRIPTION_LENGTH - title_length - 1
+        return (
+            subtitle[: subtitle_length - 3] + "..." if len(subtitle) > subtitle_length else subtitle
+        )
+
+    def format_issue_table(
+        self,
+        diff_filename: str,
+        issues: list[PullRequestIssue],
+        patch_parsers: dict[str, Any],
+        toggle: bool,
+    ) -> str:
+        language_parser = patch_parsers.get(diff_filename.split(".")[-1], None)
+
+        if not language_parser:
+            return ""
+
+        issue_row_template = language_parser.issue_row_template
+
+        issue_rows = "\n".join(
+            [
+                issue_row_template.format(
+                    title=issue.title,
+                    subtitle=self.format_open_pr_comment_subtitle(len(issue.title), issue.subtitle),
+                    url=self.format_comment_url(issue.url, GITLAB_OPEN_PR_BOT_REFERRER),
+                    event_count=small_count(issue.event_count),
+                    function_name=issue.function_name,
+                    affected_users=small_count(issue.affected_users),
+                )
+                for issue in issues
+            ]
+        )
+
+        if toggle:
+            return OPEN_PR_ISSUE_TABLE_TOGGLE_TEMPLATE.format(
+                filename=diff_filename, issue_rows=issue_rows
+            )
+
+        return OPEN_PR_ISSUE_TABLE_TEMPLATE.format(filename=diff_filename, issue_rows=issue_rows)
+
+
 class InstallationForm(forms.Form):
     url = forms.CharField(
         label=_("GitLab URL"),

src/sentry/integrations/source_code_management/tasks.py

@@ -299,6 +299,7 @@ def open_pr_comment_workflow(pr_id: int) -> None:
             extra={
                 "organization_id": org_id,
                 "repository_id": repo.id,
+                "file_name": file.filename,
                 "extension": file_extension,
             },
         )
@@ -307,22 +308,35 @@ def open_pr_comment_workflow(pr_id: int) -> None:
         if not language_parser:
             logger.info(
                 _open_pr_comment_log(integration_name=integration_name, suffix="missing_parser"),
-                extra={"extension": file_extension},
+                extra={"file_name": file.filename, "extension": file_extension},
             )
             metrics.incr(
                 OPEN_PR_METRICS_BASE.format(integration=integration_name, key="missing_parser"),
-                tags={"extension": file_extension},
+                tags={"file_name": file.filename, "extension": file_extension},
             )
             continue
 
         function_names = language_parser.extract_functions_from_patch(file.patch)
 
+        if file_extension == "py":
+            logger.info(
+                _open_pr_comment_log(integration_name=integration_name, suffix="python"),
+                extra={
+                    "organization_id": org_id,
+                    "repository_id": repo.id,
+                    "file_name": file.filename,
+                    "extension": file_extension,
+                    "has_function_names": bool(function_names),
+                },
+            )
+
         if file_extension in ["js", "jsx"]:
             logger.info(
                 _open_pr_comment_log(integration_name=integration_name, suffix="javascript"),
                 extra={
                     "organization_id": org_id,
                     "repository_id": repo.id,
+                    "file_name": file.filename,
                     "extension": file_extension,
                     "has_function_names": bool(function_names),
                 },
@@ -334,6 +348,7 @@ def open_pr_comment_workflow(pr_id: int) -> None:
                 extra={
                     "organization_id": org_id,
                     "repository_id": repo.id,
+                    "file_name": file.filename,
                     "extension": file_extension,
                     "has_function_names": bool(function_names),
                 },
@@ -345,6 +360,7 @@ def open_pr_comment_workflow(pr_id: int) -> None:
                 extra={
                     "organization_id": org_id,
                     "repository_id": repo.id,
+                    "file_name": file.filename,
                     "extension": file_extension,
                     "has_function_names": bool(function_names),
                 },