openmodule 14.0.1__tar.gz → 14.0.3__tar.gz

{openmodule-14.0.1 → openmodule-14.0.3}/ChangeLog

@@ -1,6 +1,16 @@
 CHANGES
 =======
 
+v14.0.3
+-------
+
+* OM-941 Sentry Bugfix
+
+v14.0.2
+-------
+
+* Sentry improvements
+
 v14.0.1
 -------
 
@@ -161,8 +171,6 @@ v12.0.0.rc0
 * settings models update
 * made gate\_control/day\_mode have no scope
 * schedule exports utility
-* SettingsProvider docs
-* SettingsProvider docs
 
 v11.1.1
 -------
@@ -197,14 +205,3 @@ v10.0.5
 -------
 
 * fixed problem in presence listener
-* README for settings + backend
-
-v10.0.4
--------
-
-* Improvements for backend and package reader
-
-v10.0.3
--------
-
-* added freezegun and fakeredis to openmodule requirements

{openmodule-14.0.1/openmodule.egg-info → openmodule-14.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openmodule
-Version: 14.0.1
+Version: 14.0.3
 Summary: Libraries for developing the arivo openmodule
 Home-page: https://gitlab.com/arivo-public/device-python/openmodule.git
 Author: ARIVO

{openmodule-14.0.1 → openmodule-14.0.3}/docs/sentry.md

@@ -24,6 +24,10 @@ for your project that tells the SDK where to send the events. You can find the D
 * You can provide additional [sentry options](https://docs.sentry.io/platforms/python/configuration/options/) as keyword
   arguments to the `init_openmodule` function (`server_name` and `environment` cannot be overriden).
 * the `extras` keyword argument can be used to provide additional data to the Sentry SDK
+* the `topics_to_ignore` keyword argument can be used to provide a list of topics that should not be captured by Sentry.
+You should also check that no trace will be started for every message from that topic. (defaults to `["io"]`)
+* the `functions_to_ignore` keyword argument can be used to provide a list of span names (auto generated for functions)
+that should not be captured by Sentry. (defaults to `[]`)
 
 ```python
 def main():
@@ -75,6 +79,8 @@ with sentry.trace("my_block"):
 
 You can add context to the current transaction using one of the following methods:
 
+* Adding the data as kwargs to the `sentry.trace` function.
+  * `sentry.trace("my_block", extras={"key": "value"}, tags={"key": "value"}, context={"key": "value"})`
 * `sentry_sdk.set_tag(key: str, value: str)`: Adds
   a [tag](https://docs.sentry.io/platforms/python/enriching-events/tags/) to the current transaction.
 * `sentry_sdk.set_tags(**key_value_pairs: str)`:

{openmodule-14.0.1 → openmodule-14.0.3}/openmodule/dispatcher.py

@@ -44,7 +44,7 @@ class Listener:
     def __init__(self, message_class: Type[ZMQMessage], type: Optional[str], filter: Optional[Callable],
                  handler: Callable):
         self.filter = filter
-        self.handler = handler
+        self.handler = sentry.trace(f"message_handler.{qualname_from_function(handler)}")(handler)
         self.type = type
         self.message_class = message_class
 
@@ -110,6 +110,7 @@ class MessageDispatcher:
         self.raise_validation_errors = raise_validation_errors
         self.raise_handler_errors = raise_handler_errors
         self.executor = executor or DummyExecutor()
+        self._new_transactions = not isinstance(self.executor, DummyExecutor)
         self._shutdown = False
         self._shutdown_lock = threading.Lock()
 
@@ -201,10 +202,12 @@ class MessageDispatcher:
             listeners = self.listeners.get(topic, [])
             for listener in listeners:
                 if listener.matches(message):
+                    message.update(sentry.get_trace_headers())
                     self.executor.submit(self.execute, topic, listener, message)
 
     def execute(self, topic: str, listener: Listener, message: Dict):
-        with sentry.continue_trace_zmq_message_process(topic, message):
+        with sentry.continue_trace_zmq_message_process(
+                topic, message, force_new_transaction=self._new_transactions):
             try:
                 parsed_message = parse_obj_as(listener.message_class, message)
             except ValidationError as e:
@@ -214,8 +217,7 @@ class MessageDispatcher:
                     self.log.exception("Invalid message received")
             else:
                 try:
-                    with sentry.trace(f"message_handler.{qualname_from_function(listener.handler)}"):
-                        listener.handler(parsed_message)
+                    listener.handler(parsed_message)
                 except zmq.ContextTerminated:
                     raise
                 except Exception as e:

{openmodule-14.0.1 → openmodule-14.0.3}/openmodule/rpc/server.py

@@ -77,6 +77,7 @@ class RPCServer(object):
         self.thread = None
         self.resource = None
         self.executor = executor or DummyExecutor()
+        self._new_transactions = not isinstance(self.executor, DummyExecutor)
         # since zmq does prefix matching we keep a list of unique channel names here
         # so we do not log a warning "unknown handler" if our channel is a prefix of a different channel
         self.registered_channels = set()
@@ -129,7 +130,8 @@ class RPCServer(object):
 
         self.log.debug("register handler {}:{} -> {}".format(channel, type, handler))
         self.sub.subscribe(channel_to_request_topic(channel).encode("utf8"))
-        self.handlers[(channel, type)] = HandlerEntry(request_class, response_class, handler)
+        traced_handler = sentry.trace(f"rpc_handler.{qualname_from_function(handler)}")(handler)
+        self.handlers[(channel, type)] = HandlerEntry(request_class, response_class, traced_handler)
         self.registered_channels = set(x[0] for x in self.handlers.keys())
         if register_schema:
             Schema.save_rpc(channel, type, request_class, response_class, handler)
@@ -194,15 +196,14 @@ class RPCServer(object):
             if settings.LOG_LEVEL != logging.DEBUG:
                 self.log.info("received RPC channel: %s, type: %s", channel, message.type)
             try:
-                with sentry.trace(f"rpc_handler.{qualname_from_function(handler.handler)}"):
-                    response = handler.handler(request, message)
-                    if isinstance(response, handler.response_class):
-                        # shortcut prevent serialization and de-serialization if the correct response
-                        # is already returned
-                        return self._response_to_dict(response)
-                    else:
-                        response = parse_obj_as(handler.response_class, response or {})
-                        return self._response_to_dict(response)
+                response = handler.handler(request, message)
+                if isinstance(response, handler.response_class):
+                    # shortcut prevent serialization and de-serialization if the correct response
+                    # is already returned
+                    return self._response_to_dict(response)
+                else:
+                    response = parse_obj_as(handler.response_class, response or {})
+                    return self._response_to_dict(response)
             except Exception as e:
                 self.log.exception("exception in handler {}:{}".format(channel, message.type))
                 return {"status": RPCServerError.handler_error, "exception": str(e)}
@@ -211,7 +212,8 @@ class RPCServer(object):
             return None
 
     def _process_rpc_message(self, topic: str, message: dict):
-        with sentry.continue_trace_zmq_message_process(topic, message):
+        with sentry.continue_trace_zmq_message_process(
+                topic, message, force_new_transaction=self._new_transactions):
             try:
                 channel = self._channel_from_topic(topic)
 
@@ -262,6 +264,7 @@ class RPCServer(object):
                         continue
                     if self.running:
                         # someone may have stopped our server while we were receiving a message
+                        message.update(sentry.get_trace_headers())
                         self.executor.submit(self._process_rpc_message, topic, message)
         except zmq.ContextTerminated:
             pass

{openmodule-14.0.1 → openmodule-14.0.3}/openmodule/sentry.py

@@ -5,13 +5,13 @@ import logging
 import os.path
 import time
 from contextlib import contextmanager
-from typing import Union, Callable, overload, Generator, Optional, Tuple, Any
+from typing import Union, Callable, overload, Generator, Optional, Tuple, Any, List
 
 import orjson
 import requests
+import sentry_sdk.integrations.logging
 import sentry_sdk.tracing
 import sentry_sdk.tracing_utils
-import sentry_sdk.integrations.logging
 import urllib3.exceptions
 from sentry_sdk.consts import EndpointType
 from sentry_sdk.envelope import Envelope
@@ -20,26 +20,35 @@ from sentry_sdk.utils import qualname_from_function
 from openmodule.config import settings
 
 _log = logging.getLogger("OmSentry")
+_topics_to_ignore: List[str] = ["io"]
+_functions_to_ignore: List[str] = ["message_handler.openmodule.utils.io.IoListener._on_io_message"]
+
+
+@contextmanager
+def noop_context():
+    yield
 
 
-def continue_trace_zmq_message_receive(topic: str, message: dict):
+def continue_trace_zmq_message_receive(topic: str, message: dict, **kwargs):
     """
     Continues a sentry trace for a received zmq message. (If already in a transaction, it will create a scope instead)
     Our ZMQMessage class contains the baggage and sentry-trace fields required for this, so the dict must contain these.
     :param topic: The topic of the message (as received from the ZMQ socket and decoded)
     :param message: The ZMQMessage as a dict (as received from the ZMQ socket and json loaded)
     """
-    return _continue_trace_zmq_message(topic, message, "topic.receive")
+    return _continue_trace_zmq_message(topic, message, "topic.receive", **kwargs)
 
 
-def continue_trace_zmq_message_process(topic: str, message: dict):
+def continue_trace_zmq_message_process(topic: str, message: dict, **kwargs):
     """
     Continues a sentry trace for a zmq message executor. (If already in a transaction, it will create a scope instead)
     Our ZMQMessage class contains the baggage and sentry-trace fields required for this, so the dict must contain these.
     :param topic: The topic of the message (as received from the ZMQ socket and decoded)
     :param message: The ZMQMessage as a dict (as received from the ZMQ socket and json loaded)
     """
-    return _continue_trace_zmq_message(topic, message, "topic.process")
+    if topic in _topics_to_ignore:
+        return noop_context()
+    return _continue_trace_zmq_message(topic, message, "topic.process", **kwargs)
 
 
 @overload  # pragma: no cover
@@ -48,6 +57,7 @@ def trace(
         op: Union[sentry_sdk.consts.OP, str] = sentry_sdk.consts.OP.FUNCTION,
         trace_headers: Optional[dict] = None,
         force_new_transaction: bool = False,
+        force_no_trace: bool = False,
         **span_kwargs) -> Callable[[Callable], Callable]:
     ...
 
@@ -58,6 +68,7 @@ def trace(
         op: Union[sentry_sdk.consts.OP, str] = sentry_sdk.consts.OP.FUNCTION,
         trace_headers: Optional[dict] = None,
         force_new_transaction: bool = False,
+        force_no_trace: bool = False,
         **span_kwargs) -> Union[Callable, Generator[sentry_sdk.tracing.Span, None, None]]:
     ...
 
@@ -68,6 +79,7 @@ def trace(
         op: Union[sentry_sdk.consts.OP, str] = sentry_sdk.consts.OP.FUNCTION,
         trace_headers: Optional[dict] = None,
         force_new_transaction: bool = False,
+        force_no_trace: bool = False,
         **span_kwargs) -> Callable:
     ...
 
@@ -77,6 +89,7 @@ def trace(
         op: Union[sentry_sdk.consts.OP, str] = sentry_sdk.consts.OP.FUNCTION,
         trace_headers: Optional[dict] = None,
         force_new_transaction: bool = False,
+        force_no_trace: bool = False,
         **span_kwargs):
     """
     Trace a function or a block of code.
@@ -86,6 +99,7 @@ def trace(
     span_kwargs["op"] = op
     span_kwargs["trace_headers"] = trace_headers
     span_kwargs["force_new_transaction"] = force_new_transaction
+    span_kwargs["force_no_trace"] = force_no_trace
     if name is None:
         return _Trace(**span_kwargs)
     elif callable(name):
@@ -109,6 +123,14 @@ def get_baggage() -> Optional[str]:
 get_traceparent = sentry_sdk.get_traceparent
 
 
+def get_trace_headers(empty_if_not_sampled: bool = False) -> dict:
+    if empty_if_not_sampled:
+        span = sentry_sdk.get_current_span()
+        if span and not span.sampled:
+            return {}
+    return {"sentry-trace": get_traceparent(), "baggage": get_baggage()}
+
+
 class _Trace:
     """
     Context manager for sentry tracing.
@@ -118,9 +140,11 @@ class _Trace:
     force_new_transaction: bool
     ctx: Any
 
-    def __init__(self, *, trace_headers: Optional[dict] = None, force_new_transaction: bool = False, **span_kwargs):
+    def __init__(self, *, trace_headers: Optional[dict] = None, force_new_transaction: bool = False,
+                 force_no_trace: bool = False, **span_kwargs):
         self.trace_headers = trace_headers
         self.force_new_transaction = force_new_transaction
+        self.force_no_trace = force_no_trace
         self.span_kwargs = span_kwargs
 
     @contextmanager
@@ -130,21 +154,40 @@ class _Trace:
         Otherwise, start a new span.
         If given a trace_headers dict, it will continue the trace with the given headers.
         """
+        force_no_trace = self.force_no_trace or self.span_kwargs.get("name") in _functions_to_ignore
+
+        def set_context():
+            for key, value in extras.items():
+                sentry_sdk.set_extra(key, value)
+            sentry_sdk.set_tags(tags)
+            for key, value in contexts.items():
+                sentry_sdk.set_context(key, value)
+
+        extras = self.span_kwargs.pop("extras", {})
+        tags = self.span_kwargs.pop("tags", {})
+        contexts = self.span_kwargs.pop("contexts", {})
         span = sentry_sdk.get_current_span()
         if span is None or self.force_new_transaction:
             with sentry_sdk.isolation_scope():
-                transaction: Optional[sentry_sdk.tracing.Transaction] = None
-                if self.trace_headers and "sentry-trace" in self.trace_headers:
-                    transaction = sentry_sdk.continue_trace(self.trace_headers, **self.span_kwargs)
-                with sentry_sdk.start_transaction(transaction=transaction, **self.span_kwargs) as transaction:
-                    if transaction:
-                        transaction.description = transaction.name
+                if force_no_trace:
+                    set_context()
                     yield
-        elif span.sampled:
+                else:
+                    transaction: Optional[sentry_sdk.tracing.Transaction] = None
+                    if self.trace_headers and "sentry-trace" in self.trace_headers:
+                        transaction = sentry_sdk.continue_trace(self.trace_headers, **self.span_kwargs)
+                    with sentry_sdk.start_transaction(transaction=transaction, **self.span_kwargs) as transaction:
+                        if transaction:
+                            transaction.description = transaction.name
+                        set_context()
+                        yield
+        elif not force_no_trace and span.sampled:
             self.span_kwargs.pop("source", None)
             with sentry_sdk.start_span(**self.span_kwargs):
+                set_context()
                 yield
         else:  # No need to start a span if the parent is not sampled
+            set_context()
             yield
 
     def __enter__(self) -> None:
@@ -179,9 +222,10 @@ class _Trace:
         return func_with_tracing
 
 
-def _continue_trace_zmq_message(topic: str, message: dict, op: str):
+def _continue_trace_zmq_message(topic: str, message: dict, op: str, **kwargs):
     name = f"{topic}/{message.get('type', '')}"
-    return _Trace(trace_headers=message, op=op, name=name, source="zmq", origin="auto.zmq")
+    return _Trace(trace_headers=message, op=op, name=name, source="zmq", origin="auto.zmq",
+                  force_no_trace=topic in _topics_to_ignore, **kwargs)
 
 
 class StoringTransport(sentry_sdk.transport.HttpTransport):
@@ -349,6 +393,11 @@ def _patch_sentry_method():
 
 def _update_sentry_config(kwargs: dict):
     # Set default values
+    global _topics_to_ignore, _functions_to_ignore
+    _topics_to_ignore = kwargs.pop("topics_to_ignore", ["io"])
+    _functions_to_ignore = kwargs.pop(
+        "functions_to_ignore", ["message_handler.openmodule.utils.io.IoListener._on_io_message"])
+
     if "traces_sampler" not in kwargs:
         kwargs.setdefault("traces_sample_rate", 0.0001)
     if "profiles_sampler" not in kwargs:
@@ -371,6 +420,8 @@ def _update_sentry_config(kwargs: dict):
     kwargs["extras"]["name"] = settings.NAME
     if hasattr(settings, "GATE"):
         kwargs["extras"]["gate"] = settings.GATE
+    kwargs.setdefault("contexts", {})
+    kwargs["contexts"]["device"] = {"name": settings.RESOURCE, "model": settings.RESOURCE}
 
 
 def init_sentry(dsn: str, **kwargs):
@@ -388,12 +439,17 @@ def init_sentry(dsn: str, **kwargs):
 
     _update_sentry_config(kwargs)
     extras = kwargs.pop("extras", {})
+    contexts = kwargs.pop("contexts", {})
+    tags = kwargs.pop("tags", {})
     sentry_sdk.init(dsn=dsn, **kwargs)
 
     _patch_requests_library()
     _patch_sentry_method()
     for key, value in extras.items():
         sentry_sdk.get_global_scope().set_extra(key, value)
+    sentry_sdk.get_global_scope().set_tags(tags)
+    for key, value in contexts.items():
+        sentry_sdk.get_global_scope().set_context(key, value)
 
 
 def deinit_sentry():

{openmodule-14.0.1 → openmodule-14.0.3}/openmodule/utils/io.py

@@ -137,7 +137,6 @@ class IoListener:
         return x if x else [IoState(pin="", gateway=Gateway(gate="", direction=""), type="", value=0, physical=0,
                                     inverted=False, last_timestamp=datetime.fromtimestamp(0))]
 
-    @sentry.trace
     def _on_io_message(self, message: IoMessage):
         """
         This handler receives all IO Messages, saves any changes and calls any listeners registered in the IoListener
@@ -170,18 +169,20 @@ class IoListener:
             self.current_states[message.pin].last_timestamp = message.timestamp
 
         message = message.dict()
-        for listener in self.listeners:
-            """
-            Handles the registered listeners the same as the dispatcher.
-            Is copied here because all messages are needed to keep current_states up to date.            
-            """
-            if listener.matches(message):
-                try:
-                    listener.handler(self.current_states[message["pin"]])
-                except zmq.ContextTerminated:
-                    raise
-                except Exception as e:
-                    if self.raise_handler_errors:
-                        raise e from None
-                    else:
-                        self.log.exception("Error in message handler")
+        matched_listeners = [listener for listener in self.listeners if listener.matches(message)]
+        if matched_listeners:
+            with sentry.continue_trace_zmq_message_process("io", message):
+                for listener in matched_listeners:
+                    """
+                    Handles the registered listeners the same as the dispatcher.
+                    Is copied here because all messages are needed to keep current_states up to date.            
+                    """
+                    try:
+                        listener.handler(self.current_states[message["pin"]])
+                    except zmq.ContextTerminated:
+                        raise
+                    except Exception as e:
+                        if self.raise_handler_errors:
+                            raise e from None
+                        else:
+                            self.log.exception("Error in message handler")

{openmodule-14.0.1 → openmodule-14.0.3}/openmodule/utils/kv_store.py

@@ -3,6 +3,7 @@ import logging
 import random
 import threading
 import time
+import uuid
 import warnings
 from typing import Type, Optional, List, Union, Dict
 
@@ -193,7 +194,7 @@ class KVStore:
         additional_kvs = current_kvs
         return KVSyncResponse(additions=additional_kvs, changes=changed_kvs, missing=missing_kvs)
 
-    def _log_sync_rpc_response(self, rpc_entry: RPCClient.RPCEntry) -> bool:
+    def _log_sync_rpc_response(self, rpc_entry: RPCClient.RPCEntry, conn_id: str) -> bool:
         """
         Waits for the RPC to finish and logs the response
         :return: if successful
@@ -203,11 +204,22 @@ class KVStore:
             rpc_entry.result(ServerSyncResponse)
             return True
         except RPCClient.TimeoutError:
-            self.log.error("Timeout syncing kvs")
+            if core().connection_listener.changed(conn_id):
+                self.log.warning("Connection loss during sync")
+            else:
+                self.log.error("Timeout syncing kvs")
         except RPCClient.CancelError:
-            self.log.error("Cancelled waiting for result of syncing kvs")
+            if core().connection_listener.changed(conn_id):
+                self.log.warning("Connection loss during sync")
+            else:
+                self.log.error("Cancelled waiting for result of syncing kvs")
         except RPCClient.ValidationError:
             self.log.exception("Error parsing sync response")
+        except RPCClient.RPCServerError as e:
+            if len(e.args) > 0 and e.args[0] == "request_timeout" and core().connection_listener.changed(conn_id):
+                self.log.warning("Connection loss during sync")
+            else:
+                self.log.exception("Error on server side in sync")
         except (RPCClient.ServerHandlerError, RPCClient.ServerValidationError, RPCClient.ServerFilterError):
             self.log.exception("Error on server side in sync")
         except Exception:
@@ -215,9 +227,9 @@ class KVStore:
         return False
 
     @sentry.trace
-    def sync(self) -> bool:
+    def sync(self, conn_id: str) -> bool:
         self.sync_rpc_entry = self.sync_with_server()
-        success = self._log_sync_rpc_response(self.sync_rpc_entry)
+        success = self._log_sync_rpc_response(self.sync_rpc_entry, conn_id)
         self.sync_rpc_entry = None
         if success:  # if sync was successful cancel retries
             return True
@@ -291,6 +303,7 @@ class KVStoreHandler:
 
     def run(self):
         """We only sync on startup and on reconnect"""
+        conn_id = uuid.uuid4().hex
         try:
             while self.running:
                 if self._wait_for_change_to_online():
@@ -305,7 +318,8 @@ class KVStoreHandler:
                                                                         ConnectionStatus.online):
                                 # cancel trying to sync if offline
                                 break
-                            if store.sync():
+                            core().connection_listener.changed(conn_id)
+                            if store.sync(conn_id):
                                 # if sync was successful cancel retries
                                 break
                             # we try again as long we are still alive
@@ -347,7 +361,7 @@ class KVStoreWithChangedNotification(KVStore):
         changed += list(old_values.keys())
         return changed
 
-    def _send_changed_notification(self, new_values: Dict[str, str], old_values: Dict[str, str]): # pragma: no cover
+    def _send_changed_notification(self, new_values: Dict[str, str], old_values: Dict[str, str]):  # pragma: no cover
         """
         consider using self._find_changed_kvs when implementing this
         also make sure your db model has a meaningful `comparison_value` method

{openmodule-14.0.1 → openmodule-14.0.3/openmodule.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openmodule
-Version: 14.0.1
+Version: 14.0.3
 Summary: Libraries for developing the arivo openmodule
 Home-page: https://gitlab.com/arivo-public/device-python/openmodule.git
 Author: ARIVO

openmodule-14.0.3/openmodule.egg-info/pbr.json

@@ -0,0 +1 @@
+{"git_version": "03b80ec", "is_release": true}

{openmodule-14.0.1 → openmodule-14.0.3}/openmodule.egg-info/requires.txt

@@ -1,5 +1,5 @@
 pydantic<2,>=1.7
-sentry-sdk==2.19.0
+sentry-sdk~=2.19.0
 orjson<4,>=3.4.7
 pyzmq<23,>=22
 pyyaml<6,>5

{openmodule-14.0.1 → openmodule-14.0.3}/openmodule_test/sentry.py

@@ -1,3 +1,4 @@
+import threading
 from typing import List
 from unittest import TestCase, mock
 
@@ -16,15 +17,18 @@ class SentryTestTransport(sentry_sdk.transport.Transport):
     def __init__(self, options=None):
         super().__init__(options)
         self.envelopes: List[Envelope] = []
+        self.envelopes_lock = threading.Lock()
 
     def capture_envelope(self, envelope: Envelope):
-        self.envelopes.append(envelope)
+        with self.envelopes_lock:
+            self.envelopes.append(envelope)
 
     def get_envelopes(self, clear: bool = True) -> List[Envelope]:
-        envelopes = self.envelopes
-        if clear:
-            self.envelopes = []
-        return envelopes
+        with self.envelopes_lock:
+            envelopes = self.envelopes
+            if clear:
+                self.envelopes = []
+            return envelopes
 
 
 class SentryTestMixin(TestCase):
@@ -56,10 +60,8 @@ class SentryTestMixin(TestCase):
         return transport
 
     def _get_envelopes(self) -> List[Envelope]:
-        return self.sentry_transport.envelopes
+        return self.sentry_transport.get_envelopes(clear=False)
 
     def get_sent_envelopes(self, timeout: float = 0, clear: bool = True) -> List[Envelope]:
-        envelopes = wait_for_value(self._get_envelopes, target=[], invert_target=True, timeout=timeout)
-        if clear:
-            self.sentry_transport.envelopes = []
-        return envelopes
+        wait_for_value(self._get_envelopes, target=[], invert_target=True, timeout=timeout)
+        return self.sentry_transport.get_envelopes(clear=clear)

{openmodule-14.0.1 → openmodule-14.0.3}/requirements.txt

@@ -1,5 +1,5 @@
 pydantic>=1.7,<2
-sentry-sdk==2.19.0
+sentry-sdk~=2.19.0
 orjson>=3.4.7,<4
 pyzmq>=22,<23
 pyyaml>5,<6