chore: import upstream snapshot with attribution

sdks/python/tests/unit/error_tracking/error_filtering/conftest.py

@@ -0,0 +1,50 @@
+import pytest
+from typing import Dict, Any
+
+
+def _generate_hint(error) -> Dict[str, Any]:
+    return {"exc_info": (None, error, None)}
+
+
+class FakeException(Exception):
+    pass
+
+
+class FakeExceptionWithStatus:
+    def __init__(self, status_code):
+        self.status_code = status_code
+
+
+@pytest.fixture
+def fake_warning_event():
+    return {"level": "warning"}
+
+
+@pytest.fixture
+def fake_error_event():
+    return {"level": "error"}
+
+
+@pytest.fixture
+def fake_error_event_with_status_code_401():
+    return {"level": "error", "extra": {"error_tracking_extra": {"status_code": 401}}}
+
+
+@pytest.fixture
+def fake_error_event_with_status_code_500():
+    return {"level": "error", "extra": {"error_tracking_extra": {"status_code": 500}}}
+
+
+@pytest.fixture
+def fake_basic_hint():
+    return _generate_hint(FakeException())
+
+
+@pytest.fixture
+def fake_hint_with_exception_with_status_code_401():
+    return _generate_hint(FakeExceptionWithStatus(401))
+
+
+@pytest.fixture
+def fake_hint_with_exception_with_status_code_500():
+    return _generate_hint(FakeExceptionWithStatus(500))

sdks/python/tests/unit/error_tracking/error_filtering/test_error_level_count_filters.py

@@ -0,0 +1,31 @@
+from opik.error_tracking.error_filtering import filter_by_count
+
+import pytest
+
+
+@pytest.mark.parametrize("max_count", [0, 1, 10])
+def test_filter_by_count__errors(
+    max_count, fake_warning_event, fake_error_event, fake_basic_hint
+):
+    tested = filter_by_count.FilterByCount(max_count=max_count, level="error")
+
+    for _ in range(max_count):
+        assert tested.process_event(fake_error_event, fake_basic_hint) is True
+
+    assert tested.process_event(fake_error_event, fake_basic_hint) is False
+    # should be neutral about warnings
+    assert tested.process_event(fake_warning_event, fake_basic_hint) is True
+
+
+@pytest.mark.parametrize("max_count", [0, 1, 10])
+def test_filter_by_count__warning(
+    max_count, fake_warning_event, fake_error_event, fake_basic_hint
+):
+    tested = filter_by_count.FilterByCount(max_count=max_count, level="warning")
+
+    for _ in range(max_count):
+        assert tested.process_event(fake_warning_event, fake_basic_hint) is True
+
+    assert tested.process_event(fake_warning_event, fake_basic_hint) is False
+    # should be neutral about errors
+    assert tested.process_event(fake_error_event, fake_basic_hint) is True

sdks/python/tests/unit/error_tracking/error_filtering/test_filter_by_response_status_code.py

@@ -0,0 +1,74 @@
+from opik.error_tracking.error_filtering import filter_by_response_status_code
+
+
+def test_filter_by_response_status_code__status_code_from_extra_dict__happyflows(
+    fake_basic_hint,
+    fake_error_event_with_status_code_401,
+    fake_error_event_with_status_code_500,
+):
+    tested = filter_by_response_status_code.FilterByResponseStatusCode(
+        status_codes_to_drop=[401]
+    )
+
+    assert (
+        tested.process_event(fake_error_event_with_status_code_500, fake_basic_hint)
+        is True
+    )
+
+    assert (
+        tested.process_event(fake_error_event_with_status_code_401, fake_basic_hint)
+        is False
+    )
+
+
+def test_filter_by_response_status_code__status_code_from_exception_attribute__happyflows(
+    fake_hint_with_exception_with_status_code_401,
+    fake_hint_with_exception_with_status_code_500,
+    fake_error_event,
+):
+    tested = filter_by_response_status_code.FilterByResponseStatusCode(
+        status_codes_to_drop=[401]
+    )
+
+    assert (
+        tested.process_event(
+            fake_error_event, fake_hint_with_exception_with_status_code_500
+        )
+        is True
+    )
+
+    assert (
+        tested.process_event(
+            fake_error_event, fake_hint_with_exception_with_status_code_401
+        )
+        is False
+    )
+
+
+def test_filter_by_response_status_code__cli_command_tag__bypasses_filter(
+    fake_basic_hint,
+    fake_error_event_with_status_code_401,
+):
+    tested = filter_by_response_status_code.FilterByResponseStatusCode(
+        status_codes_to_drop=[401]
+    )
+
+    event_with_cli_tag = {
+        **fake_error_event_with_status_code_401,
+        "tags": {"cli_command": "opik-connect"},
+    }
+
+    assert tested.process_event(event_with_cli_tag, fake_basic_hint) is True
+
+
+def test_filter_by_response_status_code__no_cli_command_tag__still_filters(
+    fake_basic_hint,
+    fake_error_event_with_status_code_401,
+):
+    tested = filter_by_response_status_code.FilterByResponseStatusCode(
+        status_codes_to_drop=[401]
+    )
+
+    event_without_tag = {**fake_error_event_with_status_code_401, "tags": {}}
+
+    assert tested.process_event(event_without_tag, fake_basic_hint) is False

sdks/python/tests/unit/error_tracking/error_filtering/test_filter_chain.py

@@ -0,0 +1,30 @@
+from opik.error_tracking.error_filtering import (
+    filter_chain,
+    filter_by_count,
+    event_filter,
+)
+
+
+def test_custom_filter_chain(fake_error_event, fake_basic_hint):
+    count_handler = filter_by_count.FilterByCount(max_count=1, level="error")
+
+    tested_chain = filter_chain.FilterChain([count_handler])
+
+    assert tested_chain.validate(fake_error_event, fake_basic_hint) is True
+    # because of the count = 1 should be false
+    assert tested_chain.validate(fake_error_event, fake_basic_hint) is False
+
+
+class FakeException(Exception):
+    pass
+
+
+class FilterWithExceptionInProcess(event_filter.EventFilter):
+    def process_event(self):
+        raise FakeException()
+
+
+def test_filter_chain_exception_in_process():
+    exception_handler = FilterWithExceptionInProcess()
+    chain = filter_chain.FilterChain([exception_handler])
+    assert chain.validate(None, None) is False

sdks/python/tests/unit/error_tracking/error_filtering/test_sentry_filter_chain_builder.py

@@ -0,0 +1,35 @@
+from opik.error_tracking.error_filtering import filter_chain_builder
+from opik.error_tracking import error_filtering
+
+
+def test_sentry_filter_chain(
+    fake_basic_hint,
+    fake_error_event,
+    fake_warning_event,
+):
+    for _ in range(filter_chain_builder.DEFAULT_ERROR_QUOTA):
+        assert (
+            error_filtering.sentry_filter_chain.validate(
+                fake_error_event, fake_basic_hint
+            )
+            is True
+        )
+
+    for _ in range(filter_chain_builder.DEFAULT_WARNING_QUOTA):
+        assert (
+            error_filtering.sentry_filter_chain.validate(
+                fake_warning_event, fake_basic_hint
+            )
+            is True
+        )
+
+    assert (
+        error_filtering.sentry_filter_chain.validate(fake_error_event, fake_basic_hint)
+        is False
+    )
+    assert (
+        error_filtering.sentry_filter_chain.validate(
+            fake_warning_event, fake_basic_hint
+        )
+        is False
+    )

sdks/python/tests/unit/error_tracking/test_logger_setup.py

@@ -0,0 +1,29 @@
+import logging
+
+from opik.error_tracking import logger_setup
+
+
+def test_singleton_sentry_handlers():
+    """Check that we are only adding sentry handlers once, they are using a singleton object in
+    sentry so we don't need to add them multiple time
+    """
+
+    test_logger = logging.getLogger("test_singleton_sentry_handlers")
+    base_handler = logging.StreamHandler()
+    test_logger.addHandler(base_handler)
+
+    assert len(test_logger.handlers) == 1
+
+    # Add sentry handlers, there are two of them
+    logger_setup.setup_sentry_error_handlers(test_logger)
+
+    assert len(test_logger.handlers) == 3
+    # Make sure the existing handler wasn't removed
+    assert base_handler in test_logger.handlers
+
+    # Sentry handlers are already present
+    logger_setup.setup_sentry_error_handlers(test_logger)
+
+    assert len(test_logger.handlers) == 3
+    # Make sure the existing handler wasn't removed
+    assert base_handler in test_logger.handlers