sentry-relay 0.5.13__zip → 0.5.87__zip

{sentry-relay-0.5.13 → sentry-relay-0.5.87}/PKG-INFO

@@ -1,10 +1,10 @@
-Metadata-Version: 1.0
+Metadata-Version: 2.1
 Name: sentry-relay
-Version: 0.5.13
+Version: 0.5.87
 Summary: A python library to access sentry relay functionality.
-Home-page: UNKNOWN
 Author: Sentry
 Author-email: hello@sentry.io
-License: BSL-1.1
-Description: UNKNOWN
+License: FSL-1.0-Apache-2.0
 Platform: any
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown

{sentry-relay-0.5.13 → sentry-relay-0.5.87}/sentry_relay/auth.py

@@ -1,7 +1,6 @@
 import json
 import uuid
 from sentry_relay._lowlevel import lib
-from sentry_relay._compat import PY2, text_type, implements_to_string
 from sentry_relay.utils import (
     RustObject,
     encode_str,
@@ -18,13 +17,11 @@ __all__ = [
     "SecretKey",
     "generate_key_pair",
     "create_register_challenge",
-    "get_register_response_relay_id",
     "validate_register_response",
     "is_version_supported",
 ]
 
 
-@implements_to_string
 class PublicKey(RustObject):
     __dealloc_func__ = lib.relay_publickey_free
 
@@ -50,7 +47,7 @@ class PublicKey(RustObject):
         return decode_str(self._methodcall(lib.relay_publickey_to_string), free=True)
 
     def __repr__(self):
-        return "<%s %r>" % (self.__class__.__name__, text_type(self))
+        return f"<{self.__class__.__name__} {str(self)!r}>"
 
 
 class SecretKey(RustObject):
@@ -67,16 +64,14 @@ class SecretKey(RustObject):
         return decode_str(self._methodcall(lib.relay_secretkey_sign, buf), free=True)
 
     def pack(self, data):
-        packed = json.dumps(data, separators=(",", ":"))
-        if not PY2:
-            packed = packed.encode("utf8")
+        packed = json.dumps(data, separators=(",", ":")).encode("utf8")
         return packed, self.sign(packed)
 
     def __str__(self):
         return decode_str(self._methodcall(lib.relay_secretkey_to_string), free=True)
 
     def __repr__(self):
-        return "<%s %r>" % (self.__class__.__name__, text_type(self))
+        return f"<{self.__class__.__name__} {str(self)!r}>"
 
 
 def generate_key_pair():
@@ -91,39 +86,38 @@ def generate_relay_id():
     return decode_uuid(rustcall(lib.relay_generate_relay_id))
 
 
-def create_register_challenge(data, signature, max_age=60 * 15):
+def create_register_challenge(data, signature, secret, max_age=60):
     challenge_json = rustcall(
         lib.relay_create_register_challenge,
         make_buf(data),
         encode_str(signature),
+        encode_str(secret),
         max_age,
     )
 
     challenge = json.loads(decode_str(challenge_json, free=True))
     return {
         "relay_id": uuid.UUID(challenge["relay_id"]),
-        "public_key": PublicKey.parse(challenge["public_key"]),
         "token": challenge["token"],
     }
 
 
-def get_register_response_relay_id(data):
-    return decode_uuid(
-        rustcall(lib.relay_get_register_response_relay_id, make_buf(data))
-    )
-
-
-def validate_register_response(public_key, data, signature, max_age=60 * 15):
+def validate_register_response(data, signature, secret, max_age=60):
     response_json = rustcall(
         lib.relay_validate_register_response,
-        public_key._objptr,
         make_buf(data),
         encode_str(signature),
+        encode_str(secret),
         max_age,
     )
 
     response = json.loads(decode_str(response_json, free=True))
-    return {"relay_id": uuid.UUID(response["relay_id"]), "token": response["token"]}
+    return {
+        "relay_id": uuid.UUID(response["relay_id"]),
+        "token": response["token"],
+        "public_key": response["public_key"],
+        "version": response["version"],
+    }
 
 
 def is_version_supported(version):

{sentry-relay-0.5.13 → sentry-relay-0.5.87}/sentry_relay/consts.py

@@ -1,23 +1,36 @@
+import sys
 from enum import IntEnum
 
 from sentry_relay._lowlevel import lib
 from sentry_relay.utils import decode_str, encode_str
 
-
 __all__ = ["DataCategory", "SPAN_STATUS_CODE_TO_NAME", "SPAN_STATUS_NAME_TO_CODE"]
 
 
-def _make_data_categories(ns):
-    prefix = "RELAY_DATA_CATEGORY_"
-
-    for attr in dir(lib):
-        if attr.startswith(prefix):
-            category_name = attr[len(prefix) :]
-            ns[category_name] = getattr(lib, attr)
-
-
 class DataCategory(IntEnum):
-    _make_data_categories(locals())
+    # begin generated
+    DEFAULT = 0
+    ERROR = 1
+    TRANSACTION = 2
+    SECURITY = 3
+    ATTACHMENT = 4
+    SESSION = 5
+    PROFILE = 6
+    REPLAY = 7
+    TRANSACTION_PROCESSED = 8
+    TRANSACTION_INDEXED = 9
+    MONITOR = 10
+    PROFILE_INDEXED = 11
+    SPAN = 12
+    MONITOR_SEAT = 13
+    USER_REPORT_V2 = 14
+    METRIC_BUCKET = 15
+    SPAN_INDEXED = 16
+    PROFILE_DURATION = 17
+    PROFILE_CHUNK = 18
+    METRIC_HOUR = 19
+    UNKNOWN = -1
+    # end generated
 
     @classmethod
     def parse(cls, name):
@@ -47,6 +60,7 @@ class DataCategory(IntEnum):
             DataCategory.ERROR,
             DataCategory.TRANSACTION,
             DataCategory.SECURITY,
+            DataCategory.USER_REPORT_V2,
         ]
 
     @classmethod
@@ -63,6 +77,29 @@ class DataCategory(IntEnum):
         return decode_str(lib.relay_data_category_name(self.value), free=True)
 
 
+def _check_generated():
+    prefix = "RELAY_DATA_CATEGORY_"
+
+    attrs = {}
+    for attr in dir(lib):
+        if attr.startswith(prefix):
+            category_name = attr[len(prefix) :]
+            attrs[category_name] = getattr(lib, attr)
+
+    if attrs != DataCategory.__members__:
+        values = sorted(
+            attrs.items(), key=lambda kv: sys.maxsize if kv[1] == -1 else kv[1]
+        )
+        generated = "".join(f"    {k} = {v}\n" for k, v in values)
+        raise AssertionError(
+            f"DataCategory enum does not match source!\n\n"
+            f"Paste this into `class DataCategory` in py/sentry_relay/consts.py:\n\n"
+            f"{generated}"
+        )
+
+
+_check_generated()
+
 SPAN_STATUS_CODE_TO_NAME = {}
 SPAN_STATUS_NAME_TO_CODE = {}
 

{sentry-relay-0.5.13 → sentry-relay-0.5.87}/sentry_relay/exceptions.py

@@ -1,4 +1,5 @@
-from sentry_relay._compat import implements_to_string
+from __future__ import annotations
+from typing import TYPE_CHECKING
 from sentry_relay._lowlevel import lib
 
 
@@ -6,7 +7,6 @@ __all__ = ["RelayError"]
 exceptions_by_code = {}
 
 
-@implements_to_string
 class RelayError(Exception):
     code = None
 
@@ -18,7 +18,7 @@ class RelayError(Exception):
     def __str__(self):
         rv = self.message
         if self.rust_info is not None:
-            return u"%s\n\n%s" % (rv, self.rust_info)
+            return f"{rv}\n\n{self.rust_info}"
         return rv
 
 
@@ -59,3 +59,7 @@ def _make_exceptions():
 
 
 _make_exceptions()
+
+if TYPE_CHECKING:
+    # treat unknown attribute names as exception types
+    def __getattr__(name: str) -> type[RelayError]: ...

{sentry-relay-0.5.13 → sentry-relay-0.5.87}/sentry_relay/processing.py

@@ -1,6 +1,7 @@
+from __future__ import annotations
+
 import json
 
-from sentry_relay._compat import string_types, iteritems, text_type
 from sentry_relay._lowlevel import lib, ffi
 from sentry_relay.utils import (
     encode_str,
@@ -17,24 +18,24 @@ __all__ = [
     "meta_with_chunks",
     "StoreNormalizer",
     "GeoIpLookup",
-    "scrub_event",
     "is_glob_match",
+    "is_codeowners_path_match",
     "parse_release",
+    "validate_pii_selector",
     "validate_pii_config",
     "convert_datascrubbing_config",
     "pii_strip_event",
-    "pii_selectors_from_event",
     "pii_selector_suggestions_from_event",
     "VALID_PLATFORMS",
+    "validate_rule_condition",
+    "validate_sampling_condition",
+    "validate_sampling_configuration",
+    "validate_project_config",
+    "normalize_global_config",
 ]
 
 
-VALID_PLATFORMS = frozenset()
-
-
-def _init_valid_platforms():
-    global VALID_PLATFORMS
-
+def _init_valid_platforms() -> frozenset[str]:
     size_out = ffi.new("uintptr_t *")
     strings = rustcall(lib.relay_valid_platforms, size_out)
 
@@ -42,15 +43,17 @@ def _init_valid_platforms():
     for i in range(int(size_out[0])):
         valid_platforms.append(decode_str(strings[i], free=True))
 
-    VALID_PLATFORMS = frozenset(valid_platforms)
+    return frozenset(valid_platforms)
 
 
-_init_valid_platforms()
+VALID_PLATFORMS = _init_valid_platforms()
 
 
 def split_chunks(string, remarks):
     json_chunks = rustcall(
-        lib.relay_split_chunks, encode_str(string), encode_str(json.dumps(remarks)),
+        lib.relay_split_chunks,
+        encode_str(string),
+        encode_str(json.dumps(remarks)),
     )
     return json.loads(decode_str(json_chunks, free=True))
 
@@ -60,10 +63,10 @@ def meta_with_chunks(data, meta):
         return meta
 
     result = {}
-    for key, item in iteritems(meta):
+    for key, item in meta.items():
         if key == "" and isinstance(item, dict):
             result[""] = item.copy()
-            if item.get("rem") and isinstance(data, string_types):
+            if item.get("rem") and isinstance(data, str):
                 result[""]["chunks"] = split_chunks(data, item["rem"])
         elif isinstance(data, dict):
             result[key] = meta_with_chunks(data.get(key), item)
@@ -83,14 +86,14 @@ class GeoIpLookup(RustObject):
 
     @classmethod
     def from_path(cls, path):
-        if isinstance(path, text_type):
+        if isinstance(path, str):
             path = path.encode("utf-8")
         rv = cls._from_objptr(rustcall(lib.relay_geoip_lookup_new, path))
         rv._path = path
         return rv
 
     def __repr__(self):
-        return "<GeoIpLookup %r>" % (self._path,)
+        return f"<GeoIpLookup {self._path!r}>"
 
 
 class StoreNormalizer(RustObject):
@@ -119,7 +122,7 @@ class StoreNormalizer(RustObject):
 
 def _serialize_event(event):
     raw_event = json.dumps(event, ensure_ascii=False)
-    if isinstance(raw_event, text_type):
+    if isinstance(raw_event, str):
         raw_event = raw_event.encode("utf-8", errors="replace")
     return raw_event
 
@@ -130,19 +133,6 @@ def _encode_raw_event(raw_event):
     return event
 
 
-def scrub_event(config, data):
-    if not config:
-        return data
-
-    config = json.dumps(config)
-
-    raw_event = _serialize_event(data)
-    event = _encode_raw_event(raw_event)
-
-    rv = rustcall(lib.relay_scrub_event, encode_str(config), event)
-    return json.loads(decode_str(rv, free=True))
-
-
 def is_glob_match(
     value,
     pat,
@@ -165,11 +155,30 @@ def is_glob_match(
     if allow_newline:
         flags |= lib.GLOB_FLAGS_ALLOW_NEWLINE
 
-    if isinstance(value, text_type):
+    if isinstance(value, str):
         value = value.encode("utf-8")
     return rustcall(lib.relay_is_glob_match, make_buf(value), encode_str(pat), flags)
 
 
+def is_codeowners_path_match(value, pattern):
+    if isinstance(value, str):
+        value = value.encode("utf-8")
+    return rustcall(
+        lib.relay_is_codeowners_path_match, make_buf(value), encode_str(pattern)
+    )
+
+
+def validate_pii_selector(selector):
+    """
+    Validate a PII selector spec. Used to validate datascrubbing safe fields.
+    """
+    assert isinstance(selector, str)
+    raw_error = rustcall(lib.relay_validate_pii_selector, encode_str(selector))
+    error = decode_str(raw_error, free=True)
+    if error:
+        raise ValueError(error)
+
+
 def validate_pii_config(config):
     """
     Validate a PII config against the schema. Used in project options UI.
@@ -178,7 +187,7 @@ def validate_pii_config(config):
     as a string such that line numbers from the error message match with what
     the user typed in.
     """
-    assert isinstance(config, string_types)
+    assert isinstance(config, str)
     raw_error = rustcall(lib.relay_validate_pii_config, encode_str(config))
     error = decode_str(raw_error, free=True)
     if error:
@@ -204,15 +213,6 @@ def pii_strip_event(config, event):
     return json.loads(decode_str(raw_rv, free=True))
 
 
-def pii_selectors_from_event(event):
-    """
-    DEPRECATED: Use relay_pii_selector_suggestions_from_event
-    """
-    raw_event = encode_str(json.dumps(event))
-    raw_rv = rustcall(lib.relay_pii_selectors_from_event, raw_event)
-    return json.loads(decode_str(raw_rv, free=True))
-
-
 def pii_selector_suggestions_from_event(event):
     """
     Walk through the event and collect selectors that can be applied to it in a
@@ -225,6 +225,78 @@ def pii_selector_suggestions_from_event(event):
 
 
 def parse_release(release):
+    """Parses a release string into a dictionary of its components."""
     return json.loads(
         decode_str(rustcall(lib.relay_parse_release, encode_str(release)), free=True)
     )
+
+
+def compare_version(a, b):
+    """Compares two versions with each other and returns 1/0/-1."""
+    return rustcall(lib.relay_compare_versions, encode_str(a), encode_str(b))
+
+
+def validate_sampling_condition(condition):
+    """
+    Deprecated legacy alias. Please use ``validate_rule_condition`` instead.
+    """
+    return validate_rule_condition(condition)
+
+
+def validate_rule_condition(condition):
+    """
+    Validate a dynamic rule condition. Used by dynamic sampling, metric extraction, and metric
+    tagging.
+
+    :param condition: A string containing the condition encoded as JSON.
+    """
+    assert isinstance(condition, str)
+    raw_error = rustcall(lib.relay_validate_rule_condition, encode_str(condition))
+    error = decode_str(raw_error, free=True)
+    if error:
+        raise ValueError(error)
+
+
+def validate_sampling_configuration(condition):
+    """
+    Validate the whole sampling configuration. Used in dynamic sampling serializer.
+    The parameter is a string containing the rules configuration as JSON.
+    """
+    assert isinstance(condition, str)
+    raw_error = rustcall(
+        lib.relay_validate_sampling_configuration, encode_str(condition)
+    )
+    error = decode_str(raw_error, free=True)
+    if error:
+        raise ValueError(error)
+
+
+def validate_project_config(config, strict: bool):
+    """Validate the whole project config.
+
+    :param strict: Whether or not to check for unknown fields.
+    """
+    assert isinstance(config, str)
+    raw_error = rustcall(lib.relay_validate_project_config, encode_str(config), strict)
+    error = decode_str(raw_error, free=True)
+    if error:
+        raise ValueError(error)
+
+
+def normalize_global_config(config):
+    """Normalize the global config.
+
+    Normalization consists of deserializing and serializing back the given
+    global config. If deserializing fails, throw an exception. Note that even if
+    the roundtrip doesn't produce errors, the given config may differ from
+    normalized one.
+
+    :param config: the global config to validate.
+    """
+    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:
+        raise ValueError(rv)

{sentry-relay-0.5.13 → sentry-relay-0.5.87}/sentry_relay/utils.py

@@ -1,11 +1,13 @@
+from __future__ import annotations
+
 import os
 import uuid
 import weakref
 from sentry_relay._lowlevel import ffi, lib
-from sentry_relay._compat import text_type, with_metaclass
 from sentry_relay.exceptions import exceptions_by_code, RelayError
 
 
+attached_refs: weakref.WeakKeyDictionary[object, bytes]
 attached_refs = weakref.WeakKeyDictionary()
 
 
@@ -35,7 +37,7 @@ def rustcall(func, *args):
     raise exc
 
 
-class RustObject(with_metaclass(_NoDict)):
+class RustObject(metaclass=_NoDict):
     __slots__ = ["_objptr", "_shared"]
     __dealloc_func__ = None
 
@@ -75,7 +77,7 @@ def decode_str(s, free=False):
     """Decodes a RelayStr"""
     try:
         if s.len == 0:
-            return u""
+            return ""
         return ffi.unpack(s.data, s.len).decode("utf-8", "replace")
     finally:
         if free and s.owned:
@@ -85,7 +87,7 @@ def decode_str(s, free=False):
 def encode_str(s, mutable=False):
     """Encodes a RelayStr"""
     rv = ffi.new("RelayStr *")
-    if isinstance(s, text_type):
+    if isinstance(s, str):
         s = s.encode("utf-8")
     if mutable:
         s = bytearray(s)

{sentry-relay-0.5.13 → sentry-relay-0.5.87}/setup.py

@@ -10,18 +10,20 @@ from setuptools import setup, find_packages
 from distutils.command.sdist import sdist
 
 
-_version_re = re.compile(r'^version\s*=\s*"(.*?)"\s*$(?m)')
+_version_re = re.compile(r'(?m)^version\s*=\s*"(.*?)"\s*$')
 
 
 DEBUG_BUILD = os.environ.get("RELAY_DEBUG") == "1"
 
-with open("README", "rb") as f:
+with open("README", encoding="UTF-8") as f:
     readme = f.read()
 
 
 if os.path.isfile("../relay-cabi/Cargo.toml"):
     with open("../relay-cabi/Cargo.toml") as f:
-        version = _version_re.search(f.read()).group(1)
+        match = _version_re.search(f.read())
+        assert match is not None
+        version = match[1]
 else:
     with open("version.txt") as f:
         version = f.readline().strip()
@@ -44,7 +46,7 @@ class CustomSDist(sdist):
 
 
 def build_native(spec):
-    cmd = ["cargo", "build"]
+    cmd = ["cargo", "build", "-p", "relay-cabi"]
     if not DEBUG_BUILD:
         cmd.append("--release")
         target = "release"
@@ -59,26 +61,40 @@ def build_native(spec):
         def delete_scratchpad():
             try:
                 shutil.rmtree(scratchpad)
-            except (IOError, OSError):
+            except OSError:
                 pass
 
         zf = zipfile.ZipFile("rustsrc.zip")
         zf.extractall(scratchpad)
-        rust_path = scratchpad + "/rustsrc/relay-cabi"
+        rust_path = scratchpad + "/rustsrc"
     else:
-        rust_path = "../relay-cabi"
+        rust_path = ".."
         scratchpad = None
 
+    # if the lib already built we replace the command
+    if os.environ.get("SKIP_RELAY_LIB_BUILD") is not None:
+        cmd = ["echo", "'Use pre-built library.'"]
+
     # Step 1: build the rust library
     build = spec.add_external_build(cmd=cmd, path=rust_path)
 
+    def find_dylib():
+        cargo_target = os.environ.get("CARGO_BUILD_TARGET")
+        if cargo_target:
+            in_path = f"target/{cargo_target}/{target}"
+        else:
+            in_path = "target/%s" % target
+        return build.find_dylib("relay_cabi", in_path=in_path)
+
     rtld_flags = ["NOW"]
     if sys.platform == "darwin":
         rtld_flags.append("NODELETE")
     spec.add_cffi_module(
         module_path="sentry_relay._lowlevel",
-        dylib=lambda: build.find_dylib("relay", in_path="target/%s" % target),
-        header_filename=lambda: build.find_header("relay.h", in_path="include"),
+        dylib=find_dylib,
+        header_filename=lambda: build.find_header(
+            "relay.h", in_path="relay-cabi/include"
+        ),
         rtld_flags=rtld_flags,
     )
 
@@ -88,15 +104,18 @@ setup(
     version=version,
     packages=find_packages(),
     author="Sentry",
-    license="BSL-1.1",
+    license="FSL-1.0-Apache-2.0",
     author_email="hello@sentry.io",
     description="A python library to access sentry relay functionality.",
     long_description=readme,
+    long_description_content_type="text/markdown",
     include_package_data=True,
+    package_data={"sentry_relay": ["py.typed", "_lowlevel.pyi"]},
     zip_safe=False,
     platforms="any",
-    install_requires=['enum34>=1.1.6,<1.2.0;python_version<"3.4"', "milksnake>=0.1.2"],
-    setup_requires=["milksnake>=0.1.2"],
+    python_requires=">=3.10",
+    install_requires=["milksnake>=0.1.6"],
+    setup_requires=["milksnake>=0.1.6"],
     milksnake_tasks=[build_native],
     cmdclass={"sdist": CustomSDist},
 )

sentry-relay-0.5.87/version.txt

@@ -0,0 +1 @@
+0.5.87

sentry-relay-0.5.13/sentry_relay/_compat.py

@@ -1,37 +0,0 @@
-import sys
-
-
-PY2 = sys.version_info[0] == 2
-
-if PY2:
-    text_type = unicode  # noqa
-    int_types = (int, long)  # noqa
-    string_types = (str, unicode)  # noqa
-    range_type = xrange  # noqa
-    iteritems = lambda x: x.iteritems()
-    itervalues = lambda x: x.itervalues()
-    NUL = "\x00"
-
-    def implements_to_string(cls):
-        cls.__unicode__ = cls.__str__
-        cls.__str__ = lambda x: x.__unicode__().encode("utf-8")
-        return cls
-
-
-else:
-    text_type = str
-    int_types = (int,)
-    string_types = (str,)
-    range_type = range
-    iteritems = lambda x: x.items()
-    itervalues = lambda x: x.values()
-    NUL = 0
-    implements_to_string = lambda x: x
-
-
-def with_metaclass(meta, *bases):
-    class metaclass(type):
-        def __new__(cls, name, this_bases, d):
-            return meta(name, bases, d)
-
-    return type.__new__(metaclass, "temporary_class", (), {})

sentry-relay-0.5.13/version.txt

@@ -1 +0,0 @@
-0.5.13