sentry-relay 0.9.9__tar.gz

sentry-relay-0.9.9/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.1
+Name: sentry-relay
+Version: 0.9.9
+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

sentry-relay-0.9.9/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.9/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.9/sentry_relay/consts.py

@@ -0,0 +1,133 @@
+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):
+    # 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
+    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["unknown"]
+
+
+_make_span_statuses()

sentry-relay-0.9.9/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]: ...

sentry-relay-0.9.9/sentry_relay/processing.py

@@ -0,0 +1,373 @@
+from __future__ import annotations
+
+import json
+from typing import Callable, Any
+
+from sentry_relay._lowlevel import lib, ffi
+from sentry_relay.utils import (
+    encode_str,
+    decode_str,
+    rustcall,
+    RustObject,
+    attached_refs,
+    make_buf,
+)
+
+__all__ = [
+    "split_chunks",
+    "meta_with_chunks",
+    "StoreNormalizer",
+    "GeoIpLookup",
+    "is_glob_match",
+    "is_codeowners_path_match",
+    "parse_release",
+    "validate_pii_selector",
+    "validate_pii_config",
+    "convert_datascrubbing_config",
+    "pii_strip_event",
+    "pii_selector_suggestions_from_event",
+    "VALID_PLATFORMS",
+    "validate_rule_condition",
+    "validate_sampling_condition",
+    "validate_sampling_configuration",
+    "normalize_project_config",
+    "normalize_cardinality_limit_config",
+    "normalize_global_config",
+]
+
+
+def _init_valid_platforms() -> frozenset[str]:
+    size_out = ffi.new("uintptr_t *")
+    strings = rustcall(lib.relay_valid_platforms, size_out)
+
+    valid_platforms = []
+    for i in range(int(size_out[0])):
+        valid_platforms.append(decode_str(strings[i], free=True))
+
+    return frozenset(valid_platforms)
+
+
+VALID_PLATFORMS = _init_valid_platforms()
+
+
+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)),
+    )
+    return json_loads(decode_str(json_chunks, free=True))
+
+
+def meta_with_chunks(data, meta):
+    if not isinstance(meta, dict):
+        return meta
+
+    result = {}
+    for key, item in meta.items():
+        if key == "" and isinstance(item, dict):
+            result[""] = item.copy()
+            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)
+        elif isinstance(data, list):
+            int_key = int(key)
+            val = data[int_key] if int_key < len(data) else None
+            result[key] = meta_with_chunks(val, item)
+        else:
+            result[key] = item
+
+    return result
+
+
+class GeoIpLookup(RustObject):
+    __dealloc_func__ = lib.relay_geoip_lookup_free
+    __slots__ = ("_path",)
+
+    @classmethod
+    def from_path(cls, path):
+        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 f"<GeoIpLookup {self._path!r}>"
+
+
+class StoreNormalizer(RustObject):
+    __dealloc_func__ = lib.relay_store_normalizer_free
+    __init__ = object.__init__
+    __slots__ = ("__weakref__",)
+
+    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)
+        )
+        if geoip_lookup is not None:
+            attached_refs[rv] = geoip_lookup
+        return rv
+
+    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))
+
+
+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")
+    return raw_event
+
+
+def _encode_raw_event(raw_event):
+    event = encode_str(raw_event, mutable=True)
+    rustcall(lib.relay_translate_legacy_python_json, event)
+    return event
+
+
+def is_glob_match(
+    value,
+    pat,
+    double_star=False,
+    case_insensitive=False,
+    path_normalize=False,
+    allow_newline=False,
+):
+    flags = 0
+    if double_star:
+        flags |= lib.GLOB_FLAGS_DOUBLE_STAR
+    if case_insensitive:
+        flags |= lib.GLOB_FLAGS_CASE_INSENSITIVE
+        # Since on the C side we're only working with bytes we need to lowercase the pattern
+        # and value here.  This works with both bytes and unicode strings.
+        value = value.lower()
+        pat = pat.lower()
+    if path_normalize:
+        flags |= lib.GLOB_FLAGS_PATH_NORMALIZE
+    if allow_newline:
+        flags |= lib.GLOB_FLAGS_ALLOW_NEWLINE
+
+    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.
+
+    The parameter is a JSON-encoded string. We should pass the config through
+    as a string such that line numbers from the error message match with what
+    the user typed in.
+    """
+    assert isinstance(config, str)
+    raw_error = rustcall(lib.relay_validate_pii_config, encode_str(config))
+    error = decode_str(raw_error, free=True)
+    if error:
+        raise ValueError(error)
+
+
+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_rv = rustcall(lib.relay_convert_datascrubbing_config, raw_config)
+    return json_loads(decode_str(raw_rv, free=True))
+
+
+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_rv = rustcall(lib.relay_pii_strip_event, raw_config, raw_event)
+    return json_loads(decode_str(raw_rv, free=True))
+
+
+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_rv = rustcall(lib.relay_pii_selector_suggestions_from_event, raw_event)
+    return json_loads(decode_str(raw_rv, free=True))
+
+
+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(
+        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 normalize_project_config(
+    config,
+    json_dumps: Callable[[Any], Any] = json.dumps,
+    json_loads: Callable[[str | bytes], Any] = json.loads,
+):
+    """Normalize a project config.
+
+    :param config: the project 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)
+    normalized = rustcall(lib.relay_normalize_project_config, encode_str(serialized))
+    rv = decode_str(normalized, free=True)
+    try:
+        return json_loads(rv)
+    except Exception:
+        # Catch all errors since json.loads implementation can change.
+        raise ValueError(rv)
+
+
+def normalize_cardinality_limit_config(
+    config,
+    json_dumps: Callable[[Any], Any] = json.dumps,
+    json_loads: Callable[[str | bytes], Any] = json.loads,
+):
+    """Normalize the cardinality limit config.
+
+    Normalization consists of deserializing and serializing back the given
+    cardinality limit 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 cardinality limit 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)
+    normalized = rustcall(
+        lib.normalize_cardinality_limit_config, encode_str(serialized)
+    )
+    rv = decode_str(normalized, free=True)
+    try:
+        return json_loads(rv)
+    except Exception:
+        # Catch all errors since json.loads implementation can change.
+        raise ValueError(rv)
+
+
+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
+    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.
+    :param json_dumps: a function that stringifies python objects
+    :param json_loads: a function that parses and converts JSON strings
+    """
+    serialized = json_dumps(config)
+    normalized = rustcall(lib.relay_normalize_global_config, encode_str(serialized))
+    rv = decode_str(normalized, free=True)
+    try:
+        return json_loads(rv)
+    except Exception:
+        # Catch all errors since json.loads implementation can change.
+        raise ValueError(rv)

sentry-relay-0.9.9/sentry_relay/utils.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+import os
+import uuid
+import weakref
+from sentry_relay._lowlevel import ffi, lib
+from sentry_relay.exceptions import exceptions_by_code, RelayError
+
+
+attached_refs: weakref.WeakKeyDictionary[object, bytes]
+attached_refs = weakref.WeakKeyDictionary()
+
+
+lib.relay_init()
+os.environ["RUST_BACKTRACE"] = "1"
+
+
+class _NoDict(type):
+    def __new__(cls, name, bases, d):
+        d.setdefault("__slots__", ())
+        return type.__new__(cls, name, bases, d)
+
+
+def rustcall(func, *args):
+    """Calls rust method and does some error handling."""
+    lib.relay_err_clear()
+    rv = func(*args)
+    err = lib.relay_err_get_last_code()
+    if not err:
+        return rv
+    msg = lib.relay_err_get_last_message()
+    cls = exceptions_by_code.get(err, RelayError)
+    exc = cls(decode_str(msg, free=True))
+    backtrace = decode_str(lib.relay_err_get_backtrace(), free=True)
+    if backtrace:
+        exc.rust_info = backtrace
+    raise exc
+
+
+class RustObject(metaclass=_NoDict):
+    __slots__ = ["_objptr", "_shared"]
+    __dealloc_func__ = None
+
+    def __init__(self):
+        raise TypeError("Cannot instanciate %r objects" % self.__class__.__name__)
+
+    @classmethod
+    def _from_objptr(cls, ptr, shared=False):
+        rv = object.__new__(cls)
+        rv._objptr = ptr
+        rv._shared = shared
+        return rv
+
+    def _methodcall(self, func, *args):
+        return rustcall(func, self._get_objptr(), *args)
+
+    def _get_objptr(self):
+        if not self._objptr:
+            raise RuntimeError("Object is closed")
+        return self._objptr
+
+    def __del__(self):
+        if rustcall is None:
+            # Interpreter is shutting down and our memory management utils are
+            # gone. Just give up, the process is going away anyway.
+            return
+
+        if self._objptr is None or self._shared:
+            return
+        f = self.__class__.__dealloc_func__
+        if f is not None:
+            rustcall(f, self._objptr)
+            self._objptr = None
+
+
+def decode_str(s, free=False):
+    """Decodes a RelayStr"""
+    try:
+        if s.len == 0:
+            return ""
+        return ffi.unpack(s.data, s.len).decode("utf-8", "replace")
+    finally:
+        if free and s.owned:
+            lib.relay_str_free(ffi.addressof(s))
+
+
+def encode_str(s, mutable=False):
+    """Encodes a RelayStr"""
+    rv = ffi.new("RelayStr *")
+    if isinstance(s, str):
+        s = s.encode("utf-8")
+    if mutable:
+        s = bytearray(s)
+    rv.data = ffi.from_buffer(s)
+    rv.len = len(s)
+    # we have to hold a weak reference here to ensure our string does not
+    # get collected before the string is used.
+    attached_refs[rv] = s
+    return rv
+
+
+def make_buf(value):
+    buf = memoryview(bytes(value))
+    rv = ffi.new("RelayBuf *")
+    rv.data = ffi.from_buffer(buf)
+    rv.len = len(buf)
+    attached_refs[rv] = buf
+    return rv
+
+
+def decode_uuid(value):
+    """Decodes the given uuid value."""
+    return uuid.UUID(bytes=bytes(bytearray(ffi.unpack(value.data, 16))))

sentry-relay-0.9.9/setup.py

@@ -0,0 +1,121 @@
+import os
+import re
+import sys
+import atexit
+import shutil
+import zipfile
+import tempfile
+import subprocess
+from setuptools import setup, find_packages
+from distutils.command.sdist import sdist
+
+
+_version_re = re.compile(r'(?m)^version\s*=\s*"(.*?)"\s*$')
+
+
+DEBUG_BUILD = os.environ.get("RELAY_DEBUG") == "1"
+
+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:
+        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()
+
+
+def vendor_rust_deps():
+    subprocess.Popen(["scripts/git-archive-all", "py/rustsrc.zip"], cwd="..").wait()
+
+
+def write_version():
+    with open("version.txt", "wb") as f:
+        f.write(("%s\n" % version).encode())
+
+
+class CustomSDist(sdist):
+    def run(self):
+        vendor_rust_deps()
+        write_version()
+        sdist.run(self)
+
+
+def build_native(spec):
+    cmd = ["cargo", "build", "-p", "relay-cabi"]
+    if not DEBUG_BUILD:
+        cmd.extend(("--profile", "release-cabi"))
+        target = "release-cabi"
+    else:
+        target = "debug"
+
+    # Step 0: find rust sources
+    if not os.path.isfile("../relay-cabi/Cargo.toml"):
+        scratchpad = tempfile.mkdtemp()
+
+        @atexit.register
+        def delete_scratchpad():
+            try:
+                shutil.rmtree(scratchpad)
+            except OSError:
+                pass
+
+        zf = zipfile.ZipFile("rustsrc.zip")
+        zf.extractall(scratchpad)
+        rust_path = scratchpad + "/rustsrc"
+    else:
+        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=find_dylib,
+        header_filename=lambda: build.find_header(
+            "relay.h", in_path="relay-cabi/include"
+        ),
+        rtld_flags=rtld_flags,
+    )
+
+
+setup(
+    name="sentry-relay",
+    version=version,
+    packages=find_packages(),
+    author="Sentry",
+    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",
+    python_requires=">=3.10",
+    install_requires=["milksnake>=0.1.6"],
+    setup_requires=["milksnake>=0.1.6"],
+    milksnake_tasks=[build_native],
+    cmdclass={"sdist": CustomSDist},  # type: ignore
+)

sentry-relay-0.9.9/version.txt

@@ -0,0 +1 @@
+0.9.9