sentry-relay 0.8.57__zip → 0.8.58__zip

{sentry-relay-0.8.57 → sentry-relay-0.8.58}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sentry-relay
-Version: 0.8.57
+Version: 0.8.58
 Summary: A python library to access sentry relay functionality.
 Author: Sentry
 Author-email: hello@sentry.io

{sentry-relay-0.8.57 → sentry-relay-0.8.58}/sentry_relay/auth.py

@@ -1,5 +1,7 @@
 import json
 import uuid
+from typing import Callable, Any
+
 from sentry_relay._lowlevel import lib
 from sentry_relay.utils import (
     RustObject,
@@ -38,10 +40,16 @@ class PublicKey(RustObject):
             return self._methodcall(lib.relay_publickey_verify, buf, sig)
         return self._methodcall(lib.relay_publickey_verify_timestamp, buf, sig, max_age)
 
-    def unpack(self, buf, sig, max_age=None):
+    def unpack(
+        self,
+        buf,
+        sig,
+        max_age=None,
+        json_loads: Callable[[str | bytes], Any] = json.loads,
+    ):
         if not self.verify(buf, sig, max_age):
             raise UnpackErrorBadSignature("invalid signature")
-        return json.loads(buf)
+        return json_loads(buf)
 
     def __str__(self):
         return decode_str(self._methodcall(lib.relay_publickey_to_string), free=True)
@@ -64,7 +72,8 @@ class SecretKey(RustObject):
         return decode_str(self._methodcall(lib.relay_secretkey_sign, buf), free=True)
 
     def pack(self, data):
-        packed = json.dumps(data, separators=(",", ":")).encode("utf8")
+        # TODO(@anonrig): Look into separators requirement
+        packed = json.dumps(data, separators=(",", ":")).encode()
         return packed, self.sign(packed)
 
     def __str__(self):
@@ -86,7 +95,13 @@ def generate_relay_id():
     return decode_uuid(rustcall(lib.relay_generate_relay_id))
 
 
-def create_register_challenge(data, signature, secret, max_age=60):
+def create_register_challenge(
+    data,
+    signature,
+    secret,
+    max_age=60,
+    json_loads: Callable[[str | bytes], Any] = json.loads,
+):
     challenge_json = rustcall(
         lib.relay_create_register_challenge,
         make_buf(data),
@@ -95,14 +110,20 @@ def create_register_challenge(data, signature, secret, max_age=60):
         max_age,
     )
 
-    challenge = json.loads(decode_str(challenge_json, free=True))
+    challenge = json_loads(decode_str(challenge_json, free=True))
     return {
         "relay_id": uuid.UUID(challenge["relay_id"]),
         "token": challenge["token"],
     }
 
 
-def validate_register_response(data, signature, secret, max_age=60):
+def validate_register_response(
+    data,
+    signature,
+    secret,
+    max_age=60,
+    json_loads: Callable[[str | bytes], Any] = json.loads,
+):
     response_json = rustcall(
         lib.relay_validate_register_response,
         make_buf(data),
@@ -111,7 +132,7 @@ def validate_register_response(data, signature, secret, max_age=60):
         max_age,
     )
 
-    response = json.loads(decode_str(response_json, free=True))
+    response = json_loads(decode_str(response_json, free=True))
     return {
         "relay_id": uuid.UUID(response["relay_id"]),
         "token": response["token"],

{sentry-relay-0.8.57 → sentry-relay-0.8.58}/sentry_relay/processing.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+from typing import Callable, Any
 
 from sentry_relay._lowlevel import lib, ffi
 from sentry_relay.utils import (
@@ -12,7 +13,6 @@ from sentry_relay.utils import (
     make_buf,
 )
 
-
 __all__ = [
     "split_chunks",
     "meta_with_chunks",
@@ -49,13 +49,18 @@ def _init_valid_platforms() -> frozenset[str]:
 VALID_PLATFORMS = _init_valid_platforms()
 
 
-def split_chunks(string, remarks):
+def split_chunks(
+    string,
+    remarks,
+    json_dumps: Callable[[Any], Any] = json.dumps,
+    json_loads: Callable[[str | bytes], Any] = json.loads,
+):
     json_chunks = rustcall(
         lib.relay_split_chunks,
         encode_str(string),
-        encode_str(json.dumps(remarks)),
+        encode_str(json_dumps(remarks)),
     )
-    return json.loads(decode_str(json_chunks, free=True))
+    return json_loads(decode_str(json_chunks, free=True))
 
 
 def meta_with_chunks(data, meta):
@@ -101,8 +106,10 @@ class StoreNormalizer(RustObject):
     __init__ = object.__init__
     __slots__ = ("__weakref__",)
 
-    def __new__(cls, geoip_lookup=None, **config):
-        config = json.dumps(config)
+    def __new__(
+        cls, geoip_lookup=None, json_dumps: Callable[[Any], Any] = json.dumps, **config
+    ):
+        config = json_dumps(config)
         geoptr = geoip_lookup._get_objptr() if geoip_lookup is not None else ffi.NULL
         rv = cls._from_objptr(
             rustcall(lib.relay_store_normalizer_new, encode_str(config), geoptr)
@@ -111,16 +118,22 @@ class StoreNormalizer(RustObject):
             attached_refs[rv] = geoip_lookup
         return rv
 
-    def normalize_event(self, event=None, raw_event=None):
+    def normalize_event(
+        self,
+        event=None,
+        raw_event=None,
+        json_loads: Callable[[str | bytes], Any] = json.loads,
+    ):
         if raw_event is None:
             raw_event = _serialize_event(event)
 
         event = _encode_raw_event(raw_event)
         rv = self._methodcall(lib.relay_store_normalizer_normalize_event, event)
-        return json.loads(decode_str(rv, free=True))
+        return json_loads(decode_str(rv, free=True))
 
 
 def _serialize_event(event):
+    # TODO(@anonrig): Look into ensure_ascii requirement
     raw_event = json.dumps(event, ensure_ascii=False)
     if isinstance(raw_event, str):
         raw_event = raw_event.encode("utf-8", errors="replace")
@@ -194,39 +207,52 @@ def validate_pii_config(config):
         raise ValueError(error)
 
 
-def convert_datascrubbing_config(config):
+def convert_datascrubbing_config(
+    config,
+    json_dumps: Callable[[Any], Any] = json.dumps,
+    json_loads: Callable[[str | bytes], Any] = json.loads,
+):
     """
     Convert an old datascrubbing config to the new PII config format.
     """
-    raw_config = encode_str(json.dumps(config))
+    raw_config = encode_str(json_dumps(config))
     raw_rv = rustcall(lib.relay_convert_datascrubbing_config, raw_config)
-    return json.loads(decode_str(raw_rv, free=True))
+    return json_loads(decode_str(raw_rv, free=True))
 
 
-def pii_strip_event(config, event):
+def pii_strip_event(
+    config,
+    event,
+    json_dumps: Callable[[Any], Any] = json.dumps,
+    json_loads: Callable[[str | bytes], Any] = json.loads,
+):
     """
     Scrub an event using new PII stripping config.
     """
-    raw_config = encode_str(json.dumps(config))
-    raw_event = encode_str(json.dumps(event))
+    raw_config = encode_str(json_dumps(config))
+    raw_event = encode_str(json_dumps(event))
     raw_rv = rustcall(lib.relay_pii_strip_event, raw_config, raw_event)
-    return json.loads(decode_str(raw_rv, free=True))
+    return json_loads(decode_str(raw_rv, free=True))
 
 
-def pii_selector_suggestions_from_event(event):
+def pii_selector_suggestions_from_event(
+    event,
+    json_dumps: Callable[[Any], Any] = json.dumps,
+    json_loads: Callable[[str | bytes], Any] = json.loads,
+):
     """
     Walk through the event and collect selectors that can be applied to it in a
     PII config. This function is used in the UI to provide auto-completion of
     selectors.
     """
-    raw_event = encode_str(json.dumps(event))
+    raw_event = encode_str(json_dumps(event))
     raw_rv = rustcall(lib.relay_pii_selector_suggestions_from_event, raw_event)
-    return json.loads(decode_str(raw_rv, free=True))
+    return json_loads(decode_str(raw_rv, free=True))
 
 
-def parse_release(release):
+def parse_release(release, json_loads: Callable[[str | bytes], Any] = json.loads):
     """Parses a release string into a dictionary of its components."""
-    return json.loads(
+    return json_loads(
         decode_str(rustcall(lib.relay_parse_release, encode_str(release)), free=True)
     )
 
@@ -283,7 +309,11 @@ def validate_project_config(config, strict: bool):
         raise ValueError(error)
 
 
-def normalize_global_config(config):
+def normalize_global_config(
+    config,
+    json_dumps: Callable[[Any], Any] = json.dumps,
+    json_loads: Callable[[str | bytes], Any] = json.loads,
+):
     """Normalize the global config.
 
     Normalization consists of deserializing and serializing back the given
@@ -292,11 +322,14 @@ def normalize_global_config(config):
     normalized one.
 
     :param config: the global config to validate.
+    :param json_dumps: a function that stringifies python objects
+    :param json_loads: a function that parses and converts JSON strings
     """
-    serialized = json.dumps(config)
+    serialized = json_dumps(config)
     normalized = rustcall(lib.normalize_global_config, encode_str(serialized))
     rv = decode_str(normalized, free=True)
     try:
-        return json.loads(rv)
-    except json.JSONDecodeError:
+        return json_loads(rv)
+    except Exception:
+        # Catch all errors since json.loads implementation can change.
         raise ValueError(rv)

sentry-relay-0.8.58/version.txt

@@ -0,0 +1 @@
+0.8.58

sentry-relay-0.8.57/version.txt

@@ -1 +0,0 @@
-0.8.57