chore: make logger action reporting optional

structlog_sentry/__init__.py

@@ -1,9 +1,11 @@
 import logging
 import sys
-from typing import List, Optional, Tuple, Union, Set, Iterable
+from typing import Iterable, List, Optional, Set, Tuple, Union
 
 from sentry_sdk import capture_event
-from sentry_sdk.integrations.logging import ignore_logger as logging_int_ignore_logger
+from sentry_sdk.integrations.logging import (
+    ignore_logger as logging_int_ignore_logger,
+)
 from sentry_sdk.utils import event_from_exception
 
 
@@ -20,6 +22,7 @@ def __init__(
         as_extra: bool = True,
         tag_keys: Union[List[str], str] = None,
         ignore_loggers: Optional[Iterable[str]] = None,
+        verbose: bool = False,
     ) -> None:
         """
         :param level: events of this or higher levels will be reported to Sentry.
@@ -29,13 +32,16 @@ def __init__(
             the key and its corresponding value in `event_dict` will be used as Sentry
             event tags. use `"__all__"` to report all key/value pairs of event as tags.
         :param ignore_loggers: a list of logger names to ignore any events from.
+        :param verbose: report the action taken by the logger in the `event_dict`.
         """
         self.level = level
         self.active = active
         self.tag_keys = tag_keys
         self._as_extra = as_extra
         self._original_event_dict = None
         self._ignored_loggers: Set[str] = set()
+        self.verbose = verbose
+
         if ignore_loggers is not None:
             self._ignored_loggers.update(set(ignore_loggers))
 
@@ -104,19 +110,22 @@ def __call__(self, logger, method, event_dict) -> dict:
         """A middleware to process structlog `event_dict` and send it to Sentry."""
         logger_name = self._get_logger_name(logger=logger, event_dict=event_dict)
         if logger_name in self._ignored_loggers:
-            event_dict["sentry"] = "ignored"
+            if self.verbose:
+                event_dict["sentry"] = "ignored"
             return event_dict
 
         self._original_event_dict = event_dict.copy()
         sentry_skip = event_dict.pop("sentry_skip", False)
         do_log = getattr(logging, event_dict["level"].upper()) >= self.level
 
         if sentry_skip or not self.active or not do_log:
-            event_dict["sentry"] = "skipped"
+            if self.verbose:
+                event_dict["sentry"] = "skipped"
             return event_dict
 
         sid = self._log(event_dict)
-        event_dict["sentry"] = "sent"
+        if self.verbose:
+            event_dict["sentry"] = "sent"
         event_dict["sentry_id"] = sid
 
         return event_dict

test/test_sentry_processor.py

@@ -11,19 +11,19 @@ def __init__(self, name):
 
 
 def test_sentry_disabled():
-    processor = SentryProcessor(active=False)
+    processor = SentryProcessor(active=False, verbose=True)
     event_dict = processor(None, None, {"level": "error"})
     assert event_dict.get("sentry") != "sent"
 
 
 def test_sentry_skip():
-    processor = SentryProcessor()
+    processor = SentryProcessor(verbose=True)
     event_dict = processor(None, None, {"sentry_skip": True, "level": "error"})
-    assert event_dict.get("sentry") != "sent"
+    assert event_dict.get("sentry") == "skipped"
 
 
 def test_sentry_sent():
-    processor = SentryProcessor()
+    processor = SentryProcessor(verbose=True)
     event_dict = processor(None, None, {"level": "error"})
     assert event_dict.get("sentry") == "sent"
 
@@ -268,7 +268,9 @@ def test_sentry_ignore_logger(mocker, level):
     blacklisted_logger = MockLogger("test.blacklisted")
     whitelisted_logger = MockLogger("test.whitelisted")
     processor = SentryProcessor(
-        level=getattr(logging, level.upper()), ignore_loggers=["test.blacklisted"]
+        level=getattr(logging, level.upper()),
+        ignore_loggers=["test.blacklisted"],
+        verbose=True,
     )
 
     event_data = {"level": level, "event": level + " message"}
@@ -282,7 +284,11 @@ def test_sentry_ignore_logger(mocker, level):
     )
 
     m_capture_event.assert_called_once_with(
-        {"level": level, "message": event_data["event"], "extra": sentry_event_data,},
+        {
+            "level": level,
+            "message": event_data["event"],
+            "extra": sentry_event_data,
+        },
         hint=None,
     )
     assert blacklisted_logger_event_dict.get("sentry") == "ignored"