Using render_span_tree

Author: antonpirker

tests/integrations/redis/test_redis.py

@@ -80,7 +80,7 @@ def test_redis_pipeline(
     }
 
 
-def test_sensitive_data(sentry_init, capture_events):
+def test_sensitive_data(sentry_init, capture_events, render_span_tree):
     # fakeredis does not support the AUTH command, so we need to mock it
     with mock.patch(
         "sentry_sdk.integrations.redis.utils._COMMANDS_INCLUDING_SENSITIVE_DATA",
@@ -100,12 +100,16 @@ def test_sensitive_data(sentry_init, capture_events):
             )  # because fakeredis does not support AUTH we use GET instead
 
         (event,) = events
-        spans = event["spans"]
-        assert spans[0]["op"] == "db.redis"
-        assert spans[0]["description"] == "GET [Filtered]"
+        assert (
+            render_span_tree(event)
+            == """\
+- op="": description=null
+  - op="db.redis": description="GET [Filtered]"\
+"""
+        )
 
 
-def test_pii_data_redacted(sentry_init, capture_events):
+def test_pii_data_redacted(sentry_init, capture_events, render_span_tree):
     sentry_init(
         integrations=[RedisIntegration()],
         traces_sample_rate=1.0,
@@ -120,15 +124,19 @@ def test_pii_data_redacted(sentry_init, capture_events):
         connection.delete("somekey1", "somekey2")
 
     (event,) = events
-    spans = event["spans"]
-    assert spans[0]["op"] == "db.redis"
-    assert spans[0]["description"] == "SET 'somekey1' [Filtered]"
-    assert spans[1]["description"] == "SET 'somekey2' [Filtered]"
-    assert spans[2]["description"] == "GET 'somekey2'"
-    assert spans[3]["description"] == "DEL 'somekey1' [Filtered]"
+    assert (
+        render_span_tree(event)
+        == """\
+- op="": description=null
+  - op="db.redis": description="SET 'somekey1' [Filtered]"
+  - op="db.redis": description="SET 'somekey2' [Filtered]"
+  - op="db.redis": description="GET 'somekey2'"
+  - op="db.redis": description="DEL 'somekey1' [Filtered]"\
+"""
+    )
 
 
-def test_pii_data_sent(sentry_init, capture_events):
+def test_pii_data_sent(sentry_init, capture_events, render_span_tree):
     sentry_init(
         integrations=[RedisIntegration()],
         traces_sample_rate=1.0,
@@ -144,15 +152,19 @@ def test_pii_data_sent(sentry_init, capture_events):
         connection.delete("somekey1", "somekey2")
 
     (event,) = events
-    spans = event["spans"]
-    assert spans[0]["op"] == "db.redis"
-    assert spans[0]["description"] == "SET 'somekey1' 'my secret string1'"
-    assert spans[1]["description"] == "SET 'somekey2' 'my secret string2'"
-    assert spans[2]["description"] == "GET 'somekey2'"
-    assert spans[3]["description"] == "DEL 'somekey1' 'somekey2'"
+    assert (
+        render_span_tree(event)
+        == """\
+- op="": description=null
+  - op="db.redis": description="SET 'somekey1' 'my secret string1'"
+  - op="db.redis": description="SET 'somekey2' 'my secret string2'"
+  - op="db.redis": description="GET 'somekey2'"
+  - op="db.redis": description="DEL 'somekey1' 'somekey2'"\
+"""
+    )
 
 
-def test_data_truncation(sentry_init, capture_events):
+def test_data_truncation(sentry_init, capture_events, render_span_tree):
     sentry_init(
         integrations=[RedisIntegration()],
         traces_sample_rate=1.0,
@@ -168,15 +180,17 @@ def test_data_truncation(sentry_init, capture_events):
         connection.set("somekey2", short_string)
 
     (event,) = events
-    spans = event["spans"]
-    assert spans[0]["op"] == "db.redis"
-    assert spans[0]["description"] == "SET 'somekey1' '%s..." % (
-        long_string[: 1024 - len("...") - len("SET 'somekey1' '")],
+    assert (
+        render_span_tree(event)
+        == f"""\
+- op="": description=null
+  - op="db.redis": description="SET 'somekey1' '{long_string[: 1024 - len("...") - len("SET 'somekey1' '")]}..."
+  - op="db.redis": description="SET 'somekey2' 'bbbbbbbbbb'"\
+"""
     )
-    assert spans[1]["description"] == "SET 'somekey2' '%s'" % (short_string,)
 
 
-def test_data_truncation_custom(sentry_init, capture_events):
+def test_data_truncation_custom(sentry_init, capture_events, render_span_tree):
     sentry_init(
         integrations=[RedisIntegration(max_data_size=30)],
         traces_sample_rate=1.0,
@@ -192,12 +206,14 @@ def test_data_truncation_custom(sentry_init, capture_events):
         connection.set("somekey2", short_string)
 
     (event,) = events
-    spans = event["spans"]
-    assert spans[0]["op"] == "db.redis"
-    assert spans[0]["description"] == "SET 'somekey1' '%s..." % (
-        long_string[: 30 - len("...") - len("SET 'somekey1' '")],
+    assert (
+        render_span_tree(event)
+        == f"""\
+- op="": description=null
+  - op="db.redis": description="SET 'somekey1' '{long_string[: 30 - len("...") - len("SET 'somekey1' '")]}..."
+  - op="db.redis": description="SET 'somekey2' '{short_string}'"\
+"""
     )
-    assert spans[1]["description"] == "SET 'somekey2' '%s'" % (short_string,)
 
 
 def test_breadcrumbs(sentry_init, capture_events):

tests/integrations/redis/test_redis_cache_module.py

@@ -14,7 +14,7 @@
 FAKEREDIS_VERSION = parse_version(fakeredis.__version__)
 
 
-def test_no_cache_basic(sentry_init, capture_events):
+def test_no_cache_basic(sentry_init, capture_events, render_span_tree):
     sentry_init(
         integrations=[
             RedisIntegration(),
@@ -28,12 +28,16 @@ def test_no_cache_basic(sentry_init, capture_events):
         connection.get("mycachekey")
 
     (event,) = events
-    spans = sorted(event["spans"], key=lambda x: x["start_timestamp"])
-    assert len(spans) == 1
-    assert spans[0]["op"] == "db.redis"
+    assert (
+        render_span_tree(event)
+        == """\
+- op="": description=null
+  - op="db.redis": description="GET 'mycachekey'"\
+"""
+    )
 
 
-def test_cache_basic(sentry_init, capture_events):
+def test_cache_basic(sentry_init, capture_events, render_span_tree):
     sentry_init(
         integrations=[
             RedisIntegration(
@@ -53,31 +57,25 @@ def test_cache_basic(sentry_init, capture_events):
         connection.mget("mycachekey1", "mycachekey2")
 
     (event,) = events
-    spans = sorted(event["spans"], key=lambda x: x["start_timestamp"])
-    assert len(spans) == 9
-
-    # no cache support for hget command
-    assert spans[0]["op"] == "db.redis"
-    assert spans[0]["tags"]["redis.command"] == "HGET"
-
-    assert spans[1]["op"] == "cache.get"
-    assert spans[2]["op"] == "db.redis"
-    assert spans[2]["tags"]["redis.command"] == "GET"
-
-    assert spans[3]["op"] == "cache.put"
-    assert spans[4]["op"] == "db.redis"
-    assert spans[4]["tags"]["redis.command"] == "SET"
-
-    assert spans[5]["op"] == "cache.put"
-    assert spans[6]["op"] == "db.redis"
-    assert spans[6]["tags"]["redis.command"] == "SETEX"
-
-    assert spans[7]["op"] == "cache.get"
-    assert spans[8]["op"] == "db.redis"
-    assert spans[8]["tags"]["redis.command"] == "MGET"
+    # no cache support for HGET command
+    assert (
+        render_span_tree(event)
+        == """\
+- op="": description=null
+  - op="db.redis": description="HGET 'mycachekey' [Filtered]"
+  - op="cache.get": description="mycachekey"
+    - op="db.redis": description="GET 'mycachekey'"
+  - op="cache.put": description="mycachekey1"
+    - op="db.redis": description="SET 'mycachekey1' [Filtered]"
+  - op="cache.put": description="mycachekey2"
+    - op="db.redis": description="SETEX 'mycachekey2' [Filtered] [Filtered]"
+  - op="cache.get": description="mycachekey1, mycachekey2"
+    - op="db.redis": description="MGET 'mycachekey1' [Filtered]"\
+"""
+    )
 
 
-def test_cache_keys(sentry_init, capture_events):
+def test_cache_keys(sentry_init, capture_events, render_span_tree):
     sentry_init(
         integrations=[
             RedisIntegration(
@@ -96,24 +94,18 @@ def test_cache_keys(sentry_init, capture_events):
         connection.get("bl")
 
     (event,) = events
-    spans = sorted(event["spans"], key=lambda x: x["start_timestamp"])
-
-    assert len(spans) == 6
-    assert spans[0]["op"] == "db.redis"
-    assert spans[0]["description"] == "GET 'somethingelse'"
-
-    assert spans[1]["op"] == "cache.get"
-    assert spans[1]["description"] == "blub"
-    assert spans[2]["op"] == "db.redis"
-    assert spans[2]["description"] == "GET 'blub'"
-
-    assert spans[3]["op"] == "cache.get"
-    assert spans[3]["description"] == "blubkeything"
-    assert spans[4]["op"] == "db.redis"
-    assert spans[4]["description"] == "GET 'blubkeything'"
-
-    assert spans[5]["op"] == "db.redis"
-    assert spans[5]["description"] == "GET 'bl'"
+    assert (
+        render_span_tree(event)
+        == """\
+- op="": description=null
+  - op="db.redis": description="GET 'somethingelse'"
+  - op="cache.get": description="blub"
+    - op="db.redis": description="GET 'blub'"
+  - op="cache.get": description="blubkeything"
+    - op="db.redis": description="GET 'blubkeything'"
+  - op="db.redis": description="GET 'bl'"\
+"""
+    )
 
 
 def test_cache_data(sentry_init, capture_events):

tests/integrations/redis/test_redis_cache_module_async.py

@@ -21,7 +21,7 @@
 
 
 @pytest.mark.asyncio
-async def test_no_cache_basic(sentry_init, capture_events):
+async def test_no_cache_basic(sentry_init, capture_events, render_span_tree):
     sentry_init(
         integrations=[
             RedisIntegration(),
@@ -35,13 +35,17 @@ async def test_no_cache_basic(sentry_init, capture_events):
         await connection.get("myasynccachekey")
 
     (event,) = events
-    spans = event["spans"]
-    assert len(spans) == 1
-    assert spans[0]["op"] == "db.redis"
+    assert (
+        render_span_tree(event)
+        == """\
+- op="": description=null
+  - op="db.redis": description="GET 'myasynccachekey'"\
+"""
+    )
 
 
 @pytest.mark.asyncio
-async def test_cache_basic(sentry_init, capture_events):
+async def test_cache_basic(sentry_init, capture_events, render_span_tree):
     sentry_init(
         integrations=[
             RedisIntegration(
@@ -57,15 +61,18 @@ async def test_cache_basic(sentry_init, capture_events):
         await connection.get("myasynccachekey")
 
     (event,) = events
-    spans = event["spans"]
-    assert len(spans) == 2
-
-    assert spans[0]["op"] == "cache.get"
-    assert spans[1]["op"] == "db.redis"
+    assert (
+        render_span_tree(event)
+        == """\
+- op="": description=null
+  - op="cache.get": description="myasynccachekey"
+    - op="db.redis": description="GET 'myasynccachekey'"\
+"""
+    )
 
 
 @pytest.mark.asyncio
-async def test_cache_keys(sentry_init, capture_events):
+async def test_cache_keys(sentry_init, capture_events, render_span_tree):
     sentry_init(
         integrations=[
             RedisIntegration(
@@ -84,23 +91,18 @@ async def test_cache_keys(sentry_init, capture_events):
         await connection.get("abl")
 
     (event,) = events
-    spans = event["spans"]
-    assert len(spans) == 6
-    assert spans[0]["op"] == "db.redis"
-    assert spans[0]["description"] == "GET 'asomethingelse'"
-
-    assert spans[1]["op"] == "cache.get"
-    assert spans[1]["description"] == "ablub"
-    assert spans[2]["op"] == "db.redis"
-    assert spans[2]["description"] == "GET 'ablub'"
-
-    assert spans[3]["op"] == "cache.get"
-    assert spans[3]["description"] == "ablubkeything"
-    assert spans[4]["op"] == "db.redis"
-    assert spans[4]["description"] == "GET 'ablubkeything'"
-
-    assert spans[5]["op"] == "db.redis"
-    assert spans[5]["description"] == "GET 'abl'"
+    assert (
+        render_span_tree(event)
+        == """\
+- op="": description=null
+  - op="db.redis": description="GET 'asomethingelse'"
+  - op="cache.get": description="ablub"
+    - op="db.redis": description="GET 'ablub'"
+  - op="cache.get": description="ablubkeything"
+    - op="db.redis": description="GET 'ablubkeything'"
+  - op="db.redis": description="GET 'abl'"\
+"""
+    )
 
 
 @pytest.mark.asyncio
@@ -122,7 +124,7 @@ async def test_cache_data(sentry_init, capture_events):
         await connection.get("myasynccachekey")
 
     (event,) = events
-    spans = event["spans"]
+    spans = sorted(event["spans"], key=lambda x: x["start_timestamp"])
 
     assert len(spans) == 6