sentry-relay 0.9.22__tar.gz

sentry_relay-0.9.22/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: sentry-relay
+Version: 0.9.22
+Summary: A python library to access sentry relay functionality.
+Author: Sentry
+Author-email: hello@sentry.io
+License: FSL-1.0-Apache-2.0
+Platform: any
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: milksnake>=0.1.6
+Dynamic: author
+Dynamic: author-email
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: platform
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

sentry_relay-0.9.22/sentry_relay/__init__.py

@@ -0,0 +1,23 @@
+__all__ = []
+
+
+def _import_all():
+    import pkgutil
+
+    glob = globals()
+    for _, modname, _ in pkgutil.iter_modules(__path__):
+        if modname[:1] == "_":
+            continue
+        mod = __import__("sentry_relay.%s" % modname, glob, glob, ["__name__"])
+        if not hasattr(mod, "__all__"):
+            continue
+        __all__.extend(mod.__all__)
+        for name in mod.__all__:
+            obj = getattr(mod, name)
+            if hasattr(obj, "__module__"):
+                obj.__module__ = "sentry_relay"
+            glob[name] = obj
+
+
+_import_all()
+del _import_all

sentry_relay-0.9.22/sentry_relay/auth.py

@@ -0,0 +1,149 @@
+import json
+import uuid
+from typing import Callable, Any
+
+from sentry_relay._lowlevel import lib
+from sentry_relay.utils import (
+    RustObject,
+    encode_str,
+    decode_str,
+    decode_uuid,
+    rustcall,
+    make_buf,
+)
+from sentry_relay.exceptions import UnpackErrorBadSignature
+
+
+__all__ = [
+    "PublicKey",
+    "SecretKey",
+    "generate_key_pair",
+    "create_register_challenge",
+    "validate_register_response",
+    "is_version_supported",
+]
+
+
+class PublicKey(RustObject):
+    __dealloc_func__ = lib.relay_publickey_free
+
+    @classmethod
+    def parse(cls, string):
+        s = encode_str(string)
+        ptr = rustcall(lib.relay_publickey_parse, s)
+        return cls._from_objptr(ptr)
+
+    def verify(self, buf, sig, max_age=None):
+        buf = make_buf(buf)
+        sig = encode_str(sig)
+        if max_age is None:
+            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,
+        json_loads: Callable[[str | bytes], Any] = json.loads,
+    ):
+        if not self.verify(buf, sig, max_age):
+            raise UnpackErrorBadSignature("invalid signature")
+        return json_loads(buf)
+
+    def __str__(self):
+        return decode_str(self._methodcall(lib.relay_publickey_to_string), free=True)
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__} {str(self)!r}>"
+
+
+class SecretKey(RustObject):
+    __dealloc_func__ = lib.relay_secretkey_free
+
+    @classmethod
+    def parse(cls, string):
+        s = encode_str(string)
+        ptr = rustcall(lib.relay_secretkey_parse, s)
+        return cls._from_objptr(ptr)
+
+    def sign(self, value):
+        buf = make_buf(value)
+        return decode_str(self._methodcall(lib.relay_secretkey_sign, buf), free=True)
+
+    def pack(self, data):
+        # TODO(@anonrig): Look into separators requirement
+        packed = json.dumps(data, separators=(",", ":")).encode()
+        return packed, self.sign(packed)
+
+    def __str__(self):
+        return decode_str(self._methodcall(lib.relay_secretkey_to_string), free=True)
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__} {str(self)!r}>"
+
+
+def generate_key_pair():
+    rv = rustcall(lib.relay_generate_key_pair)
+    return (
+        SecretKey._from_objptr(rv.secret_key),
+        PublicKey._from_objptr(rv.public_key),
+    )
+
+
+def generate_relay_id():
+    return decode_uuid(rustcall(lib.relay_generate_relay_id))
+
+
+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),
+        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"]),
+        "token": challenge["token"],
+    }
+
+
+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),
+        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"],
+        "public_key": response["public_key"],
+        "version": response["version"],
+    }
+
+
+def is_version_supported(version):
+    """
+    Checks if the provided Relay version is still compatible with this library. The version can be
+    ``None``, in which case a legacy Relay is assumed.
+    """
+    return rustcall(lib.relay_version_supported, encode_str(version or ""))

sentry_relay-0.9.22/sentry_relay/consts.py

@@ -0,0 +1,142 @@
+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"]
+
+
+class DataCategory(IntEnum):
+    # See _check_generated below.
+    # 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_SECOND = 19
+    DO_NOT_USE_REPLAY_VIDEO = 20
+    UPTIME = 21
+    ATTACHMENT_ITEM = 22
+    LOG_ITEM = 23
+    LOG_BYTE = 24
+    PROFILE_DURATION_UI = 25
+    PROFILE_CHUNK_UI = 26
+    SEER_AUTOFIX = 27
+    SEER_SCANNER = 28
+    PREVENT_USER = 29
+    PREVENT_REVIEW = 30
+    SIZE_ANALYSIS = 31
+    INSTALLABLE_BUILD = 32
+    TRACE_METRIC = 33
+    SEER_USER = 34
+    UNKNOWN = -1
+    # end generated
+
+    @classmethod
+    def parse(cls, name):
+        """
+        Parses a `DataCategory` from its API name.
+        """
+        category = DataCategory(lib.relay_data_category_parse(encode_str(name or "")))
+        if category == DataCategory.UNKNOWN:
+            return None  # Unknown is a Rust-only value, replace with None
+        return category
+
+    @classmethod
+    def from_event_type(cls, event_type):
+        """
+        Parses a `DataCategory` from an event type.
+        """
+        s = encode_str(event_type or "")
+        return DataCategory(lib.relay_data_category_from_event_type(s))
+
+    @classmethod
+    def event_categories(cls):
+        """
+        Returns categories that count as events, including transactions.
+        """
+        return [
+            DataCategory.DEFAULT,
+            DataCategory.ERROR,
+            DataCategory.TRANSACTION,
+            DataCategory.SECURITY,
+            DataCategory.USER_REPORT_V2,
+        ]
+
+    @classmethod
+    def error_categories(cls):
+        """
+        Returns categories that count as traditional error tracking events.
+        """
+        return [DataCategory.DEFAULT, DataCategory.ERROR, DataCategory.SECURITY]
+
+    def api_name(self):
+        """
+        Returns the API name of the given `DataCategory`.
+        """
+        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 = {}
+
+
+def _make_span_statuses():
+    prefix = "RELAY_SPAN_STATUS_"
+
+    for attr in dir(lib):
+        if not attr.startswith(prefix):
+            continue
+
+        status_name = attr[len(prefix) :].lower()
+        status_code = getattr(lib, attr)
+
+        SPAN_STATUS_CODE_TO_NAME[status_code] = status_name
+        SPAN_STATUS_NAME_TO_CODE[status_name] = status_code
+
+    # Legacy alias
+    SPAN_STATUS_NAME_TO_CODE["unknown_error"] = SPAN_STATUS_NAME_TO_CODE[
+        "internal_error"
+    ]
+
+
+_make_span_statuses()

sentry_relay-0.9.22/sentry_relay/exceptions.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+from sentry_relay._lowlevel import lib
+
+
+__all__ = ["RelayError"]
+exceptions_by_code = {}
+
+
+class RelayError(Exception):
+    code = None
+
+    def __init__(self, msg):
+        Exception.__init__(self)
+        self.message = msg
+        self.rust_info = None
+
+    def __str__(self):
+        rv = self.message
+        if self.rust_info is not None:
+            return f"{rv}\n\n{self.rust_info}"
+        return rv
+
+
+def _make_error(error_name, base=RelayError, code=None):
+    class Exc(base):
+        pass
+
+    Exc.__name__ = error_name
+    Exc.__qualname__ = error_name
+    if code is not None:
+        Exc.code = code
+    globals()[Exc.__name__] = Exc
+    __all__.append(Exc.__name__)
+    return Exc
+
+
+def _get_error_base(error_name):
+    pieces = error_name.split("Error", 1)
+    if len(pieces) == 2 and pieces[0] and pieces[1]:
+        base_error_name = pieces[0] + "Error"
+        base_class = globals().get(base_error_name)
+        if base_class is None:
+            base_class = _make_error(base_error_name)
+        return base_class
+    return RelayError
+
+
+def _make_exceptions():
+    prefix = "RELAY_ERROR_CODE_"
+    for attr in dir(lib):
+        if not attr.startswith(prefix):
+            continue
+
+        error_name = attr[len(prefix) :].title().replace("_", "")
+        base = _get_error_base(error_name)
+        exc = _make_error(error_name, base=base, code=getattr(lib, attr))
+        exceptions_by_code[exc.code] = exc
+
+
+_make_exceptions()
+
+if TYPE_CHECKING:
+    # treat unknown attribute names as exception types
+    def __getattr__(name: str) -> type[RelayError]: ...