openmodule 13.5.0__tar.gz → 13.6.0__tar.gz

{openmodule-13.5.0 → openmodule-13.6.0}/ChangeLog

@@ -1,6 +1,11 @@
 CHANGES
 =======
 
+v13.6.0
+-------
+
+* OM-697 OpenModule Verbesserungen
+
 v13.5.0
 -------
 
@@ -159,11 +164,6 @@ v11.1.0
 -------
 
 * csv export library, databox upload and schedule library tips
-
-v11.1.0.rc5
------------
-
-* again no language set in testing
 * removed mock rpcs from schema
 
 v11.0.3
@@ -210,8 +210,3 @@ v10.0.2.rc2
 
 * added more documentation [skip ci]
 * fixes an issue in the multiprocessing\_logging package in testcases
-
-v10.0.2.rc1
------------
-
-* Refactor for backend class for controller v2

{openmodule-13.5.0/openmodule.egg-info → openmodule-13.6.0}/PKG-INFO

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

{openmodule-13.5.0 → openmodule-13.6.0}/docs/migrations.md

@@ -1,11 +1,18 @@
 # Breaking Version Changes
 
+## 13.6.0
+* messaging:
+  * the `get_pub_socket` now raises an AssertionError because we no longer support multiple publishers. 
+    This was done because pub sockets receive all subscriptions and queue them until the next message is sent.
+    This can lead to a memory leak.
+* logging:
+  * logs will now be written to stdout instead of stderr
+
 ## 13.5.0:
 * changes in env.py of alembic: <br>
   `from openmodule.database.database import run_env_py` -> <br> 
   `from openmodule.database.migration import run_env_py`
 
-
 ## 13.0.0
 * access_service:
   * changes in AccessCheckAccess (removed media field) and AccessCheckResponse (removed error field)

{openmodule-13.5.0 → openmodule-13.6.0}/openmodule/core.py

@@ -14,7 +14,8 @@ from openmodule.config import validate_config_module
 from openmodule.dispatcher import ZMQMessageDispatcher
 from openmodule.health import HealthHandlerType, Healthz, HealthPingMessage
 from openmodule.logging import init_logging
-from openmodule.messaging import get_pub_socket, get_sub_socket, receive_message_from_socket, wait_for_connection
+from openmodule.messaging import _internal_get_pub_socket, get_sub_socket, receive_message_from_socket, \
+    wait_for_connection
 from openmodule.models.base import ZMQMessage
 from openmodule.sentry import init_sentry, should_activate_sentry, deinit_sentry
 from openmodule.threading import get_thread_wrapper
@@ -35,7 +36,7 @@ class OpenModuleCore(threading.Thread):
         self.pub_lock = threading.Lock()
         self.sub_lock = threading.Lock()
 
-        self.pub_socket = get_pub_socket(self.context, self.config, linger=1000)
+        self.pub_socket = _internal_get_pub_socket(self.context, self.config, linger=1000)
         self.sub_socket = get_sub_socket(self.context, self.config)
         self.sub_socket_internal = get_sub_socket(self.context, self.config)
 

{openmodule-13.5.0 → openmodule-13.6.0}/openmodule/dispatcher.py

@@ -108,6 +108,8 @@ class MessageDispatcher:
         self.raise_validation_errors = raise_validation_errors
         self.raise_handler_errors = raise_handler_errors
         self.executor = executor or DummyExecutor()
+        self._shutdown = False
+        self._shutdown_lock = threading.Lock()
 
     @property
     def is_multi_threaded(self):
@@ -125,7 +127,9 @@ class MessageDispatcher:
         return True
 
     def shutdown(self, wait=True):
-        self.executor.shutdown(wait=wait)
+        with self._shutdown_lock:
+            self._shutdown = True
+            self.executor.shutdown(wait=wait)
 
     def unregister_handler(self, listener: Listener):
         for topic, listeners in self.listeners.items():
@@ -180,15 +184,22 @@ class MessageDispatcher:
         return listener
 
     def dispatch(self, topic: str, message: Union[Dict, BaseModel]):
-        assert isinstance(topic, str), "topic must be a string"
-
-        if isinstance(message, BaseModel):
-            message = message.dict()
-
-        listeners = self.listeners.get(topic, [])
-        for listener in listeners:
-            if listener.matches(message):
-                self.executor.submit(self.execute, listener, message)
+        with self._shutdown_lock:
+            if self._shutdown:
+                # We need to drop messages after shutdown somewhere.
+                # Cannot be done in the executor because it's a python builtin base class.
+                # Could also be done in core, but it's better here because messages and _messages_internal are
+                # both dispatched here.
+                return
+            assert isinstance(topic, str), "topic must be a string"
+
+            if isinstance(message, BaseModel):
+                message = message.dict()
+
+            listeners = self.listeners.get(topic, [])
+            for listener in listeners:
+                if listener.matches(message):
+                    self.executor.submit(self.execute, listener, message)
 
     def execute(self, listener: Listener, message: Dict):
         try:

{openmodule-13.5.0 → openmodule-13.6.0}/openmodule/logging.py

@@ -1,11 +1,12 @@
 import logging
+import sys
 
 
 def init_logging(core):
     assert hasattr(core.config, "LOG_LEVEL"), (
-        "LOG_LEVLE setting not found in your config. In order to use logging please add \n"
+        "LOG_LEVEL setting not found in your config. In order to use logging please add \n"
         "> LOG_LEVEL = config.log_level()\n"
         "to your config.py"
     )
-    logging.basicConfig(level=core.config.LOG_LEVEL)
+    logging.basicConfig(level=core.config.LOG_LEVEL, stream=sys.stdout)
     logging.captureWarnings(True)

{openmodule-13.5.0 → openmodule-13.6.0}/openmodule/messaging.py

@@ -12,18 +12,29 @@ from openmodule.dispatcher import MessageDispatcher
 from openmodule.models.base import ZMQMessage
 
 
+def _internal_get_pub_socket(context, config, linger=100) -> zmq.Socket:
+    socket: zmq.Socket = context.socket(zmq.PUB)
+    socket.setsockopt(zmq.LINGER, linger)
+    socket.setsockopt(zmq.TCP_KEEPALIVE, 1)
+    socket.setsockopt(zmq.TCP_KEEPALIVE_IDLE, 3600)
+    socket.connect(config.BROKER_SUB)
+    return socket
+
+
 def get_sub_socket(context, config, linger=0) -> zmq.Socket:
-    socket = context.socket(zmq.SUB)
+    socket: zmq.Socket = context.socket(zmq.SUB)
     socket.setsockopt(zmq.LINGER, linger)
+    socket.setsockopt(zmq.TCP_KEEPALIVE, 1)
+    socket.setsockopt(zmq.TCP_KEEPALIVE_IDLE, 3600)
     socket.connect(config.BROKER_PUB)
     return socket
 
 
 def get_pub_socket(context, config, linger=100) -> zmq.Socket:
-    socket = context.socket(zmq.PUB)
-    socket.setsockopt(zmq.LINGER, linger)
-    socket.connect(config.BROKER_SUB)
-    return socket
+    raise AssertionError(
+        "This function must not be used. Use core().publish instead (OM-697, OM-700). This is because the pub_socket "
+        "receives all subscriptions which will result in a memory leak until a message is sent to the socket."
+    )
 
 
 def wait_for_connection(dispatcher: MessageDispatcher, pub_socket=None, pub_lock=None, timeout=100):

{openmodule-13.5.0 → openmodule-13.6.0}/openmodule/models/base.py

@@ -137,15 +137,9 @@ def datetime_to_timestamp(dt: datetime):
 
 class ZMQMessage(OpenModuleModel):
     timestamp: datetime = Field(default_factory=lambda: datetime.utcnow())
-    name: str
+    name: str = Field(default_factory=lambda: settings.NAME)
     type: str
 
-    def __init__(self, **kwargs):
-        name = kwargs.pop("name", None)
-        if name is None:
-            name = settings.NAME
-        super().__init__(name=name, **kwargs)
-
     _tz_timestamp = timezone_validator("timestamp")
 
     def publish_on_topic(self, pub_socket: zmq.Socket, topic: str):

{openmodule-13.5.0 → openmodule-13.6.0}/openmodule/rpc/server.py

@@ -10,8 +10,9 @@ from pydantic import ValidationError, BaseModel, parse_obj_as
 from pydantic.main import ROOT_KEY
 
 from openmodule.config import settings
+from openmodule.core import core
 from openmodule.dispatcher import DummyExecutor
-from openmodule.messaging import get_sub_socket, get_pub_socket, receive_message_from_socket
+from openmodule.messaging import get_sub_socket, receive_message_from_socket
 from openmodule.models.rpc import RPCResponse, RPCRequest, RPCServerError
 from openmodule.rpc.common import channel_to_request_topic, channel_to_response_topic
 from openmodule.threading import get_thread_wrapper
@@ -67,7 +68,6 @@ class RPCServer(object):
         config = config or settings
         self.name = config.NAME
         self.sub = get_sub_socket(context, config)
-        self.pub = get_pub_socket(context, config)
         self.pub_lock = threading.Lock()
         self.handlers: Dict[Tuple[str, str], HandlerEntry] = {}
         self.filters = []
@@ -102,8 +102,6 @@ class RPCServer(object):
         if self.thread:
             self.thread.join(timeout=timeout)
         else:
-            with self.pub_lock:
-                self.pub.close()
             self.sub.close()
 
     def register_handler(self, channel: str, type: str,
@@ -237,11 +235,7 @@ class RPCServer(object):
                     response=response,
                     name=self.name
                 )
-                with self.pub_lock:
-                    result.publish_on_topic(
-                        self.pub,
-                        channel_to_response_topic(channel),
-                    )
+                core().publish(result, channel_to_response_topic(channel))
         except zmq.ContextTerminated:
             self.log.warning(
                 "context terminated while RPC request was being processed. The result might not have been sent."
@@ -267,5 +261,3 @@ class RPCServer(object):
             pass
         finally:
             self.sub.close()
-            with self.pub_lock:
-                self.pub.close()

{openmodule-13.5.0 → openmodule-13.6.0/openmodule.egg-info}/PKG-INFO

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

{openmodule-13.5.0 → openmodule-13.6.0}/openmodule.egg-info/SOURCES.txt

@@ -136,6 +136,7 @@ tests/test_dispatcher.py
 tests/test_health.py
 tests/test_interrupt.py
 tests/test_io_listen.py
+tests/test_logging.py
 tests/test_messaging.py
 tests/test_mockrpcclient.py
 tests/test_model.py

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

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

openmodule-13.6.0/tests/test_core.py

@@ -0,0 +1,104 @@
+import threading
+from unittest import TestCase, mock
+
+from openmodule.alert import AlertHandleType
+from openmodule.config import override_settings
+from openmodule.core import core, init_openmodule, shutdown_openmodule
+from openmodule.models.base import ZMQMessage
+from openmodule_test.alert import AlertTestMixin
+from openmodule_test.health import HealthTestMixin
+
+
+class OpenModuleCoreTest(AlertTestMixin, HealthTestMixin, TestCase):
+    topics = ["healthpong", "sentry", "alert", "test"]
+    protocol = "tcp://"
+
+    @override_settings(NAME="x123x")
+    def test_core_init_and_shutdown(self):
+        self.assertIsNone(core())
+
+        init_openmodule(self.zmq_config())
+        try:
+            self.assertIsNotNone(core())
+            self.wait_for_health(name="x123x")
+        finally:
+            shutdown_openmodule()
+
+    @override_settings(DEBUG=False, TESTING=False)
+    def test_core_sentry_error_logging(self):
+        # sentry is not active during unittests / debug
+        init_openmodule(self.zmq_config())
+        self.wait_for_health()
+
+        try:
+            core().log.error("some-error-message")
+            sentry_message = self.zmq_client.wait_for_message_on_topic("sentry")
+            self.assertIn("some-error-message", str(sentry_message))
+        finally:
+            shutdown_openmodule()
+
+    def test_core_alerts(self):
+        init_openmodule(self.zmq_config())
+        self.wait_for_health()
+
+        try:
+            core().alerts.send("some_type", AlertHandleType.state_change)
+            self.assertAlert(alert_type="some_type")
+        finally:
+            shutdown_openmodule()
+
+    def test_shutdown_wait_for_message_handling(self):
+        def handler(_):
+            nonlocal error
+            handler_started.set()
+            if shutdown_finished.wait(timeout=3):
+                error = "shutdown finished while message was still being handled"
+                return
+            if core().messages._shutdown:
+                error = "shutdown flag was set while message was still being handled"
+
+        error = ""
+        handler_started = threading.Event()
+        shutdown_finished = threading.Event()
+        init_openmodule(self.zmq_config())
+        self.wait_for_health()
+        core().messages.register_handler("test", ZMQMessage, handler, register_schema=False, match_type=False)
+        core().publish(ZMQMessage(type="test"), "test")
+        self.assertTrue(handler_started.wait(timeout=3))
+        try:
+            core().shutdown()
+            shutdown_finished.set()
+            self.assertEqual(error, "")
+        finally:
+            shutdown_openmodule()
+
+    def test_no_message_submit_after_shutdown(self):
+        def dispatch_wrapper(topic, message):
+            nonlocal error
+            dispatch_started.set()
+            if not shutdown_done.wait(timeout=3):
+                error = "shutdown did not finish when expected"
+            original_dispatch(topic, message)
+            dispatch_done.set()
+
+        error = ""
+        dispatch_started = threading.Event()
+        dispatch_done = threading.Event()
+        shutdown_done = threading.Event()
+        init_openmodule(self.zmq_config())
+        self.wait_for_health()
+        original_dispatch = core().messages.dispatch
+        handler = mock.MagicMock()
+        core().messages.dispatch = dispatch_wrapper
+
+        core().messages.register_handler("test", ZMQMessage, handler, register_schema=False, match_type=False)
+        core().publish(ZMQMessage(type="test"), "test")
+        self.assertTrue(dispatch_started.wait(timeout=3))
+        try:
+            with mock.patch("zmq.Context.term", side_effect=shutdown_done.set):
+                core().shutdown()
+            self.assertTrue(dispatch_done.wait(timeout=3))
+            self.assertFalse(handler.called)
+            self.assertEqual(error, "")
+        finally:
+            shutdown_openmodule()

{openmodule-13.5.0 → openmodule-13.6.0}/tests/test_database.py

@@ -23,6 +23,14 @@ from tests.database_models_test import DatabaseTestModel
 class DatabaseTest(SQLiteTestMixin, TestCase):
     alembic_path = "../tests/test_database"
 
+    @classmethod
+    def tearDownClass(cls):
+        super().tearDownClass()
+        try:
+            os.unlink(database_path(cls.get_database_folder(), "asdf"))
+        except FileNotFoundError:
+            pass
+
     def test_filter(self):
         data = [DatabaseTestModel(value1=x, value2=x % 3) for x in range(5)]
         with self.database as db:
@@ -257,6 +265,14 @@ class DatabaseTest(SQLiteTestMixin, TestCase):
 class ShutdownTestCase(TestCase):
     alembic_path = "../tests/test_database"
 
+    @classmethod
+    def tearDownClass(cls):
+        super().tearDownClass()
+        try:
+            os.unlink(database_path(settings.DATABASE_FOLDER, "shutdown"))
+        except FileNotFoundError:
+            pass
+
     def get_database(self):
         return Database(settings.DATABASE_FOLDER, name="shutdown", alembic_path=self.alembic_path)
 
@@ -409,6 +425,13 @@ class DowngradeMigrationSequenceNameTest(SQLiteTestMixin, TestCase):
 
 
 class DatabaseMigrationProcessFailTest(TestCase):
+    @classmethod
+    def tearDownClass(cls):
+        super().tearDownClass()
+        try:
+            os.unlink(database_path(cls.get_database_folder(), "database"))
+        except FileNotFoundError:
+            pass
 
     @classmethod
     def get_database_folder(cls):

{openmodule-13.5.0 → openmodule-13.6.0}/tests/test_dispatcher.py

@@ -2,7 +2,7 @@ from concurrent.futures.process import ProcessPoolExecutor
 from concurrent.futures.thread import ThreadPoolExecutor
 from functools import partial
 from typing import Any
-from unittest import TestCase
+from unittest import TestCase, mock
 
 from openmodule.config import settings
 from openmodule.dispatcher import MessageDispatcher, SubscribingMessageDispatcher
@@ -15,7 +15,8 @@ class MessageDispatcherBaseTest(TestCase):
     dispatcher: MessageDispatcher
     message: Any
 
-    def dummy_message(self, type="test", **kwargs):
+    @staticmethod
+    def dummy_message(type="test", **kwargs):
         return {"type": type, "name": "testclient", **kwargs}
 
     def _set_true_handler(self, message, var="message"):
@@ -120,10 +121,19 @@ class MessageDispatcherBasicsTestCase(MessageDispatcherBaseTest):
             self.dispatcher.register_handler("test", MessageWithoutType, self._set_true_handler, match_type=True)
         self.assertIn("class definition does not set a `type` field", str(e.exception))
 
+    def test_no_message_handling_after_shutdown(self):
+        handler = mock.MagicMock()
+        self.dispatcher.register_handler("test", ZMQMessage, handler, register_schema=False, match_type=False)
+        self.dispatcher.dispatch("test", {"type": "test"})
+        self.assertEqual(1, handler.call_count)
+        self.dispatcher.shutdown()
+        self.dispatcher.dispatch("test", {"type": "test"})
+        self.assertEqual(1, handler.call_count)
+
 
 class MessageDispatcherWithoutExecutorTestCase(MessageDispatcherBaseTest):
     def test_exception_in_handler(self):
-        def raises_exception(message):
+        def raises_exception(_):
             raises_exception.register_schema = False
             raise Exception("something broke!")
 
@@ -133,7 +143,7 @@ class MessageDispatcherWithoutExecutorTestCase(MessageDispatcherBaseTest):
         self.assertIn("something broke!", cm.output[0])
 
     def test_validation_error(self):
-        def handler(x):
+        def handler(_):
             pass
 
         handler.register_schema = False

openmodule-13.6.0/tests/test_logging.py

@@ -0,0 +1,29 @@
+import io
+import logging
+from unittest import TestCase, mock
+
+import openmodule.logging
+
+
+class LoggingTestCase(TestCase):
+    def test_logging_to_stdout(self):
+        logging.basicConfig(force=True)  # reset logging
+        stdout = io.StringIO()
+        stderr = io.StringIO()
+        with mock.patch("sys.stdout.write", stdout.write), mock.patch("sys.stderr.write", stderr.write):
+            logging.warning("test")
+        self.assertNotIn("test", stdout.getvalue())
+        self.assertIn("test", stderr.getvalue())
+
+        core = mock.MagicMock()
+        core.config.LOG_LEVEL = logging.INFO
+        for h in logging.root.handlers[:]:  # reset logging again
+            logging.root.removeHandler(h)
+            h.close()
+        openmodule.logging.init_logging(core)
+        stdout = io.StringIO()
+        stderr = io.StringIO()
+        with mock.patch("sys.stdout.write", stdout.write), mock.patch("sys.stderr.write", stderr.write):
+            logging.warning("test")
+        self.assertIn("test", stdout.getvalue())
+        self.assertNotIn("test", stderr.getvalue())

{openmodule-13.5.0 → openmodule-13.6.0}/tests/test_messaging.py

@@ -8,7 +8,8 @@ import orjson
 import zmq
 
 from openmodule.config import override_context
-from openmodule.messaging import get_pub_socket, get_sub_socket, receive_message_from_socket, wait_for_connection
+from openmodule.messaging import get_sub_socket, receive_message_from_socket, wait_for_connection, \
+    _internal_get_pub_socket, get_pub_socket
 from openmodule_test.core import OpenModuleCoreTestMixin
 from openmodule_test.zeromq import TestBroker, fake_config, TestClient
 
@@ -29,7 +30,7 @@ class MessagingTest(TestCase):
         self.broker = TestBroker(sub, pub)
         self.broker.start()
 
-        self.pub_socket = get_pub_socket(self.broker.context, fake_config(self.broker))
+        self.pub_socket = _internal_get_pub_socket(self.broker.context, fake_config(self.broker))
         self.sub_socket = get_sub_socket(self.broker.context, fake_config(self.broker))
         self.sub_socket.subscribe(b"topic")
 
@@ -102,6 +103,11 @@ class MessagingTest(TestCase):
         self.assertEqual(res, (None, None))
         self.assertIn("not a dict", str(cm.output))
 
+    def disallow_pub_socket_creation(self):
+        with self.assertRaises(AssertionError) as e:
+            get_pub_socket(self.broker.context, fake_config(self.broker))
+        self.assertIn("OM-697, OM-700", str(e.exception))
+
 
 class WaitForConnectionTestCase(OpenModuleCoreTestMixin, TestCase):
     protocol = "tcp://"
@@ -110,13 +116,13 @@ class WaitForConnectionTestCase(OpenModuleCoreTestMixin, TestCase):
         wait_for_connection(self.core.messages)
 
     def test_wait_for_connection(self):
-        pub_socket = get_pub_socket(self.zmq_context(), self.zmq_config())
+        pub_socket = _internal_get_pub_socket(self.zmq_context(), self.zmq_config())
         wait_for_connection(self.core.messages, pub_socket)
 
     def test_wait_for_connection_timeout(self):
         try:
             with override_context(BROKER_SUB="tcp://127.0.0.1:900"):
-                incorrect_pub_socket = get_pub_socket(self.zmq_context(), self.zmq_config())
+                incorrect_pub_socket = _internal_get_pub_socket(self.zmq_context(), self.zmq_config())
 
             with self.assertRaises(TimeoutError):
                 wait_for_connection(self.core.messages, incorrect_pub_socket, timeout=3)

{openmodule-13.5.0 → openmodule-13.6.0}/tests/test_rpc.py

@@ -102,7 +102,7 @@ class RPCResponseWithStatus(OpenModuleModel):
     status = "bad"
 
 
-class RPCServerTestCase(RPCServerTestMixin):
+class RPCServerTestCase(RPCServerTestMixin, OpenModuleCoreTestMixin):
     rpc_channels = ["channel", "channel2", "a", "ab"]
     topics = ["test"]
 
@@ -465,7 +465,7 @@ class RPCServerTestCase(RPCServerTestMixin):
         def publishing_handler(*_, **__):
             """test handler which publishes a message"""
             message = ZMQMessage(type="abc")
-            message.publish_on_topic(self.server.pub, "test")
+            self.core.publish(message, "test")
 
         self.server.register_handler("channel", "test", EmptyModel, EmptyModel, publishing_handler)
         self.wait_for_rpc_server(self.server)
@@ -748,5 +748,3 @@ class RPCServerMultithreadingTest(OpenModuleCoreTestMixin, RPCServerTestMixin, T
             self.rpc_no_response("test", "test", EmptyModel())
             self.zmq_client.wait_for_message_on_topic("sentry")
         self.assertTrue(cm.output)
-
-

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

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

openmodule-13.5.0/tests/test_core.py

@@ -1,48 +0,0 @@
-from unittest import TestCase
-
-from openmodule_test.core import OpenModuleCoreTestMixin
-
-from openmodule.alert import AlertHandleType
-from openmodule.config import override_settings
-from openmodule.core import core, init_openmodule, shutdown_openmodule
-from openmodule_test.alert import AlertTestMixin
-from openmodule_test.health import HealthTestMixin
-
-
-class OpenModuleCoreTest(AlertTestMixin, HealthTestMixin, TestCase):
-    topics = ["healthpong", "sentry", "alert"]
-    protocol = "tcp://"
-
-    @override_settings(NAME="x123x")
-    def test_core_init_and_shutdown(self):
-        self.assertIsNone(core())
-
-        init_openmodule(self.zmq_config())
-        try:
-            self.assertIsNotNone(core())
-            self.wait_for_health(name="x123x")
-        finally:
-            shutdown_openmodule()
-
-    @override_settings(DEBUG=False, TESTING=False)
-    def test_core_sentry_error_logging(self):
-        # sentry is not active during unittests / debug
-        init_openmodule(self.zmq_config())
-        self.wait_for_health()
-
-        try:
-            core().log.error("some-error-message")
-            sentry_message = self.zmq_client.wait_for_message_on_topic("sentry")
-            self.assertIn("some-error-message", str(sentry_message))
-        finally:
-            shutdown_openmodule()
-
-    def test_core_alerts(self):
-        init_openmodule(self.zmq_config())
-        self.wait_for_health()
-
-        try:
-            core().alerts.send("some_type", AlertHandleType.state_change)
-            self.assertAlert(alert_type="some_type")
-        finally:
-            shutdown_openmodule()