canvas 0.34.1__py3-none-any.whl → 0.35.1__py3-none-any.whl

plugin_runner/plugin_runner.py

@@ -1,24 +1,28 @@
-import asyncio
 import json
 import os
 import pathlib
 import pickle
 import pkgutil
 import sys
-import time
+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 +33,8 @@ from canvas_sdk.effects import Effect
 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.stats import get_duration_ms, statsd_client
+from canvas_sdk.utils import metrics
+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,164 +153,147 @@ 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_start_time = time.time()
         event = Event(request)
-        event_type = event.type
-        event_name = event.name
-        relevant_plugins = EVENT_HANDLER_MAP[event_name]
-        relevant_plugin_handlers = []
-
-        log.debug(f"Processing {relevant_plugins} for {event_name}")
-        sentry_sdk.set_tag("event-name", event_name)
-
-        if relevant_plugins:
-            await reconnect_if_needed()
-
-        if event_type in [EventType.PLUGIN_CREATED, EventType.PLUGIN_UPDATED]:
-            plugin_name = event.target.id
-            # filter only for the plugin(s) that were created/updated
-            relevant_plugins = [p for p in relevant_plugins if p.startswith(f"{plugin_name}:")]
-        elif event_type in {EventType.SIMPLE_API_AUTHENTICATE, EventType.SIMPLE_API_REQUEST}:
-            # The target plugin's name will be part of the home-app URL path, so other plugins that
-            # respond to SimpleAPI request events are not relevant
-            plugin_name = event.context["plugin_name"]
-            relevant_plugins = [p for p in relevant_plugins if p.startswith(f"{plugin_name}:")]
-
-        effect_list = []
-
-        for plugin_name in relevant_plugins:
-            log.debug(f"Processing {plugin_name}")
-            sentry_sdk.set_tag("plugin-name", plugin_name)
-
-            plugin = LOADED_PLUGINS[plugin_name]
-            handler_class = plugin["class"]
-            base_plugin_name = plugin_name.split(":")[0]
+        with metrics.measure(
+            metrics.get_qualified_name(self.HandleEvent), extra_tags={"event": event.name}
+        ):
+            event_type = event.type
+            event_name = event.name
+            relevant_plugins = EVENT_HANDLER_MAP[event_name]
+            relevant_plugin_handlers = []
+
+            log.debug(f"Processing {relevant_plugins} for {event_name}")
+            sentry_sdk.set_tag("event-name", event_name)
+
+            if relevant_plugins:
+                # 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
+                # filter only for the plugin(s) that were created/updated
+                relevant_plugins = [p for p in relevant_plugins if p.startswith(f"{plugin_name}:")]
+            elif event_type in {EventType.SIMPLE_API_AUTHENTICATE, EventType.SIMPLE_API_REQUEST}:
+                # The target plugin's name will be part of the home-app URL path, so other plugins that
+                # respond to SimpleAPI request events are not relevant
+                plugin_name = event.context["plugin_name"]
+                relevant_plugins = [p for p in relevant_plugins if p.startswith(f"{plugin_name}:")]
+
+            effect_list = []
+
+            for plugin_name in relevant_plugins:
+                log.debug(f"Processing {plugin_name}")
+                sentry_sdk.set_tag("plugin-name", plugin_name)
+
+                plugin = LOADED_PLUGINS[plugin_name]
+                handler_class = plugin["class"]
+                base_plugin_name = plugin_name.split(":")[0]
+
+                secrets = plugin.get("secrets", {})
+
+                secrets.update(
+                    {"graphql_jwt": token_for_plugin(plugin_name=plugin_name, audience="home")}
+                )
 
-            secrets = plugin.get("secrets", {})
+                try:
+                    handler = handler_class(event, secrets, ENVIRONMENT)
 
-            secrets.update(
-                {"graphql_jwt": token_for_plugin(plugin_name=plugin_name, audience="home")}
-            )
+                    if not handler.accept_event():
+                        continue
+                    relevant_plugin_handlers.append(handler_class)
 
-            try:
-                handler = handler_class(event, secrets, ENVIRONMENT)
-
-                if not handler.accept_event():
+                    classname = (
+                        handler.__class__.__name__
+                        if isinstance(handler, ClinicalQualityMeasure)
+                        else None
+                    )
+                    handler_name = metrics.get_qualified_name(handler.compute)
+                    with metrics.measure(
+                        name=handler_name,
+                        extra_tags={
+                            "plugin": base_plugin_name,
+                            "event": event_name,
+                        },
+                    ):
+                        _effects = handler.compute()
+                        effects = [
+                            Effect(
+                                type=effect.type,
+                                payload=effect.payload,
+                                plugin_name=base_plugin_name,
+                                classname=classname,
+                                handler_name=handler_name,
+                            )
+                            for effect in _effects
+                        ]
+
+                        effects = validate_effects(effects)
+
+                        apply_effects_to_context(effects, event=event)
+
+                        log.info(f"{plugin_name}.compute() completed.")
+
+                except Exception as e:
+                    log.error(f"Encountered exception in plugin {plugin_name}:")
+
+                    for error_line_with_newlines in traceback.format_exception(e):
+                        for error_line in error_line_with_newlines.split("\n"):
+                            log.error(error_line)
+
+                    sentry_sdk.capture_exception(e)
                     continue
-                relevant_plugin_handlers.append(handler_class)
 
-                classname = (
-                    handler.__class__.__name__
-                    if isinstance(handler, ClinicalQualityMeasure)
-                    else None
-                )
-
-                compute_start_time = time.time()
-                _effects = await sync_to_async(handler.compute)()
-                effects = [
-                    Effect(
-                        type=effect.type,
-                        payload=effect.payload,
-                        plugin_name=base_plugin_name,
-                        classname=classname,
+                effect_list += effects
+
+            sentry_sdk.set_tag("plugin-name", None)
+
+            # Special handling for SimpleAPI requests: if there were no relevant handlers (as determined
+            # by calling ignore_event on handlers), then set the effects list to be a single 404 Not
+            # Found response effect. If multiple handlers were able to respond, log an error and set the
+            # effects list to be a single 500 Internal Server Error response effect.
+            if event.type in {EventType.SIMPLE_API_AUTHENTICATE, EventType.SIMPLE_API_REQUEST}:
+                if len(relevant_plugin_handlers) == 0:
+                    effect_list = [Response(status_code=HTTPStatus.NOT_FOUND).apply()]
+                elif len(relevant_plugin_handlers) > 1:
+                    log.error(
+                        f"Multiple handlers responded to {EventType.Name(EventType.SIMPLE_API_REQUEST)}"
+                        f" {event.context['path']}"
                     )
-                    for effect in _effects
-                ]
-
-                effects = validate_effects(effects)
-
-                apply_effects_to_context(effects, event=event)
-
-                compute_duration = get_duration_ms(compute_start_time)
-
-                log.info(f"{plugin_name}.compute() completed ({compute_duration} ms)")
-                statsd_client.timing(
-                    "plugins.protocol_duration_ms",
-                    delta=compute_duration,
-                    tags={"plugin": plugin_name},
-                )
-            except Exception as e:
-                log.error(f"Encountered exception in plugin {plugin_name}:")
-
-                for error_line_with_newlines in traceback.format_exception(e):
-                    for error_line in error_line_with_newlines.split("\n"):
-                        log.error(error_line)
-
-                sentry_sdk.capture_exception(e)
+                    effect_list = [Response(status_code=HTTPStatus.INTERNAL_SERVER_ERROR).apply()]
 
-                continue
-
-            effect_list += effects
-
-        sentry_sdk.set_tag("plugin-name", None)
-
-        # Special handling for SimpleAPI requests: if there were no relevant handlers (as determined
-        # by calling ignore_event on handlers), then set the effects list to be a single 404 Not
-        # Found response effect. If multiple handlers were able to respond, log an error and set the
-        # effects list to be a single 500 Internal Server Error response effect.
-        if event.type in {EventType.SIMPLE_API_AUTHENTICATE, EventType.SIMPLE_API_REQUEST}:
-            if len(relevant_plugin_handlers) == 0:
-                effect_list = [Response(status_code=HTTPStatus.NOT_FOUND).apply()]
-            elif len(relevant_plugin_handlers) > 1:
-                log.error(
-                    f"Multiple handlers responded to {EventType.Name(EventType.SIMPLE_API_REQUEST)}"
-                    f" {event.context['path']}"
-                )
-                effect_list = [Response(status_code=HTTPStatus.INTERNAL_SERVER_ERROR).apply()]
-
-        event_duration = get_duration_ms(event_start_time)
+            # 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__)
 
-        # Don't log anything if a plugin handler didn't actually run.
-        if relevant_plugins:
-            log.info(f"Responded to Event {event_name} ({event_duration} ms)")
-            statsd_client.timing(
-                "plugins.event_duration_ms", delta=event_duration, tags={"event": event_name}
-            )
+                log.info(f"Responded to Event {event_name}.")
 
-        yield EventResponse(success=True, effects=effect_list)
+            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.
@@ -315,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)
+    pubsub.psubscribe(CHANNEL_NAME)
 
-        await pubsub.check_health()
-
-        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
@@ -360,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]:
@@ -437,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
@@ -560,6 +546,7 @@ def refresh_event_type_map() -> None:
                 log.warning(f"Unknown RESPONDS_TO type: {type(responds_to)}")
 
 
+@measured
 def load_plugins(specified_plugin_paths: list[str] | None = None) -> None:
     """Load the plugins."""
     # first mark each plugin as inactive since we want to remove it from
@@ -596,67 +583,41 @@ def load_plugins(specified_plugin_paths: list[str] | None = None) -> None:
 
     refresh_event_type_map()
 
-    log_nr_event_handlers()
-
-
-def log_nr_event_handlers() -> None:
-    """Log the number of event handlers for each event."""
-    for key in EventType.keys():  # noqa: SIM118
-        value = len(EVENT_HANDLER_MAP[key]) if key in EVENT_HANDLER_MAP else 0
-        statsd_client.timing("plugins.event_nr_handlers", 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__":

plugin_runner/sandbox.py

@@ -217,6 +217,9 @@ STANDARD_LIBRARY_MODULES = {
         "uuid4",
         "UUID",
     },
+    "zoneinfo": {
+        "ZoneInfo",
+    },
 }
 
 

protobufs/canvas_generated/messages/effects.proto

@@ -169,6 +169,12 @@ enum EffectType {
   COMMIT_REFER_COMMAND = 142;
   ENTER_IN_ERROR_REFER_COMMAND = 143;
 
+  ORIGINATE_CHANGE_MEDICATION_COMMAND = 150;
+  EDIT_CHANGE_MEDICATION_COMMAND = 151;
+  DELETE_CHANGE_MEDICATION_COMMAND = 152;
+  COMMIT_CHANGE_MEDICATION_COMMAND = 153;
+  ENTER_IN_ERROR_CHANGE_MEDICATION_COMMAND = 154;
+
   CREATE_QUESTIONNAIRE_RESULT = 138;
 
   ANNOTATE_PATIENT_CHART_CONDITION_RESULTS = 200;
@@ -256,6 +262,12 @@ enum EffectType {
   SIMPLE_API_RESPONSE = 4000;
 
   UPDATE_USER = 5000;
+
+  CREATE_NOTE = 6000;
+  CREATE_APPOINTMENT = 6001;
+  CREATE_SCHEDULE_EVENT = 6002;
+
+  CREATE_PATIENT = 6003;
 }
 
 message Effect {
@@ -263,6 +275,7 @@ message Effect {
   string payload = 2;
   string plugin_name = 3;
   string classname = 4;
+  string handler_name = 5;
   //Oneof effect_payload {
   //  ...
   //}

protobufs/canvas_generated/messages/events.proto

@@ -1028,6 +1028,22 @@ enum EventType {
   DEFER_CODING_GAP_COMMAND__POST_EXECUTE_ACTION = 60011;
   DEFER_CODING_GAP_COMMAND__POST_INSERTED_INTO_NOTE = 60012;
 
+  CHANGE_MEDICATION_COMMAND__PRE_ORIGINATE = 61000;
+  CHANGE_MEDICATION_COMMAND__POST_ORIGINATE = 61001;
+  CHANGE_MEDICATION_COMMAND__PRE_UPDATE = 61002;
+  CHANGE_MEDICATION_COMMAND__POST_UPDATE = 61003;
+  CHANGE_MEDICATION_COMMAND__PRE_COMMIT = 61004;
+  CHANGE_MEDICATION_COMMAND__POST_COMMIT = 61005;
+  CHANGE_MEDICATION_COMMAND__PRE_DELETE = 61006;
+  CHANGE_MEDICATION_COMMAND__POST_DELETE = 61007;
+  CHANGE_MEDICATION_COMMAND__PRE_ENTER_IN_ERROR = 61008;
+  CHANGE_MEDICATION_COMMAND__POST_ENTER_IN_ERROR = 61009;
+  CHANGE_MEDICATION_COMMAND__PRE_EXECUTE_ACTION = 61010;
+  CHANGE_MEDICATION_COMMAND__POST_EXECUTE_ACTION = 61011;
+  CHANGE_MEDICATION_COMMAND__POST_INSERTED_INTO_NOTE = 61012;
+  CHANGE_MEDICATION__MEDICATION__PRE_SEARCH = 61013;
+  CHANGE_MEDICATION__MEDICATION__POST_SEARCH = 61014;
+
   SHOW_NOTE_HEADER_BUTTON = 70000;
   SHOW_NOTE_FOOTER_BUTTON = 70001;
   ACTION_BUTTON_CLICKED = 70002;

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
 

settings.py

@@ -14,6 +14,7 @@ ENV = os.getenv("ENV", "development")
 IS_PRODUCTION = ENV == "production"
 IS_PRODUCTION_CUSTOMER = env_to_bool("IS_PRODUCTION_CUSTOMER", IS_PRODUCTION)
 IS_TESTING = env_to_bool("IS_TESTING", "pytest" in sys.argv[0] or sys.argv[0] == "-c")
+IS_SCRIPT = env_to_bool("IS_SCRIPT", "plugin_runner.py" not in sys.argv[0])
 CUSTOMER_IDENTIFIER = os.getenv("CUSTOMER_IDENTIFIER", "local")
 APP_NAME = os.getenv("APP_NAME")
 
@@ -24,6 +25,9 @@ INTEGRATION_TEST_CLIENT_SECRET = os.getenv("INTEGRATION_TEST_CLIENT_SECRET")
 GRAPHQL_ENDPOINT = os.getenv("GRAPHQL_ENDPOINT", "http://localhost:8000/plugins-graphql")
 REDIS_ENDPOINT = os.getenv("REDIS_ENDPOINT", f"redis://{APP_NAME}-redis:6379")
 
+
+METRICS_ENABLED = env_to_bool("PLUGINS_METRICS_ENABLED", not IS_SCRIPT)
+
 INSTALLED_APPS = [
     "canvas_sdk.v1",
 ]
@@ -42,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"),
@@ -59,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,