feat(feedback): spam detection (#69169)

JoshFerge · MichaelSun48 · commit 280db3e91b12 · 2024-04-24T17:58:25.000-07:00
- Adds llm based spam detection field to issue evidence if the algorithm
returns that the message is spam. behind a feature flag.
diff --git a/src/sentry/feedback/usecases/create_feedback.py b/src/sentry/feedback/usecases/create_feedback.py
@@ -8,8 +8,10 @@
 
 import jsonschema
 
+from sentry import features
 from sentry.constants import DataCategory
 from sentry.eventstore.models import Event
+from sentry.feedback.usecases.spam_detection import is_spam
 from sentry.issues.grouptype import FeedbackGroup
 from sentry.issues.issue_occurrence import IssueEvidence, IssueOccurrence
 from sentry.issues.json_schemas import EVENT_PAYLOAD_SCHEMA, LEGACY_EVENT_PAYLOAD_SCHEMA
@@ -54,7 +56,7 @@ def old_feedback_category_values(cls) -> set[str]:
         }
 
 
-def make_evidence(feedback, source: FeedbackCreationSource):
+def make_evidence(feedback, source: FeedbackCreationSource, is_message_spam: bool | None):
     evidence_data = {}
     evidence_display = []
     if feedback.get("contact_email"):
@@ -74,6 +76,12 @@ def make_evidence(feedback, source: FeedbackCreationSource):
     evidence_data["source"] = source.value
     evidence_display.append(IssueEvidence(name="source", value=source.value, important=False))
 
+    if is_message_spam is True:
+        evidence_data["is_spam"] = str(is_message_spam)
+        evidence_display.append(
+            IssueEvidence(name="is_spam", value=str(is_message_spam), important=False)
+        )
+
     return evidence_data, evidence_display
 
 
@@ -169,11 +177,23 @@ def create_feedback_issue(event, project_id, source: FeedbackCreationSource):
     if should_filter_feedback(event, project_id, source):
         return
 
+    project = Project.objects.get_from_cache(id=project_id)
+
+    is_message_spam = None
+    if features.has("organizations:user-feedback-spam-filter-ingest", project.organization):
+        try:
+            is_message_spam = is_spam(event["contexts"]["feedback"]["message"])
+        except Exception:
+            # until we have LLM error types ironed out, just catch all exceptions
+            logger.exception("Error checking if message is spam")
+
     # Note that some of the fields below like title and subtitle
     # are not used by the feedback UI, but are required.
     event["event_id"] = event.get("event_id") or uuid4().hex
     detection_time = datetime.fromtimestamp(event["timestamp"], UTC)
-    evidence_data, evidence_display = make_evidence(event["contexts"]["feedback"], source)
+    evidence_data, evidence_display = make_evidence(
+        event["contexts"]["feedback"], source, is_message_spam
+    )
     occurrence = IssueOccurrence(
         id=uuid4().hex,
         event_id=event.get("event_id") or uuid4().hex,
@@ -204,8 +224,6 @@ def create_feedback_issue(event, project_id, source: FeedbackCreationSource):
     # make sure event data is valid for issue platform
     validate_issue_platform_event_schema(event_fixed)
 
-    project = Project.objects.get_from_cache(id=project_id)
-
     if not project.flags.has_feedbacks:
         first_feedback_received.send_robust(project=project, sender=Project)
 
diff --git a/src/sentry/feedback/usecases/spam_detection.py b/src/sentry/feedback/usecases/spam_detection.py
@@ -0,0 +1,27 @@
+import logging
+
+from sentry.llm.usecases import LLMUseCase, complete_prompt
+from sentry.utils import metrics
+
+logger = logging.getLogger(__name__)
+
+PROMPT = """Classify the text into one of the following two classes: [Junk, Not Junk]. Choose Junk only if you are confident. Text: """
+
+
+@metrics.wraps("feedback.spam_detection", sample_rate=1.0)
+def is_spam(message):
+    is_spam = False
+    response = complete_prompt(usecase=LLMUseCase.SPAM_DETECTION, prompt=PROMPT, message=message)
+    if response and response.lower() == "junk":
+        is_spam = True
+
+    logger.info(
+        "Spam detection",
+        extra={
+            "feedback_message": message,
+            "is_spam": is_spam,
+            "response": response,
+        },
+    )
+    metrics.incr("spam-detection", tags={"is_spam": is_spam}, sample_rate=1.0)
+    return is_spam
diff --git a/src/sentry/llm/usecases/__init__.py b/src/sentry/llm/usecases/__init__.py
@@ -18,6 +18,7 @@
 class LLMUseCase(Enum):
     EXAMPLE = "example"  # used in tests / examples
     SUGGESTED_FIX = "suggestedfix"  # OG version of suggested fix
+    SPAM_DETECTION = "spamdetection"
 
 
 llm_provider_backends: dict[str, LlmModelBase] = {}
diff --git a/tests/sentry/feedback/usecases/test_create_feedback.py b/tests/sentry/feedback/usecases/test_create_feedback.py
@@ -1,16 +1,20 @@
 from __future__ import annotations
 
+import time
 from typing import Any
 from unittest.mock import Mock
 
 import pytest
+from openai.types.chat.chat_completion import ChatCompletion, Choice
+from openai.types.chat.chat_completion_message import ChatCompletionMessage
 
 from sentry.feedback.usecases.create_feedback import (
     FeedbackCreationSource,
     create_feedback_issue,
     fix_for_issue_platform,
     validate_issue_platform_event_schema,
 )
+from sentry.testutils.helpers import Feature
 from sentry.testutils.pytest.fixtures import django_db_all
 
 
@@ -23,6 +27,21 @@ def mock_produce_occurrence_to_kafka(monkeypatch):
     return mock
 
 
+@pytest.fixture(autouse=True)
+def llm_settings(set_sentry_option):
+    with (
+        set_sentry_option(
+            "llm.provider.options",
+            {"openai": {"models": ["gpt-4-turbo-1.0"], "options": {"api_key": "fake_api_key"}}},
+        ),
+        set_sentry_option(
+            "llm.usecases.options",
+            {"spamdetection": {"provider": "openai", "options": {"model": "gpt-4-turbo-1.0"}}},
+        ),
+    ):
+        yield
+
+
 def test_fix_for_issue_platform():
     event: dict[str, Any] = {
         "project_id": 1,
@@ -421,3 +440,100 @@ def test_create_feedback_filters_no_contexts_or_message(
     )
 
     assert mock_produce_occurrence_to_kafka.call_count == 0
+
+
+@django_db_all
+@pytest.mark.parametrize(
+    "input_message, expected_result, feature_flag",
+    [
+        ("This is definitely spam", "True", True),
+        ("Valid feedback message", None, True),
+        ("This is definitely spam", None, False),
+        ("Valid feedback message", None, False),
+    ],
+)
+def test_create_feedback_spam_detection_adds_field(
+    default_project,
+    mock_produce_occurrence_to_kafka,
+    input_message,
+    expected_result,
+    monkeypatch,
+    feature_flag,
+):
+    with Feature({"organizations:user-feedback-spam-filter-ingest": feature_flag}):
+        event = {
+            "project_id": default_project.id,
+            "request": {
+                "url": "https://sentry.sentry.io/feedback/?statsPeriod=14d",
+                "headers": {
+                    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36"
+                },
+            },
+            "event_id": "56b08cf7852c42cbb95e4a6998c66ad6",
+            "timestamp": 1698255009.574,
+            "received": "2021-10-24T22:23:29.574000+00:00",
+            "environment": "prod",
+            "release": "frontend@daf1316f209d961443664cd6eb4231ca154db502",
+            "user": {
+                "ip_address": "72.164.175.154",
+                "email": "josh.ferge@sentry.io",
+                "id": 880461,
+                "isStaff": False,
+                "name": "Josh Ferge",
+            },
+            "contexts": {
+                "feedback": {
+                    "contact_email": "josh.ferge@sentry.io",
+                    "name": "Josh Ferge",
+                    "message": input_message,
+                    "replay_id": "3d621c61593c4ff9b43f8490a78ae18e",
+                    "url": "https://sentry.sentry.io/feedback/?statsPeriod=14d",
+                },
+            },
+            "breadcrumbs": [],
+            "platform": "javascript",
+        }
+
+        def dummy_response(*args, **kwargs):
+            return ChatCompletion(
+                id="test",
+                choices=[
+                    Choice(
+                        index=0,
+                        message=ChatCompletionMessage(
+                            content=(
+                                "Junk"
+                                if kwargs["messages"][1]["content"] == "This is definitely spam"
+                                else "Not Junk"
+                            ),
+                            role="assistant",
+                        ),
+                        finish_reason="stop",
+                    )
+                ],
+                created=time.time(),
+                model="gpt3.5-trubo",
+                object="chat.completion",
+            )
+
+        mock_openai = Mock()
+        mock_openai().chat.completions.create = dummy_response
+
+        monkeypatch.setattr("sentry.llm.providers.openai.OpenAI", mock_openai)
+
+        create_feedback_issue(
+            event, default_project.id, FeedbackCreationSource.NEW_FEEDBACK_ENVELOPE
+        )
+
+        # Check if the 'is_spam' evidence in the Kafka message matches the expected result
+        is_spam_evidence = [
+            evidence.value
+            for evidence in mock_produce_occurrence_to_kafka.call_args.kwargs[
+                "occurrence"
+            ].evidence_display
+            if evidence.name == "is_spam"
+        ]
+        found_is_spam = is_spam_evidence[0] if is_spam_evidence else None
+        assert (
+            found_is_spam == expected_result
+        ), f"Expected {expected_result} but found {found_is_spam} for {input_message} and feature flag {feature_flag}"
