canvas 0.35.0__tar.gz → 0.35.1__tar.gz

{canvas-0.35.0 → canvas-0.35.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: canvas
-Version: 0.35.0
+Version: 0.35.1
 Summary: SDK to customize event-driven actions in your Canvas instance
 Author-email: Canvas Team <engineering@canvasmedical.com>
 License-Expression: MIT
@@ -18,7 +18,7 @@ Requires-Dist: ipython<9,>=8.21.0
 Requires-Dist: jsonschema<5,>=4.21.1
 Requires-Dist: keyring
 Requires-Dist: protobuf<5,>=4.25.3
-Requires-Dist: psycopg[binary]<4,>=3.2.2
+Requires-Dist: psycopg[binary,pool]<4,>=3.2.2
 Requires-Dist: pydantic<3,>=2.6.1
 Requires-Dist: pyjwt==2.10.1
 Requires-Dist: python-dotenv<2,>=1.0.1

{canvas-0.35.0 → canvas-0.35.1}/plugin_runner/plugin_runner.py

@@ -1,23 +1,28 @@
-import asyncio
 import json
 import os
 import pathlib
 import pickle
 import pkgutil
 import sys
+import threading
 import traceback
 from collections import defaultdict
-from collections.abc import AsyncGenerator
+from collections.abc import Iterable
+from concurrent.futures import ThreadPoolExecutor
 from http import HTTPStatus
+from time import sleep
 from typing import Any, TypedDict
 
 import grpc
-import redis.asyncio as redis
+import redis
 import sentry_sdk
-from asgiref.sync import sync_to_async
-from django.db import connections
+from django.core.signals import request_finished, request_started
+from redis.backoff import ExponentialBackoff
+from redis.exceptions import ConnectionError, TimeoutError
+from redis.retry import Retry
 from sentry_sdk.integrations.logging import ignore_logger
 
+import settings
 from canvas_generated.messages.effects_pb2 import EffectType
 from canvas_generated.messages.plugins_pb2 import ReloadPluginsRequest, ReloadPluginsResponse
 from canvas_generated.services.plugin_runner_pb2_grpc import (
@@ -29,7 +34,7 @@ from canvas_sdk.effects.simple_api import Response
 from canvas_sdk.events import Event, EventRequest, EventResponse, EventType
 from canvas_sdk.protocols import ClinicalQualityMeasure
 from canvas_sdk.utils import metrics
-from canvas_sdk.utils.metrics import measured, statsd_client
+from canvas_sdk.utils.metrics import measured
 from logger import log
 from plugin_runner.authentication import token_for_plugin
 from plugin_runner.installation import install_plugins
@@ -39,7 +44,6 @@ from settings import (
     CUSTOMER_IDENTIFIER,
     ENV,
     IS_PRODUCTION_CUSTOMER,
-    IS_TESTING,
     MANIFEST_FILE_NAME,
     PLUGIN_DIRECTORY,
     REDIS_ENDPOINT,
@@ -149,33 +153,12 @@ class PluginManifest(TypedDict):
     readme: str
 
 
-@sync_to_async
-def reconnect_if_needed() -> None:
-    """
-    Reconnect to the database if the connection has been closed.
-
-    NOTE: Django database functions are not async-safe and must be called
-    via e.g. sync_to_async. They will silently fail and block the handler
-    if called in an async context directly.
-    """
-    if IS_TESTING:
-        return
-
-    connection = connections["default"]
-
-    if not connection.is_usable():
-        log.debug("Connection was unusable, reconnecting...")
-        connection.connect()
-
-
 class PluginRunner(PluginRunnerServicer):
     """This process runs provided plugins that register interest in incoming events."""
 
     sandbox: Sandbox
 
-    async def HandleEvent(
-        self, request: EventRequest, context: Any
-    ) -> AsyncGenerator[EventResponse, None]:
+    def HandleEvent(self, request: EventRequest, context: Any) -> Iterable[EventResponse]:
         """This is invoked when an event comes in."""
         event = Event(request)
         with metrics.measure(
@@ -190,7 +173,8 @@ class PluginRunner(PluginRunnerServicer):
             sentry_sdk.set_tag("event-name", event_name)
 
             if relevant_plugins:
-                await reconnect_if_needed()
+                # Send the Django request_started signal
+                request_started.send(sender=self.__class__)
 
             if event_type in [EventType.PLUGIN_CREATED, EventType.PLUGIN_UPDATED]:
                 plugin_name = event.target.id
@@ -238,7 +222,7 @@ class PluginRunner(PluginRunnerServicer):
                             "event": event_name,
                         },
                     ):
-                        _effects = await sync_to_async(handler.compute)()
+                        _effects = handler.compute()
                         effects = [
                             Effect(
                                 type=effect.type,
@@ -286,24 +270,30 @@ class PluginRunner(PluginRunnerServicer):
 
             # Don't log anything if a plugin handler didn't actually run.
             if relevant_plugins:
+                # Send the Django request_finished signal
+                request_finished.send(sender=self.__class__)
+
                 log.info(f"Responded to Event {event_name}.")
 
             yield EventResponse(success=True, effects=effect_list)
 
-    async def ReloadPlugins(
+    def ReloadPlugins(
         self, request: ReloadPluginsRequest, context: Any
-    ) -> AsyncGenerator[ReloadPluginsResponse, None]:
+    ) -> Iterable[ReloadPluginsResponse]:
         """This is invoked when we need to reload plugins."""
         log.info("Reloading plugins...")
         try:
-            await publish_message(message={"action": "reload"})
+            publish_message(message={"action": "reload"})
         except ImportError:
             yield ReloadPluginsResponse(success=False)
         else:
             yield ReloadPluginsResponse(success=True)
 
 
-async def synchronize_plugins(run_once: bool = False) -> None:
+STOP_SYNCHRONIZER = threading.Event()
+
+
+def synchronize_plugins(run_once: bool = False) -> None:
     """
     Listen for messages on the pubsub channel that will indicate it is
     necessary to reinstall and reload plugins.
@@ -312,16 +302,10 @@ async def synchronize_plugins(run_once: bool = False) -> None:
 
     _, pubsub = get_client()
 
-    await pubsub.psubscribe(CHANNEL_NAME)
-
-    while True:
-        message = await pubsub.get_message(ignore_subscribe_messages=True, timeout=5.0)
-
-        await pubsub.check_health()
+    pubsub.psubscribe(CHANNEL_NAME)
 
-        if not pubsub.connection.is_connected:  # type: ignore
-            log.info("synchronize_plugins: reconnecting to Redis")
-            await pubsub.connection.connect()  # type: ignore
+    while not STOP_SYNCHRONIZER.is_set():
+        message = pubsub.get_message(ignore_subscribe_messages=True, timeout=5.0)
 
         if message is None:
             continue
@@ -357,21 +341,21 @@ async def synchronize_plugins(run_once: bool = False) -> None:
             break
 
 
-async def synchronize_plugins_and_report_errors() -> None:
+def synchronize_plugins_and_report_errors() -> None:
     """
     Run synchronize_plugins() in perpetuity and report any encountered errors.
     """
     log.info("synchronize_plugins: starting loop...")
 
-    while True:
+    while not STOP_SYNCHRONIZER.is_set():
         try:
-            await synchronize_plugins()
+            synchronize_plugins()
         except Exception as e:
             log.error(f"synchronize_plugins: error: {e}")
             sentry_sdk.capture_exception(e)
 
         # don't crush redis if we're retrying in a tight loop
-        await asyncio.sleep(0.5)
+        sleep(0.5)
 
 
 def validate_effects(effects: list[Effect]) -> list[Effect]:
@@ -434,17 +418,22 @@ def find_modules(base_path: pathlib.Path, prefix: str | None = None) -> list[str
     return modules
 
 
-async def publish_message(message: dict) -> None:
+def publish_message(message: dict) -> None:
     """Publish a message to the pubsub channel."""
     log.info(f'Publishing message to pubsub channel "{CHANNEL_NAME}"')
     client, _ = get_client()
 
-    await client.publish(CHANNEL_NAME, pickle.dumps(message))
+    client.publish(CHANNEL_NAME, pickle.dumps(message))
 
 
 def get_client() -> tuple[redis.Redis, redis.client.PubSub]:
-    """Return an async Redis client and pubsub object."""
-    client = redis.Redis.from_url(REDIS_ENDPOINT)
+    """Return a Redis client and pubsub object."""
+    client = redis.from_url(
+        REDIS_ENDPOINT,
+        retry=Retry(backoff=ExponentialBackoff(), retries=10),
+        retry_on_error=[ConnectionError, TimeoutError, ConnectionResetError],
+        health_check_interval=1,
+    )
     pubsub = client.pubsub()
 
     return client, pubsub
@@ -594,62 +583,41 @@ def load_plugins(specified_plugin_paths: list[str] | None = None) -> None:
 
     refresh_event_type_map()
 
-    for key in EventType.keys():  # noqa: SIM118
-        value = len(EVENT_HANDLER_MAP[key]) if key in EVENT_HANDLER_MAP else 0
-        statsd_client.gauge("plugins.event_handler_count", value, tags={"event": key})
-
-
-_cleanup_coroutines = []
 
-
-async def serve(specified_plugin_paths: list[str] | None = None) -> None:
-    """Run the server."""
+# NOTE: specified_plugin_paths powers the `canvas run-plugins` command
+def main(specified_plugin_paths: list[str] | None = None) -> None:
+    """Run the server and the synchronize_plugins loop."""
     port = "50051"
 
-    server = grpc.aio.server()
+    executor = ThreadPoolExecutor(max_workers=settings.PLUGIN_RUNNER_MAX_WORKERS)
+    server = grpc.server(thread_pool=executor)
     server.add_insecure_port("127.0.0.1:" + port)
 
     add_PluginRunnerServicer_to_server(PluginRunner(), server)
 
     log.info(f"Starting server, listening on port {port}")
 
-    # Only install plugins if the plugin runner was not started from the CLI
+    # Only install plugins and start the synchronizer thread if the plugin runner was not started
+    # from the CLI
+    synchronizer_thread = threading.Thread(target=synchronize_plugins_and_report_errors)
     if specified_plugin_paths is None:
         install_plugins()
+        STOP_SYNCHRONIZER.clear()
+        synchronizer_thread.start()
 
     load_plugins(specified_plugin_paths)
 
-    await server.start()
-
-    async def server_graceful_shutdown() -> None:
-        log.info("Starting graceful shutdown...")
-        await server.stop(5)
-
-    _cleanup_coroutines.append(server_graceful_shutdown())
-
-    await server.wait_for_termination()
-
-
-# NOTE: specified_plugin_paths powers the `canvas run-plugins` command
-def main(specified_plugin_paths: list[str] | None = None) -> None:
-    """Run the server and the synchronize_plugins loop."""
-    loop = asyncio.new_event_loop()
-
-    asyncio.set_event_loop(loop)
+    server.start()
 
     try:
-        coroutines = [serve(specified_plugin_paths)]
-
-        # Only start the synchronizer if the plugin runner was not started from the CLI
-        if specified_plugin_paths is None:
-            coroutines.append(synchronize_plugins_and_report_errors())
-
-        loop.run_until_complete(asyncio.gather(*coroutines))
+        server.wait_for_termination()
     except KeyboardInterrupt:
         pass
     finally:
-        loop.run_until_complete(*_cleanup_coroutines)
-        loop.close()
+        executor.shutdown(wait=True, cancel_futures=True)
+        if synchronizer_thread.is_alive():
+            STOP_SYNCHRONIZER.set()
+            synchronizer_thread.join()
 
 
 if __name__ == "__main__":

{canvas-0.35.0 → canvas-0.35.1}/pubsub/pubsub.py

@@ -2,6 +2,9 @@ import os
 from typing import Any
 
 import redis
+from redis.backoff import ExponentialBackoff
+from redis.exceptions import ConnectionError, TimeoutError
+from redis.retry import Retry
 
 REDIS_ENDPOINT = os.getenv("REDIS_ENDPOINT")
 CUSTOMER_IDENTIFIER = os.getenv("CUSTOMER_IDENTIFIER")
@@ -24,7 +27,13 @@ class PubSubBase:
 
     def _create_client(self) -> redis.Redis | None:
         if self.redis_endpoint and self.channel:
-            return redis.Redis.from_url(self.redis_endpoint, decode_responses=True)
+            return redis.Redis.from_url(
+                self.redis_endpoint,
+                decode_responses=True,
+                retry=Retry(backoff=ExponentialBackoff(), retries=10),
+                retry_on_error=[ConnectionError, TimeoutError, ConnectionResetError],
+                health_check_interval=1,
+            )
 
         return None
 

{canvas-0.35.0 → canvas-0.35.1}/pyproject.toml

@@ -9,7 +9,6 @@ dev = [
   "mypy",
   "pre-commit",
   "pytest",
-  "pytest-asyncio>=0.24,<0.26",
   "pytest-mock",
   "python-semantic-release",
   "requests-mock",
@@ -34,7 +33,7 @@ dependencies = [
   "jsonschema>=4.21.1,<5",
   "keyring",
   "protobuf>=4.25.3,<5",
-  "psycopg[binary]>=3.2.2,<4",
+  "psycopg[binary,pool]>=3.2.2,<4",
   "pydantic>=2.6.1,<3",
   "pyjwt==2.10.1",
   "python-dotenv>=1.0.1,<2",
@@ -53,7 +52,7 @@ license = "MIT"
 name = "canvas"
 readme = "README.md"
 requires-python = ">=3.11,<3.13"
-version = "0.35.0"
+version = "0.35.1"
 
 [project.scripts]
 canvas = "canvas_cli.main:app"
@@ -119,7 +118,6 @@ init_typed = true
 
 [tool.pytest.ini_options]
 addopts = "--durations=5 --durations-min=0.25 --pdbcls=IPython.terminal.debugger:TerminalPdb"
-asyncio_default_fixture_loop_scope = "session"
 filterwarnings = [
   'ignore:No directory at.*static.*:UserWarning:whitenoise.base',
   'ignore:SelectableGroups dict interface is deprecated. .*:DeprecationWarning'

{canvas-0.35.0 → canvas-0.35.1}/settings.py

@@ -46,12 +46,15 @@ CANVAS_SDK_DB_PASSWORD = os.getenv("CANVAS_SDK_DB_PASSWORD", "app")
 CANVAS_SDK_DB_HOST = os.getenv("CANVAS_SDK_DB_HOST", "home-app-db")
 CANVAS_SDK_DB_PORT = os.getenv("CANVAS_SDK_DB_PORT", "5432")
 
+PLUGIN_RUNNER_MAX_WORKERS = int(os.getenv("PLUGIN_RUNNER_MAX_WORKERS", 5))
+
 if os.getenv("DATABASE_URL"):
     parsed_url = parse.urlparse(os.getenv("DATABASE_URL"))
 
     DATABASES = {
         "default": {
             "ENGINE": "django.db.backends.postgresql",
+            "OPTIONS": {"pool": {"min_size": 2, "max_size": PLUGIN_RUNNER_MAX_WORKERS}},
             "NAME": parsed_url.path[1:],
             "USER": os.getenv("CANVAS_SDK_DATABASE_ROLE"),
             "PASSWORD": os.getenv("CANVAS_SDK_DATABASE_ROLE_PASSWORD"),
@@ -63,6 +66,7 @@ else:
     DATABASES = {
         "default": {
             "ENGINE": "django.db.backends.postgresql",
+            "OPTIONS": {"pool": {"min_size": 2, "max_size": PLUGIN_RUNNER_MAX_WORKERS}},
             "NAME": CANVAS_SDK_DB_NAME,
             "USER": CANVAS_SDK_DB_USERNAME,
             "PASSWORD": CANVAS_SDK_DB_PASSWORD,