♻️ ref: metrics for task and create_or_update_comment

iamrajjoshi · iamrajjoshi · commit c248ca77c81c · 2024-11-20T19:25:29.000-05:00
diff --git a/src/sentry/integrations/source_code_management/commit_context.py b/src/sentry/integrations/source_code_management/commit_context.py
@@ -14,6 +14,7 @@
 from sentry.auth.exceptions import IdentityNotValid
 from sentry.integrations.models.repository_project_path_config import RepositoryProjectPathConfig
 from sentry.integrations.source_code_management.metrics import (
+    CommitContextHaltReason,
     SCMIntegrationInteractionEvent,
     SCMIntegrationInteractionType,
 )
@@ -140,114 +141,140 @@ def queue_comment_task_if_needed(
         group_owner: GroupOwner,
         group_id: int,
     ) -> None:
-        if not OrganizationOption.objects.get_value(
-            organization=project.organization,
-            key="sentry:github_pr_bot",
-            default=True,
-        ):
-            logger.info(
-                _pr_comment_log(integration_name=self.integration_name, suffix="disabled"),
-                extra={"organization_id": project.organization_id},
-            )
-            return
-
-        repo_query = Repository.objects.filter(id=commit.repository_id).order_by("-date_added")
-        group = Group.objects.get_from_cache(id=group_id)
-        if not (
-            group.level is not logging.INFO and repo_query.exists()
-        ):  # Don't comment on info level issues
-            logger.info(
-                _pr_comment_log(
-                    integration_name=self.integration_name, suffix="incorrect_repo_config"
-                ),
-                extra={"organization_id": project.organization_id},
-            )
-            return
-
-        repo: Repository = repo_query.get()
-
-        logger.info(
-            _pr_comment_log(integration_name=self.integration_name, suffix="queue_comment_check"),
-            extra={"organization_id": commit.organization_id, "merge_commit_sha": commit.key},
-        )
-        from sentry.integrations.github.tasks.pr_comment import github_comment_workflow
-
-        # client will raise an Exception if the request is not successful
-        try:
-            client = self.get_client()
-            merge_commit_sha = client.get_merge_commit_sha_from_commit(
-                repo=repo.name, sha=commit.key
+        with self.record_event(
+            SCMIntegrationInteractionType.QUEUE_COMMENT_TASK
+        ).capture() as lifecycle:
+            lifecycle.add_extras(
+                {
+                    "project_id": project.id,
+                    "organization_id": project.organization_id,
+                    "commit_id": commit.id,
+                }
             )
-        except Exception as e:
-            sentry_sdk.capture_exception(e)
-            return
+            if not OrganizationOption.objects.get_value(
+                organization=project.organization,
+                key="sentry:github_pr_bot",
+                default=True,
+            ):
+                # TODO: remove logger in favor of the log recorded in  lifecycle.record_halt
+                logger.info(
+                    _pr_comment_log(integration_name=self.integration_name, suffix="disabled"),
+                    extra={"organization_id": project.organization_id},
+                )
+                lifecycle.record_halt(CommitContextHaltReason.PR_BOT_DISABLED)
+                return
+
+            repo_query = Repository.objects.filter(id=commit.repository_id).order_by("-date_added")
+            group = Group.objects.get_from_cache(id=group_id)
+            if not (
+                group.level is not logging.INFO and repo_query.exists()
+            ):  # Don't comment on info level issues
+                logger.info(
+                    _pr_comment_log(
+                        integration_name=self.integration_name, suffix="incorrect_repo_config"
+                    ),
+                    extra={"organization_id": project.organization_id},
+                )
+                lifecycle.record_halt(CommitContextHaltReason.INCORRECT_REPO_CONFIG)
+                return
 
-        if merge_commit_sha is None:
-            logger.info(
-                _pr_comment_log(
-                    integration_name=self.integration_name,
-                    suffix="queue_comment_workflow.commit_not_in_default_branch",
-                ),
-                extra={
-                    "organization_id": commit.organization_id,
-                    "repository_id": repo.id,
-                    "commit_sha": commit.key,
-                },
-            )
-            return
+            repo: Repository = repo_query.get()
+            lifecycle.add_extra("repository_id", repo.id)
 
-        pr_query = PullRequest.objects.filter(
-            organization_id=commit.organization_id,
-            repository_id=commit.repository_id,
-            merge_commit_sha=merge_commit_sha,
-        )
-        if not pr_query.exists():
             logger.info(
                 _pr_comment_log(
-                    integration_name=self.integration_name,
-                    suffix="queue_comment_workflow.missing_pr",
+                    integration_name=self.integration_name, suffix="queue_comment_check"
                 ),
-                extra={
-                    "organization_id": commit.organization_id,
-                    "repository_id": repo.id,
-                    "commit_sha": commit.key,
-                },
+                extra={"organization_id": commit.organization_id, "merge_commit_sha": commit.key},
             )
-            return
+            scope = sentry_sdk.Scope.get_isolation_scope()
+            scope.set_tag("queue_comment_check.merge_commit_sha", commit.key)
+            scope.set_tag("queue_comment_check.organization_id", commit.organization_id)
+            from sentry.integrations.github.tasks.pr_comment import github_comment_workflow
 
-        pr = pr_query.first()
-        assert pr is not None
-        # need to query explicitly for merged PR comments since we can have multiple comments per PR
-        merged_pr_comment_query = PullRequestComment.objects.filter(
-            pull_request_id=pr.id, comment_type=CommentType.MERGED_PR
-        )
-        if pr.date_added >= datetime.now(tz=timezone.utc) - timedelta(days=PR_COMMENT_WINDOW) and (
-            not merged_pr_comment_query.exists()
-            or group_owner.group_id not in merged_pr_comment_query[0].group_ids
-        ):
-            lock = locks.get(
-                _debounce_pr_comment_lock_key(pr.id), duration=10, name="queue_comment_task"
-            )
-            with lock.acquire():
-                cache_key = _debounce_pr_comment_cache_key(pullrequest_id=pr.id)
-                if cache.get(cache_key) is not None:
-                    return
+            # client will raise an Exception if the request is not successful
+            try:
+                client = self.get_client()
+                merge_commit_sha = client.get_merge_commit_sha_from_commit(
+                    repo=repo.name, sha=commit.key
+                )
+            except Exception as e:
+                sentry_sdk.capture_exception(e)
+                lifecycle.record_halt(e)
+                return
 
-                # create PR commit row for suspect commit and PR
-                PullRequestCommit.objects.get_or_create(commit=commit, pull_request=pr)
+            if merge_commit_sha is None:
+                logger.info(
+                    _pr_comment_log(
+                        integration_name=self.integration_name,
+                        suffix="queue_comment_workflow.commit_not_in_default_branch",
+                    ),
+                    extra={
+                        "organization_id": commit.organization_id,
+                        "repository_id": repo.id,
+                        "commit_sha": commit.key,
+                    },
+                )
+                lifecycle.record_halt(CommitContextHaltReason.COMMIT_NOT_IN_DEFAULT_BRANCH)
+                return
 
+            pr_query = PullRequest.objects.filter(
+                organization_id=commit.organization_id,
+                repository_id=commit.repository_id,
+                merge_commit_sha=merge_commit_sha,
+            )
+            if not pr_query.exists():
                 logger.info(
                     _pr_comment_log(
-                        integration_name=self.integration_name, suffix="queue_comment_workflow"
+                        integration_name=self.integration_name,
+                        suffix="queue_comment_workflow.missing_pr",
                     ),
-                    extra={"pullrequest_id": pr.id, "project_id": group_owner.project_id},
+                    extra={
+                        "organization_id": commit.organization_id,
+                        "repository_id": repo.id,
+                        "commit_sha": commit.key,
+                    },
+                )
+                lifecycle.record_halt(CommitContextHaltReason.MISSING_PR)
+                return
+
+            pr = pr_query.first()
+            lifecycle.add_extra("pull_request_id", pr.id)
+            assert pr is not None
+            # need to query explicitly for merged PR comments since we can have multiple comments per PR
+            merged_pr_comment_query = PullRequestComment.objects.filter(
+                pull_request_id=pr.id, comment_type=CommentType.MERGED_PR
+            )
+            if pr.date_added >= datetime.now(tz=timezone.utc) - timedelta(
+                days=PR_COMMENT_WINDOW
+            ) and (
+                not merged_pr_comment_query.exists()
+                or group_owner.group_id not in merged_pr_comment_query[0].group_ids
+            ):
+                lock = locks.get(
+                    _debounce_pr_comment_lock_key(pr.id), duration=10, name="queue_comment_task"
                 )
+                with lock.acquire():
+                    cache_key = _debounce_pr_comment_cache_key(pullrequest_id=pr.id)
+                    if cache.get(cache_key) is not None:
+                        lifecycle.record_halt(CommitContextHaltReason.ALREADY_QUEUED)
+                        return
 
-                cache.set(cache_key, True, PR_COMMENT_TASK_TTL)
+                    # create PR commit row for suspect commit and PR
+                    PullRequestCommit.objects.get_or_create(commit=commit, pull_request=pr)
 
-                github_comment_workflow.delay(
-                    pullrequest_id=pr.id, project_id=group_owner.project_id
-                )
+                    logger.info(
+                        _pr_comment_log(
+                            integration_name=self.integration_name, suffix="queue_comment_workflow"
+                        ),
+                        extra={"pullrequest_id": pr.id, "project_id": group_owner.project_id},
+                    )
+
+                    cache.set(cache_key, True, PR_COMMENT_TASK_TTL)
+
+                    github_comment_workflow.delay(
+                        pullrequest_id=pr.id, project_id=group_owner.project_id
+                    )
 
     def create_or_update_comment(
         self,
@@ -268,70 +295,86 @@ def create_or_update_comment(
         )
         pr_comment = pr_comment_query[0] if pr_comment_query.exists() else None
 
-        # client will raise ApiError if the request is not successful
-        if pr_comment is None:
-            resp = client.create_comment(
-                repo=repo.name,
-                issue_id=str(pr_key),
-                data=(
-                    {
-                        "body": comment_body,
-                        "actions": github_copilot_actions,
-                    }
-                    if github_copilot_actions
-                    else {"body": comment_body}
-                ),
-            )
+        interaction_type = (
+            SCMIntegrationInteractionType.CREATE_COMMENT
+            if not pr_comment
+            else SCMIntegrationInteractionType.UPDATE_COMMENT
+        )
 
-            current_time = django_timezone.now()
-            comment = PullRequestComment.objects.create(
-                external_id=resp.body["id"],
-                pull_request_id=pullrequest_id,
-                created_at=current_time,
-                updated_at=current_time,
-                group_ids=issue_list,
-                comment_type=comment_type,
-            )
-            metrics.incr(
-                metrics_base.format(integration=self.integration_name, key="comment_created")
+        with self.record_event(interaction_type).capture() as lifecycle:
+            lifecycle.add_extras(
+                {
+                    "repository_id": repo.id,
+                    "organization_id": repo.organization_id,
+                    "pull_request_id": pullrequest_id,
+                    "comment_type": comment_type,
+                    "language": language,
+                }
             )
 
-            if comment_type == CommentType.OPEN_PR:
-                analytics.record(
-                    "open_pr_comment.created",
-                    comment_id=comment.id,
-                    org_id=repo.organization_id,
-                    pr_id=pullrequest_id,
-                    language=(language or "not found"),
+            if pr_comment is None:
+                resp = client.create_comment(
+                    repo=repo.name,
+                    issue_id=str(pr_key),
+                    data=(
+                        {
+                            "body": comment_body,
+                            "actions": github_copilot_actions,
+                        }
+                        if github_copilot_actions
+                        else {"body": comment_body}
+                    ),
                 )
-        else:
-            resp = client.update_comment(
-                repo=repo.name,
-                issue_id=str(pr_key),
-                comment_id=pr_comment.external_id,
-                data=(
-                    {
-                        "body": comment_body,
-                        "actions": github_copilot_actions,
-                    }
-                    if github_copilot_actions
-                    else {"body": comment_body}
-                ),
+
+                current_time = django_timezone.now()
+                comment = PullRequestComment.objects.create(
+                    external_id=resp.body["id"],
+                    pull_request_id=pullrequest_id,
+                    created_at=current_time,
+                    updated_at=current_time,
+                    group_ids=issue_list,
+                    comment_type=comment_type,
+                )
+                metrics.incr(
+                    metrics_base.format(integration=self.integration_name, key="comment_created")
+                )
+
+                if comment_type == CommentType.OPEN_PR:
+                    analytics.record(
+                        "open_pr_comment.created",
+                        comment_id=comment.id,
+                        org_id=repo.organization_id,
+                        pr_id=pullrequest_id,
+                        language=(language or "not found"),
+                    )
+            else:
+                resp = client.update_comment(
+                    repo=repo.name,
+                    issue_id=str(pr_key),
+                    comment_id=pr_comment.external_id,
+                    data=(
+                        {
+                            "body": comment_body,
+                            "actions": github_copilot_actions,
+                        }
+                        if github_copilot_actions
+                        else {"body": comment_body}
+                    ),
+                )
+                metrics.incr(
+                    metrics_base.format(integration=self.integration_name, key="comment_updated")
+                )
+                pr_comment.updated_at = django_timezone.now()
+                pr_comment.group_ids = issue_list
+                pr_comment.save()
+
+            logger_event = metrics_base.format(
+                integration=self.integration_name, key="create_or_update_comment"
             )
-            metrics.incr(
-                metrics_base.format(integration=self.integration_name, key="comment_updated")
+            logger.info(
+                logger_event,
+                extra={"new_comment": pr_comment is None, "pr_key": pr_key, "repo": repo.name},
             )
-            pr_comment.updated_at = django_timezone.now()
-            pr_comment.group_ids = issue_list
-            pr_comment.save()
-
-        logger_event = metrics_base.format(
-            integration=self.integration_name, key="create_or_update_comment"
-        )
-        logger.info(
-            logger_event,
-            extra={"new_comment": pr_comment is None, "pr_key": pr_key, "repo": repo.name},
-        )
 
 
 class CommitContextClient(ABC):
diff --git a/src/sentry/integrations/source_code_management/metrics.py b/src/sentry/integrations/source_code_management/metrics.py
@@ -74,3 +74,13 @@ class LinkAllReposHaltReason(StrEnum):
     MISSING_ORGANIZATION = "missing_organization"
     RATE_LIMITED = "rate_limited"
     REPOSITORY_NOT_CREATED = "repository_not_created"
+
+
+class CommitContextHaltReason(StrEnum):
+    """Common reasons why a commit context integration may halt without success/failure."""
+
+    PR_BOT_DISABLED = "pr_bot_disabled"
+    INCORRECT_REPO_CONFIG = "incorrect_repo_config"
+    COMMIT_NOT_IN_DEFAULT_BRANCH = "commit_not_in_default_branch"
+    MISSING_PR = "missing_pr"
+    ALREADY_QUEUED = "already_queued"
diff --git a/src/sentry/integrations/utils/metrics.py b/src/sentry/integrations/utils/metrics.py
