✨ feat: add issue sync outbound support

Author: iamrajjoshi

src/sentry/integrations/gitlab/integration.py

@@ -8,6 +8,7 @@
 from django import forms
 from django.http.request import HttpRequest
 from django.http.response import HttpResponseBase
+from django.urls import reverse
 from django.utils.translation import gettext_lazy as _
 
 from sentry import features
@@ -22,6 +23,8 @@
 )
 from sentry.integrations.gitlab.constants import GITLAB_WEBHOOK_VERSION, GITLAB_WEBHOOK_VERSION_KEY
 from sentry.integrations.gitlab.tasks import update_all_project_webhooks
+from sentry.integrations.gitlab.types import GitLabIssueStatus
+from sentry.integrations.models.integration_external_project import IntegrationExternalProject
 from sentry.integrations.pipeline import IntegrationPipeline
 from sentry.integrations.referrer_ids import GITLAB_PR_BOT_REFERRER
 from sentry.integrations.services.integration import integration_service
@@ -42,6 +45,7 @@
 from sentry.shared_integrations.exceptions import (
     ApiError,
     IntegrationConfigurationError,
+    IntegrationError,
     IntegrationProviderError,
 )
 from sentry.snuba.referrer import Referrer
@@ -257,6 +261,54 @@ def get_organization_config(self) -> list[dict[str, Any]]:
 
         has_issue_sync = features.has("organizations:integrations-issue-sync", organization)
 
+        # Add outbound status sync configuration if feature flag is enabled
+        if self.check_feature_flag():
+            # Get currently configured external projects to display their labels
+            current_project_items = []
+            if self.org_integration:
+                external_projects = IntegrationExternalProject.objects.filter(
+                    organization_integration_id=self.org_integration.id
+                )
+
+                if external_projects.exists():
+                    current_project_items = [
+                        {"value": project.external_id, "label": project.name}
+                        for project in external_projects
+                    ]
+
+            config.insert(
+                0,
+                {
+                    "name": self.outbound_status_key,
+                    "type": "choice_mapper",
+                    "label": _("Sync Sentry Status to GitLab"),
+                    "help": _(
+                        "When a Sentry issue changes status, change the status of the linked ticket in GitLab."
+                    ),
+                    "addButtonText": _("Add GitLab Project"),
+                    "addDropdown": {
+                        "emptyMessage": _("All projects configured"),
+                        "noResultsMessage": _("Could not find GitLab project"),
+                        "items": current_project_items,
+                        "url": reverse(
+                            "sentry-extensions-gitlab-search",
+                            args=[organization.slug, self.model.id],
+                        ),
+                        "searchField": "project",
+                    },
+                    "mappedSelectors": {
+                        "on_resolve": {"choices": GitLabIssueStatus.get_choices()},
+                        "on_unresolve": {"choices": GitLabIssueStatus.get_choices()},
+                    },
+                    "columnLabels": {
+                        "on_resolve": _("When resolved"),
+                        "on_unresolve": _("When unresolved"),
+                    },
+                    "mappedColumnLabel": _("GitLab Project"),
+                    "formatMessageValue": False,
+                },
+            )
+
         if not has_issue_sync:
             for field in config:
                 field["disabled"] = True
@@ -272,6 +324,43 @@ def update_organization_config(self, data: MutableMapping[str, Any]) -> None:
 
         config = self.org_integration.config
 
+        # Handle status sync configuration
+        if "sync_status_forward" in data:
+            project_mappings = data.pop("sync_status_forward")
+
+            # Validate that all mappings have both statuses
+            if any(
+                not mapping.get("on_unresolve") or not mapping.get("on_resolve")
+                for mapping in project_mappings.values()
+            ):
+                raise IntegrationError("Resolve and unresolve status are required.")
+
+            data["sync_status_forward"] = bool(project_mappings)
+
+            IntegrationExternalProject.objects.filter(
+                organization_integration_id=self.org_integration.id
+            ).delete()
+
+            for project_path, statuses in project_mappings.items():
+                # Validate status values
+                valid_statuses = {GitLabIssueStatus.OPENED.value, GitLabIssueStatus.CLOSED.value}
+                if statuses["on_resolve"] not in valid_statuses:
+                    raise IntegrationError(
+                        f"Invalid resolve status: {statuses['on_resolve']}. Must be 'opened' or 'closed'."
+                    )
+                if statuses["on_unresolve"] not in valid_statuses:
+                    raise IntegrationError(
+                        f"Invalid unresolve status: {statuses['on_unresolve']}. Must be 'opened' or 'closed'."
+                    )
+
+                IntegrationExternalProject.objects.create(
+                    organization_integration_id=self.org_integration.id,
+                    external_id=project_path,
+                    name=project_path,
+                    resolved_status=statuses["on_resolve"],
+                    unresolved_status=statuses["on_unresolve"],
+                )
+
         # Check webhook version BEFORE updating config to determine if migration is needed
         current_webhook_version = config.get(GITLAB_WEBHOOK_VERSION_KEY, 0)
 
@@ -284,9 +373,7 @@ def update_organization_config(self, data: MutableMapping[str, Any]) -> None:
         if org_integration is not None:
             self.org_integration = org_integration
 
-        # Only update webhooks if:
-        # 1. A sync setting was enabled, AND
-        # 2. The webhook version is outdated
+        # Only update webhooks if the webhook version is outdated
         if current_webhook_version < GITLAB_WEBHOOK_VERSION:
             update_all_project_webhooks.delay(
                 integration_id=self.model.id,

src/sentry/integrations/gitlab/issue_sync.py

@@ -6,10 +6,12 @@
 from urllib.parse import quote
 
 from sentry import features
+from sentry.integrations.gitlab.types import GitLabIssueAction, GitLabIssueStatus
 from sentry.integrations.mixins.issues import IssueSyncIntegration, ResolveSyncAction
 from sentry.integrations.models.external_actor import ExternalActor
 from sentry.integrations.models.external_issue import ExternalIssue
 from sentry.integrations.models.integration_external_project import IntegrationExternalProject
+from sentry.integrations.services.integration import integration_service
 from sentry.integrations.types import EXTERNAL_PROVIDERS_REVERSE, ExternalProviderEnum
 from sentry.shared_integrations.exceptions import ApiError
 from sentry.users.services.user.model import RpcUser
@@ -23,6 +25,7 @@ class GitlabIssueSyncSpec(IssueSyncIntegration):
     outbound_assignee_key = "sync_forward_assignment"
     inbound_assignee_key = "sync_reverse_assignment"
     inbound_status_key = "sync_status_reverse"
+    outbound_status_key = "sync_status_forward"
     resolution_strategy_key = "resolution_strategy"
 
     def check_feature_flag(self) -> bool:
@@ -164,7 +167,93 @@ def sync_status_outbound(
         Propagate a sentry issue's status to a linked GitLab issue's status.
         For GitLab, we only support opened/closed states.
         """
-        raise NotImplementedError
+
+        client = self.get_client()
+        project_path, issue_iid = self.split_external_issue_key(external_issue.key)
+
+        if not project_path or not issue_iid:
+            logger.warning(
+                "status-outbound.invalid-key",
+                extra={
+                    "external_issue_key": external_issue.key,
+                    "provider": self.model.provider,
+                },
+            )
+            return
+
+        # Get the project mapping to determine what status to use
+        external_project = integration_service.get_integration_external_project(
+            organization_id=external_issue.organization_id,
+            integration_id=external_issue.integration_id,
+            external_id=project_path,
+        )
+
+        log_context = {
+            "provider": self.model.provider,
+            "integration_id": external_issue.integration_id,
+            "is_resolved": is_resolved,
+            "issue_key": external_issue.key,
+            "project_path": project_path,
+        }
+
+        if not external_project:
+            logger.info("external-project-not-found", extra=log_context)
+            return
+
+        desired_state = (
+            external_project.resolved_status if is_resolved else external_project.unresolved_status
+        )
+
+        # Fetch current GitLab issue state
+        try:
+            # URL-encode project_path since it's a path_with_namespace
+            encoded_project_path = quote(project_path, safe="")
+            issue_data = client.get_issue(encoded_project_path, issue_iid)
+        except ApiError as e:
+            self.raise_error(e)
+
+        current_state = issue_data.get("state")
+
+        # Don't update if it's already in the desired state
+        if current_state == desired_state:
+            logger.info(
+                "sync_status_outbound.unchanged",
+                extra={
+                    **log_context,
+                    "current_state": current_state,
+                    "desired_state": desired_state,
+                },
+            )
+            return
+
+        # Determine state_event parameter for GitLab API
+        # GitLab uses "close" to transition to closed, "reopen" to transition to opened
+        if desired_state == GitLabIssueStatus.CLOSED.value:
+            state_event = GitLabIssueAction.CLOSE.value
+        elif desired_state == GitLabIssueStatus.OPENED.value:
+            state_event = GitLabIssueAction.REOPEN.value
+        else:
+            logger.warning(
+                "sync_status_outbound.invalid-desired-state",
+                extra={**log_context, "desired_state": desired_state},
+            )
+            return
+
+        # Update the issue state
+        try:
+            encoded_project_path = quote(project_path, safe="")
+            client.update_issue_status(encoded_project_path, issue_iid, state_event)
+            logger.info(
+                "sync_status_outbound.success",
+                extra={
+                    **log_context,
+                    "old_state": current_state,
+                    "new_state": desired_state,
+                    "state_event": state_event,
+                },
+            )
+        except ApiError as e:
+            self.raise_error(e)
 
     def get_resolve_sync_action(self, data: Mapping[str, Any]) -> ResolveSyncAction:
         """

src/sentry/integrations/gitlab/search.py

@@ -77,7 +77,10 @@ def handle_search_repositories(
                 return Response({"detail": str(e)}, status=400)
             return Response(
                 [
-                    {"label": project["name_with_namespace"], "value": project["id"]}
+                    {
+                        "label": project["name_with_namespace"],
+                        "value": project["path_with_namespace"],
+                    }
                     for project in response
                 ]
             )

src/sentry/integrations/gitlab/types.py

@@ -10,3 +10,13 @@ class GitLabIssueAction(StrEnum):
     @classmethod
     def values(cls):
         return [action.value for action in cls]
+
+
+class GitLabIssueStatus(StrEnum):
+    OPENED = "opened"
+    CLOSED = "closed"
+
+    @classmethod
+    def get_choices(cls):
+        """Return choices formatted for dropdown selectors"""
+        return [(status.value, status.value.capitalize()) for status in cls]