flagsmith-common 2.2.1__tar.gz → 2.2.3__tar.gz

{flagsmith_common-2.2.1 → flagsmith_common-2.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flagsmith-common
-Version: 2.2.1
+Version: 2.2.3
 Summary: Flagsmith's common library
 License-Expression: BSD-3-Clause
 License-File: LICENSE

{flagsmith_common-2.2.1 → flagsmith_common-2.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flagsmith-common"
-version = "2.2.1"
+version = "2.2.3"
 description = "Flagsmith's common library"
 requires-python = ">=3.11,<4.0"
 dependencies = [

{flagsmith_common-2.2.1 → flagsmith_common-2.2.3}/src/common/core/main.py

@@ -2,14 +2,15 @@ import contextlib
 import logging
 import os
 import sys
-import tempfile
 import typing
 
 from django.core.management import (
     execute_from_command_line as django_execute_from_command_line,
 )
+from environs import Env
 
 from common.core.cli import healthcheck
+from common.core.utils import TemporaryDirectory
 
 logger = logging.getLogger(__name__)
 
@@ -30,6 +31,7 @@ def ensure_cli_env() -> typing.Generator[None, None, None]:
         main()
     ```
     """
+    env = Env()
     ctx = contextlib.ExitStack()
 
     # TODO @khvn26 Move logging setup to here
@@ -43,9 +45,11 @@ def ensure_cli_env() -> typing.Generator[None, None, None]:
     os.environ.setdefault("DJANGO_SETTINGS_MODULE", "settings.dev")
 
     # Set up Prometheus' multiprocess mode
-    if "PROMETHEUS_MULTIPROC_DIR" not in os.environ:
-        prometheus_multiproc_dir_name = tempfile.mkdtemp()
-
+    if not env.str("PROMETHEUS_MULTIPROC_DIR", ""):
+        delete = not env.bool("PROMETHEUS_MULTIPROC_DIR_KEEP", False)
+        prometheus_multiproc_dir_name = ctx.enter_context(
+            TemporaryDirectory(delete=delete)
+        )
         logger.info(
             "Created %s for Prometheus multi-process mode",
             prometheus_multiproc_dir_name,

{flagsmith_common-2.2.1 → flagsmith_common-2.2.3}/src/common/core/utils.py

@@ -2,9 +2,18 @@ import json
 import logging
 import pathlib
 import random
+import sys
+import tempfile
 from functools import lru_cache
 from itertools import cycle
-from typing import Iterator, Literal, NotRequired, TypedDict, TypeVar, get_args
+from typing import (
+    Iterator,
+    Literal,
+    NotRequired,
+    TypedDict,
+    TypeVar,
+    get_args,
+)
 
 from django.conf import settings
 from django.contrib.auth import get_user_model
@@ -186,3 +195,40 @@ def using_database_replica(
         return manager
 
     return manager.db_manager(chosen_replica)
+
+
+if sys.version_info >= (3, 12):
+    # Already has the desired behavior; re-export for uniform imports.
+    TemporaryDirectory = tempfile.TemporaryDirectory
+else:
+    import contextlib
+    from typing import ContextManager, Generator
+
+    def TemporaryDirectory(
+        suffix: str | None = None,
+        prefix: str | None = None,
+        dir: str | None = None,
+        *,
+        delete: bool = True,
+    ) -> ContextManager[str]:
+        """
+        Create a temporary directory with optional cleanup control.
+
+        This wrapper exists because Python 3.12 changed TemporaryDirectory's behavior
+        by adding a 'delete' parameter, which doesn't exist in Python 3.11. This
+        function provides a consistent API across both versions.
+
+        When delete=True, uses the stdlib's TemporaryDirectory (auto-cleanup).
+        When delete=False, creates a directory with mkdtemp that persists after
+        the context manager exits, matching Python 3.12's delete=False behavior.
+
+        See https://docs.python.org/3.12/library/tempfile.html#tempfile.TemporaryDirectory for usage details.
+        """
+        if delete:
+            return tempfile.TemporaryDirectory(suffix, prefix, dir)
+
+        @contextlib.contextmanager
+        def _tmpdir() -> Generator[str, None, None]:
+            yield tempfile.mkdtemp(suffix, prefix, dir)
+
+        return _tmpdir()

{flagsmith_common-2.2.1 → flagsmith_common-2.2.3}/src/task_processor/processor.py

@@ -128,12 +128,17 @@ def _run_task(
     )
     task_run: AnyTaskRun = task.task_runs.model(started_at=timezone.now(), task=task)  # type: ignore[attr-defined]
     result: str
+    executor = None
 
     try:
-        with ThreadPoolExecutor(max_workers=1) as executor:
-            future = executor.submit(task.run)
-            timeout = task.timeout.total_seconds() if task.timeout else None
-            future.result(timeout=timeout)  # Wait for completion or timeout
+        # Use explicit executor management to avoid blocking on shutdown
+        # when tasks timeout but continue running in worker threads.
+        # The default context manager behavior (wait=True) would block
+        # the TaskRunner thread indefinitely waiting for stuck workers.
+        executor = ThreadPoolExecutor(max_workers=1)
+        future = executor.submit(task.run)
+        timeout = task.timeout.total_seconds() if task.timeout else None
+        future.result(timeout=timeout)  # Wait for completion or timeout
 
         task_run.result = result = TaskResult.SUCCESS.value
         task_run.finished_at = timezone.now()
@@ -176,6 +181,13 @@ def _run_task(
                     delay_until,
                 )
 
+    finally:
+        # Always shutdown the executor without waiting for worker threads.
+        # This prevents the TaskRunner thread from blocking indefinitely
+        # when a task times out but continues running in a worker thread.
+        if executor is not None:
+            executor.shutdown(wait=False)
+
     labels = {
         "task_identifier": task_identifier,
         "task_type": registered_task.task_type.value.lower(),