openmodule 14.0.1__tar.gz → 14.0.2__tar.gz

{openmodule-14.0.1 → openmodule-14.0.2}/ChangeLog

@@ -1,6 +1,11 @@
 CHANGES
 =======
 
+v14.0.2
+-------
+
+* Sentry improvements
+
 v14.0.1
 -------
 
@@ -162,7 +167,6 @@ v12.0.0.rc0
 * made gate\_control/day\_mode have no scope
 * schedule exports utility
 * SettingsProvider docs
-* SettingsProvider docs
 
 v11.1.1
 -------
@@ -202,9 +206,3 @@ v10.0.5
 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.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openmodule
-Version: 14.0.1
+Version: 14.0.2
 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.2}/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.2}/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.2}/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.2}/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,37 @@ 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")
+    if topic in _topics_to_ignore:
+        return noop_context()
+    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
@@ -109,6 +120,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": sentry_sdk.get_traceparent(), "baggage": sentry_sdk.get_baggage()}
+
+
 class _Trace:
     """
     Context manager for sentry tracing.
@@ -130,6 +149,20 @@ class _Trace:
         Otherwise, start a new span.
         If given a trace_headers dict, it will continue the trace with the given headers.
         """
+        if self.span_kwargs.get("name") in _functions_to_ignore:
+            yield
+            return
+
+        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():
@@ -139,12 +172,15 @@ class _Trace:
                 with sentry_sdk.start_transaction(transaction=transaction, **self.span_kwargs) as transaction:
                     if transaction:
                         transaction.description = transaction.name
+                    set_context()
                     yield
         elif 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 +215,9 @@ 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", **kwargs)
 
 
 class StoringTransport(sentry_sdk.transport.HttpTransport):
@@ -349,6 +385,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 +412,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 +431,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.2}/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.2/openmodule.egg-info}/PKG-INFO

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

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

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

{openmodule-14.0.1 → openmodule-14.0.2}/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.2}/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.2}/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

{openmodule-14.0.1 → openmodule-14.0.2}/tests/test_sentry.py

@@ -10,8 +10,10 @@ import random
 import signal
 import subprocess
 import sys
+import threading
 import time
 import unittest
+from concurrent.futures.thread import ThreadPoolExecutor
 from contextlib import contextmanager
 from io import BytesIO
 from pathlib import Path
@@ -30,9 +32,12 @@ import openmodule.logging
 from openmodule import sentry
 from openmodule.config import settings, override_settings
 from openmodule.core import init_openmodule, shutdown_openmodule
-from openmodule.models.base import ZMQMessage
+from openmodule.dispatcher import MessageDispatcher
+from openmodule.models.base import ZMQMessage, Gateway, Direction
+from openmodule.models.io import IoMessage
 from openmodule.rpc import RPCServer
 from openmodule.sentry import init_sentry, deinit_sentry
+from openmodule.utils.io import IoListener
 from openmodule_test.sentry import SentryTestMixin
 from openmodule_test.utils import wait_for_value
 from openmodule_test.zeromq import ZMQTestMixin
@@ -149,18 +154,25 @@ class SentryInitTestCase(ZMQTestMixin):
         self.assertEqual(str(e.exception), "sentry DSN is required")
         self.assertFalse(openmodule.core._core_thread.sentry_was_initialized)
 
+    @override_settings(GATE="einfahrt")
     def test_sentry_init(self):
         config = self.zmq_config()
         init_openmodule(config, context=self.zmq_context(), sentry=True, dsn="http://test@test/1")
         self.assertTrue(openmodule.core._core_thread.sentry_was_initialized)
-        self.assertIsInstance(sentry_sdk.get_global_scope().client, sentry_sdk.client.Client)
-        self.assertIsInstance(sentry_sdk.get_global_scope().client.transport, sentry.StoringTransport)
-        self.assertEqual(sentry_sdk.get_global_scope().client.options["release"], "test@test-version")
-        self.assertEqual(sentry_sdk.get_global_scope().client.options["server_name"], "test-resource")
-        self.assertEqual(sentry_sdk.get_global_scope().client.options["environment"], "staging")
-        self.assertEqual(sentry_sdk.get_global_scope().client.options["dsn"], "http://test@test/1")
-        self.assertEqual(sentry_sdk.get_global_scope().client.options["traces_sample_rate"], 0.0001)
-        self.assertEqual(sentry_sdk.get_global_scope().client.options["profiles_sample_rate"], 0.001)
+        scope = sentry_sdk.get_global_scope()
+        self.assertIsInstance(scope.client, sentry_sdk.client.Client)
+        self.assertIsInstance(scope.client.transport, sentry.StoringTransport)
+        self.assertEqual(scope.client.options["release"], "test@test-version")
+        self.assertEqual(scope.client.options["server_name"], "test-resource")
+        self.assertEqual(scope.client.options["environment"], "staging")
+        self.assertEqual(scope.client.options["dsn"], "http://test@test/1")
+        self.assertEqual(scope.client.options["traces_sample_rate"], 0.0001)
+        self.assertEqual(scope.client.options["profiles_sample_rate"], 0.001)
+        self.assertEqual(scope._extras, {"name": "test", "gate": "einfahrt"})
+        self.assertEqual(scope._contexts, {'device': {'model': 'test-resource', 'name': 'test-resource'}})
+        self.assertEqual(sentry._topics_to_ignore, ["io"])
+        self.assertEqual(sentry._functions_to_ignore, ["message_handler.openmodule.utils.io.IoListener._on_io_message"])
+
 
     @override_settings(NAME="test")
     def test_service_name_generation(self):
@@ -184,6 +196,18 @@ class SentryInitTestCase(ZMQTestMixin):
         sentry._update_sentry_config(kwargs)
         self.assertEqual(kwargs["release"], "service-test@test-version")
 
+    def test_sentry_ignore_topics(self):
+        self.assertEqual(sentry._topics_to_ignore, ["io"])
+        init_openmodule(self.zmq_config(), context=self.zmq_context(), sentry=True, dsn="http://test@test/1",
+                        topics_to_ignore=["test"])
+        self.assertEqual(sentry._topics_to_ignore, ["test"])
+
+    def test_sentry_ignore_functions(self):
+        self.assertEqual(sentry._functions_to_ignore, ["message_handler.openmodule.utils.io.IoListener._on_io_message"])
+        init_openmodule(self.zmq_config(), context=self.zmq_context(), sentry=True, dsn="http://test@test/1",
+                        functions_to_ignore=["test"])
+        self.assertEqual(sentry._functions_to_ignore, ["test"])
+
 
 class SentryTestCase(SentryTestMixin):
     def setUp(self):
@@ -404,6 +428,94 @@ class SentryTestCase(SentryTestMixin):
             ExampleClass.method()
         self.assert_spans(span_recorder, ["func"])
 
+    def test_io_message_not_traced(self):
+        with sentry.continue_trace_zmq_message_receive("io", {}):
+            pass
+        with sentry.continue_trace_zmq_message_receive("not-io", {}):
+            pass
+        envelopes = self.get_sent_envelopes()
+        self.assertEqual(len(envelopes), 1)
+        self.assertEqual(len(envelopes[0].items), 1)
+        self.assertEqual(envelopes[0].items[0].payload.json["transaction"], "not-io/")
+
+    def test_ignored_function(self):
+        sentry._functions_to_ignore = ["test-ignore"]
+        with sentry.trace("test-ignore"):
+            pass
+        with sentry.trace("not-test-ignore"):
+            pass
+        envelopes = self.get_sent_envelopes()
+        self.assertEqual(len(envelopes), 1)
+        self.assertEqual(len(envelopes[0].items), 1)
+        self.assertEqual(envelopes[0].items[0].payload.json["transaction"], "not-test-ignore")
+
+class SentryInDispatcherTestCase(SentryTestMixin):
+    def setUp(self):
+        super().setUp()
+        init_sentry("http://test@test/1")
+        sentry_sdk.get_client().options["traces_sample_rate"] = 1.0
+        self.dispatcher = None
+
+    def tearDown(self):
+        if self.dispatcher:
+            self.dispatcher.shutdown()
+        super().tearDown()
+        deinit_sentry()
+
+    def test_dispatcher(self):
+        def handler(*_):
+            pass
+
+        self.dispatcher = MessageDispatcher()
+        self.dispatcher.register_handler("test", ZMQMessage, handler, match_type=False, register_schema=False)
+        with sentry.trace("parent", sampled=True):
+            self.dispatcher.dispatch("test", ZMQMessage(type="test").dict())
+
+        envelopes = self.get_sent_envelopes()
+        self.assertEqual(len(envelopes), 1)
+        self.assertEqual(len(envelopes[0].items), 1)
+        self.assertEqual(envelopes[0].items[0].payload.json["transaction"], "parent")
+        self.assertEqual(len(envelopes[0].items[0].payload.json["spans"]), 2)
+        span_names = [span["description"] for span in envelopes[0].items[0].payload.json["spans"]]
+        handler_name = "message_handler.tests.test_sentry.SentryInDispatcherTestCase.test_dispatcher.<locals>.handler"
+        self.assertEqual(span_names, ["test/test", handler_name])
+
+    def test_io_handler_not_traced(self):
+        self.dispatcher = MessageDispatcher()
+        IoListener(self.dispatcher)
+        self.dispatcher.dispatch("io", IoMessage(edge=1, gateway=Gateway(gate="test", direction=Direction.IN),
+                                                 type="io", pin="1", value=1).dict())
+        with self.assertRaises(TimeoutError):
+            self.get_sent_envelopes()
+
+    def test_multi_worker_dispatcher(self):
+        def handler(*_):
+            envelopes_got.wait(1)
+            handled.set()
+
+        handled = threading.Event()
+        envelopes_got = threading.Event()
+        self.dispatcher = MessageDispatcher(executor=ThreadPoolExecutor(max_workers=20))
+        self.dispatcher.register_handler("test", ZMQMessage, handler, match_type=False, register_schema=False)
+        with sentry.trace("parent", sampled=True):
+            self.dispatcher.dispatch("test", ZMQMessage(type="test").dict())
+        first_envelopes = self.get_sent_envelopes()
+        envelopes_got.set()
+        self.assertTrue(handled.wait(timeout=1))
+        second_envelopes = self.get_sent_envelopes(timeout=1)
+        self.assertEqual(len(first_envelopes), 1)
+        self.assertEqual(len(first_envelopes[0].items), 1)
+        self.assertEqual(first_envelopes[0].items[0].payload.json["transaction"], "parent")
+        self.assertEqual(len(first_envelopes[0].items[0].payload.json["spans"]), 0)
+
+        self.assertEqual(len(second_envelopes), 1)
+        self.assertEqual(len(second_envelopes[0].items), 1)
+        self.assertEqual(second_envelopes[0].items[0].payload.json["transaction"], "test/test")
+        self.assertEqual(len(second_envelopes[0].items[0].payload.json["spans"]), 1)
+        handler_name = ("message_handler.tests.test_sentry.SentryInDispatcherTestCase."
+                        "test_multi_worker_dispatcher.<locals>.handler")
+        self.assertEqual(second_envelopes[0].items[0].payload.json["spans"][0]["description"], handler_name)
+
 
 class SentryUtilsTestCase(SentryTestMixin):
     @classmethod

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

@@ -1 +0,0 @@
-{"git_version": "18fe816", "is_release": true}