Merge branch 'master' into ivana/delayed-asynciointegration-enable

Author: sentrivana

sentry_sdk/integrations/clickhouse_driver.py

@@ -30,7 +30,9 @@ def __getitem__(self, _):
 
 
 try:
-    import clickhouse_driver  # type: ignore[import-not-found]
+    from clickhouse_driver import VERSION  # type: ignore[import-not-found]
+    from clickhouse_driver.client import Client  # type: ignore[import-not-found]
+    from clickhouse_driver.connection import Connection  # type: ignore[import-not-found]
 
 except ImportError:
     raise DidNotEnable("clickhouse-driver not installed.")
@@ -42,29 +44,23 @@ class ClickhouseDriverIntegration(Integration):
 
     @staticmethod
     def setup_once() -> None:
-        _check_minimum_version(ClickhouseDriverIntegration, clickhouse_driver.VERSION)
+        _check_minimum_version(ClickhouseDriverIntegration, VERSION)
 
         # Every query is done using the Connection's `send_query` function
-        clickhouse_driver.connection.Connection.send_query = _wrap_start(
-            clickhouse_driver.connection.Connection.send_query
-        )
+        Connection.send_query = _wrap_start(Connection.send_query)
 
         # If the query contains parameters then the send_data function is used to send those parameters to clickhouse
         _wrap_send_data()
 
         # Every query ends either with the Client's `receive_end_of_query` (no result expected)
         # or its `receive_result` (result expected)
-        clickhouse_driver.client.Client.receive_end_of_query = _wrap_end(
-            clickhouse_driver.client.Client.receive_end_of_query
-        )
-        if hasattr(clickhouse_driver.client.Client, "receive_end_of_insert_query"):
+        Client.receive_end_of_query = _wrap_end(Client.receive_end_of_query)
+        if hasattr(Client, "receive_end_of_insert_query"):
             # In 0.2.7, insert queries are handled separately via `receive_end_of_insert_query`
-            clickhouse_driver.client.Client.receive_end_of_insert_query = _wrap_end(
-                clickhouse_driver.client.Client.receive_end_of_insert_query
+            Client.receive_end_of_insert_query = _wrap_end(
+                Client.receive_end_of_insert_query
             )
-        clickhouse_driver.client.Client.receive_result = _wrap_end(
-            clickhouse_driver.client.Client.receive_result
-        )
+        Client.receive_result = _wrap_end(Client.receive_result)
 
 
 P = ParamSpec("P")
@@ -128,7 +124,7 @@ def _inner_end(*args: "P.args", **kwargs: "P.kwargs") -> "T":
 
 
 def _wrap_send_data() -> None:
-    original_send_data = clickhouse_driver.client.Client.send_data
+    original_send_data = Client.send_data
 
     def _inner_send_data(  # type: ignore[no-untyped-def] # clickhouse-driver does not type send_data
         self, sample_block, data, types_check=False, columnar=False, *args, **kwargs
@@ -164,12 +160,10 @@ def wrapped_generator() -> "Iterator[Any]":
             self, sample_block, data, types_check, columnar, *args, **kwargs
         )
 
-    clickhouse_driver.client.Client.send_data = _inner_send_data
+    Client.send_data = _inner_send_data
 
 
-def _set_db_data(
-    span: "Span", connection: "clickhouse_driver.connection.Connection"
-) -> None:
+def _set_db_data(span: "Span", connection: "Connection") -> None:
     span.set_data(SPANDATA.DB_SYSTEM, "clickhouse")
     span.set_data(SPANDATA.SERVER_ADDRESS, connection.host)
     span.set_data(SPANDATA.SERVER_PORT, connection.port)

sentry_sdk/integrations/gql.py

@@ -95,18 +95,23 @@ def _request_info_from_transport(
 def _patch_execute() -> None:
     real_execute = gql.Client.execute
 
+    # Maintain signature for backwards compatibility.
+    # gql.Client.execute() accepts a positional-only "request"
+    # parameter with version 4.0.0.
     @ensure_integration_enabled(GQLIntegration, real_execute)
     def sentry_patched_execute(
         self: "gql.Client",
-        document_or_request: "DocumentNode",
+        document: "DocumentNode",
         *args: "Any",
         **kwargs: "Any",
     ) -> "Any":
         scope = sentry_sdk.get_isolation_scope()
-        scope.add_event_processor(_make_gql_event_processor(self, document_or_request))
+        # document is a gql.GraphQLRequest with gql v4.0.0.
+        scope.add_event_processor(_make_gql_event_processor(self, document))
 
         try:
-            return real_execute(self, document_or_request, *args, **kwargs)
+            # document is a gql.GraphQLRequest with gql v4.0.0.
+            return real_execute(self, document, *args, **kwargs)
         except TransportQueryError as e:
             event, hint = event_from_exception(
                 e,

sentry_sdk/integrations/litellm.py

@@ -19,6 +19,7 @@
 
 try:
     import litellm  # type: ignore[import-not-found]
+    from litellm import input_callback, success_callback, failure_callback
 except ImportError:
     raise DidNotEnable("LiteLLM not installed")
 
@@ -278,14 +279,14 @@ def __init__(self: "LiteLLMIntegration", include_prompts: bool = True) -> None:
     @staticmethod
     def setup_once() -> None:
         """Set up LiteLLM callbacks for monitoring."""
-        litellm.input_callback = litellm.input_callback or []
+        litellm.input_callback = input_callback or []
         if _input_callback not in litellm.input_callback:
             litellm.input_callback.append(_input_callback)
 
-        litellm.success_callback = litellm.success_callback or []
+        litellm.success_callback = success_callback or []
         if _success_callback not in litellm.success_callback:
             litellm.success_callback.append(_success_callback)
 
-        litellm.failure_callback = litellm.failure_callback or []
+        litellm.failure_callback = failure_callback or []
         if _failure_callback not in litellm.failure_callback:
             litellm.failure_callback.append(_failure_callback)

sentry_sdk/integrations/pure_eval.py

@@ -15,12 +15,12 @@
     from sentry_sdk._types import Event, Hint
 
 try:
-    import executing
+    from executing import Source
 except ImportError:
     raise DidNotEnable("executing is not installed")
 
 try:
-    import pure_eval
+    from pure_eval import Evaluator
 except ImportError:
     raise DidNotEnable("pure_eval is not installed")
 
@@ -81,7 +81,7 @@ def add_executing_info(
 
 
 def pure_eval_frame(frame: "FrameType") -> "Dict[str, Any]":
-    source = executing.Source.for_frame(frame)
+    source = Source.for_frame(frame)
     if not source.tree:
         return {}
 
@@ -98,7 +98,7 @@ def pure_eval_frame(frame: "FrameType") -> "Dict[str, Any]":
         if isinstance(scope, (ast.FunctionDef, ast.ClassDef, ast.Module)):
             break
 
-    evaluator = pure_eval.Evaluator.from_frame(frame)
+    evaluator = Evaluator.from_frame(frame)
     expressions = evaluator.interesting_expressions_grouped(scope)
 
     def closeness(expression: "Tuple[List[Any], Any]") -> "Tuple[int, int]":

sentry_sdk/integrations/ray.py

@@ -16,6 +16,7 @@
 
 try:
     import ray  # type: ignore[import-not-found]
+    from ray import remote
 except ImportError:
     raise DidNotEnable("Ray not installed.")
 
@@ -57,7 +58,7 @@ def _insert_sentry_tracing_in_signature(func: "Callable[..., Any]") -> None:
 
 
 def _patch_ray_remote() -> None:
-    old_remote = ray.remote
+    old_remote = remote
 
     @functools.wraps(old_remote)
     def new_remote(

sentry_sdk/integrations/typer.py

@@ -22,6 +22,7 @@
 
 try:
     import typer
+    from typer.main import except_hook
 except ImportError:
     raise DidNotEnable("Typer not installed")
 
@@ -31,7 +32,7 @@ class TyperIntegration(Integration):
 
     @staticmethod
     def setup_once() -> None:
-        typer.main.except_hook = _make_excepthook(typer.main.except_hook)  # type: ignore
+        typer.main.except_hook = _make_excepthook(except_hook)  # type: ignore
 
 
 def _make_excepthook(old_excepthook: "Excepthook") -> "Excepthook":

tests/integrations/gql/test_gql.py

@@ -3,9 +3,13 @@
 import responses
 from gql import gql
 from gql import Client
+from gql import __version__
 from gql.transport.exceptions import TransportQueryError
 from gql.transport.requests import RequestsHTTPTransport
 from sentry_sdk.integrations.gql import GQLIntegration
+from sentry_sdk.utils import parse_version
+
+GQL_VERSION = parse_version(__version__)
 
 
 @responses.activate
@@ -32,7 +36,36 @@ def _execute_mock_query(response_json):
     return client.execute(query)
 
 
-def _make_erroneous_query(capture_events):
+@responses.activate
+def _execute_mock_query_with_keyword_document(response_json):
+    url = "http://example.com/graphql"
+    query_string = """
+        query Example {
+            example
+        }
+    """
+
+    # Mock the GraphQL server response
+    responses.add(
+        method=responses.POST,
+        url=url,
+        json=response_json,
+        status=200,
+    )
+
+    transport = RequestsHTTPTransport(url=url)
+    client = Client(transport=transport)
+    query = gql(query_string)
+
+    return client.execute(document=query)
+
+
+_execute_query_funcs = [_execute_mock_query]
+if GQL_VERSION < (4,):
+    _execute_query_funcs.append(_execute_mock_query_with_keyword_document)
+
+
+def _make_erroneous_query(capture_events, execute_query):
     """
     Make an erroneous GraphQL query, and assert that the error was reraised, that
     exactly one event was recorded, and that the exception recorded was a
@@ -42,7 +75,7 @@ def _make_erroneous_query(capture_events):
     response_json = {"errors": ["something bad happened"]}
 
     with pytest.raises(TransportQueryError):
-        _execute_mock_query(response_json)
+        execute_query(response_json)
 
     assert len(events) == 1, (
         "the sdk captured %d events, but 1 event was expected" % len(events)
@@ -67,7 +100,8 @@ def test_gql_init(sentry_init):
     sentry_init(integrations=[GQLIntegration()])
 
 
-def test_real_gql_request_no_error(sentry_init, capture_events):
+@pytest.mark.parametrize("execute_query", _execute_query_funcs)
+def test_real_gql_request_no_error(sentry_init, capture_events, execute_query):
     """
     Integration test verifying that the GQLIntegration works as expected with successful query.
     """
@@ -77,7 +111,7 @@ def test_real_gql_request_no_error(sentry_init, capture_events):
     response_data = {"example": "This is the example"}
     response_json = {"data": response_data}
 
-    result = _execute_mock_query(response_json)
+    result = execute_query(response_json)
 
     assert result == response_data, (
         "client.execute returned a different value from what it received from the server"
@@ -87,27 +121,31 @@ def test_real_gql_request_no_error(sentry_init, capture_events):
     )
 
 
-def test_real_gql_request_with_error_no_pii(sentry_init, capture_events):
+@pytest.mark.parametrize("execute_query", _execute_query_funcs)
+def test_real_gql_request_with_error_no_pii(sentry_init, capture_events, execute_query):
     """
     Integration test verifying that the GQLIntegration works as expected with query resulting
     in a GraphQL error, and that PII is not sent.
     """
     sentry_init(integrations=[GQLIntegration()])
 
-    event = _make_erroneous_query(capture_events)
+    event = _make_erroneous_query(capture_events, execute_query)
 
     assert "data" not in event["request"]
     assert "response" not in event["contexts"]
 
 
-def test_real_gql_request_with_error_with_pii(sentry_init, capture_events):
+@pytest.mark.parametrize("execute_query", _execute_query_funcs)
+def test_real_gql_request_with_error_with_pii(
+    sentry_init, capture_events, execute_query
+):
     """
     Integration test verifying that the GQLIntegration works as expected with query resulting
     in a GraphQL error, and that PII is not sent.
     """
     sentry_init(integrations=[GQLIntegration()], send_default_pii=True)
 
-    event = _make_erroneous_query(capture_events)
+    event = _make_erroneous_query(capture_events, execute_query)
 
     assert "data" in event["request"]
     assert "response" in event["contexts"]

tests/test_shadowed_module.py

@@ -26,15 +26,7 @@ def pytest_generate_tests(metafunc):
 
         metafunc.parametrize(
             "integration_submodule_name",
-            # Temporarily skip some integrations
-            submodule_names
-            - {
-                "clickhouse_driver",
-                "litellm",
-                "pure_eval",
-                "ray",
-                "typer",
-            },
+            submodule_names,
         )