indexify 0.3.9__py3-none-any.whl → 0.3.10__py3-none-any.whl

indexify/executor/monitoring/metrics.py

@@ -0,0 +1,245 @@
+import prometheus_client
+
+_INF = float("inf")
+
+
+def latency_metric_for_fast_operation(
+    operation_name: str, operation_description: str
+) -> prometheus_client.Histogram:
+    """Creates a histogram metric for latency of a fast operation.
+
+    A fast operation is typically expected to complete in a few tens of milliseconds."""
+    return prometheus_client.Histogram(
+        f"{operation_name}_latency_seconds",
+        f"Latency of {operation_description}",
+        # Buckets are in seconds
+        buckets=[
+            _ms_to_sec(1),
+            _ms_to_sec(2),
+            _ms_to_sec(3),
+            _ms_to_sec(4),
+            _ms_to_sec(5),
+            _ms_to_sec(6),
+            _ms_to_sec(7),
+            _ms_to_sec(8),
+            _ms_to_sec(9),
+            _ms_to_sec(10),
+            _ms_to_sec(15),
+            _ms_to_sec(20),
+            _ms_to_sec(25),
+            _ms_to_sec(30),
+            _ms_to_sec(35),
+            _ms_to_sec(40),
+            _ms_to_sec(45),
+            _ms_to_sec(50),
+            _ms_to_sec(55),
+            _ms_to_sec(60),
+            _ms_to_sec(65),
+            _ms_to_sec(70),
+            _ms_to_sec(75),
+            _ms_to_sec(80),
+            _ms_to_sec(85),
+            _ms_to_sec(90),
+            _ms_to_sec(95),
+            _ms_to_sec(100),
+            _ms_to_sec(150),
+            _ms_to_sec(200),
+            _ms_to_sec(250),
+            _ms_to_sec(300),
+            _ms_to_sec(350),
+            _ms_to_sec(400),
+            _ms_to_sec(450),
+            _ms_to_sec(500),
+            _ms_to_sec(550),
+            _ms_to_sec(600),
+            _ms_to_sec(650),
+            _ms_to_sec(700),
+            _ms_to_sec(750),
+            _ms_to_sec(800),
+            _ms_to_sec(850),
+            _ms_to_sec(900),
+            _ms_to_sec(950),
+            1,
+            _ms_to_sec(1050),
+            _ms_to_sec(1100),
+            _ms_to_sec(1150),
+            _ms_to_sec(1200),
+            _ms_to_sec(1250),
+            _ms_to_sec(1300),
+            _ms_to_sec(1350),
+            _ms_to_sec(1400),
+            _ms_to_sec(1450),
+            _ms_to_sec(1500),
+            _ms_to_sec(1550),
+            _ms_to_sec(1600),
+            _ms_to_sec(1650),
+            _ms_to_sec(1700),
+            _ms_to_sec(1750),
+            _ms_to_sec(1800),
+            _ms_to_sec(1850),
+            _ms_to_sec(1900),
+            _ms_to_sec(1950),
+            2,
+            _ms_to_sec(2100),
+            _ms_to_sec(2200),
+            _ms_to_sec(2300),
+            _ms_to_sec(2400),
+            _ms_to_sec(2500),
+            _ms_to_sec(2600),
+            _ms_to_sec(2700),
+            _ms_to_sec(2800),
+            _ms_to_sec(2900),
+            3,
+            _ms_to_sec(3500),
+            4,
+            _ms_to_sec(4500),
+            5,
+            10,
+            60,
+            _INF,
+        ],
+    )
+
+
+def latency_metric_for_slow_operation(
+    operation_name: str, operation_description: str
+) -> prometheus_client.Histogram:
+    """Creates a histogram metric for latency of a slow operation.
+
+    A slow operation is typically expected to complete within a few tens of seconds."""
+    return prometheus_client.Histogram(
+        f"{operation_name}_latency_seconds",
+        f"Latency of {operation_description}",
+        # Buckets are in seconds
+        buckets=[
+            _ms_to_sec(10),
+            _ms_to_sec(20),
+            _ms_to_sec(30),
+            _ms_to_sec(40),
+            _ms_to_sec(50),
+            _ms_to_sec(60),
+            _ms_to_sec(70),
+            _ms_to_sec(80),
+            _ms_to_sec(90),
+            _ms_to_sec(100),
+            _ms_to_sec(200),
+            _ms_to_sec(300),
+            _ms_to_sec(400),
+            _ms_to_sec(500),
+            _ms_to_sec(600),
+            _ms_to_sec(700),
+            _ms_to_sec(800),
+            _ms_to_sec(900),
+            1,
+            2,
+            3,
+            4,
+            5,
+            6,
+            7,
+            8,
+            9,
+            10,
+            15,
+            20,
+            25,
+            30,
+            35,
+            40,
+            45,
+            50,
+            _minutes_to_sec(1),
+            _minutes_to_sec(2),
+            _minutes_to_sec(3),
+            _minutes_to_sec(4),
+            _minutes_to_sec(5),
+            _minutes_to_sec(6),
+            _minutes_to_sec(7),
+            _minutes_to_sec(8),
+            _minutes_to_sec(9),
+            _minutes_to_sec(10),
+            _minutes_to_sec(20),
+            _INF,
+        ],
+    )
+
+
+def latency_metric_for_customer_controlled_operation(
+    operation_name: str, operation_description: str
+) -> prometheus_client.Histogram:
+    """Creates a histogram metric for latency of a customer controlled operation.
+
+    Example of a customer controlled operation is executing customer code.
+    The buckets in this histrogram tend to be quite large because we don't
+    know how long customer code will take to execute and because we don't need
+    a precise understanding of its duration."""
+    return prometheus_client.Histogram(
+        f"{operation_name}_latency_seconds",
+        f"Latency of {operation_description}",
+        # Buckets are in seconds
+        buckets=[
+            _ms_to_sec(1),
+            _ms_to_sec(5),
+            _ms_to_sec(50),
+            _ms_to_sec(100),
+            _ms_to_sec(200),
+            _ms_to_sec(300),
+            _ms_to_sec(400),
+            _ms_to_sec(500),
+            1,
+            2,
+            3,
+            4,
+            5,
+            6,
+            7,
+            8,
+            9,
+            10,
+            15,
+            20,
+            30,
+            40,
+            50,
+            _minutes_to_sec(1),
+            _minutes_to_sec(2),
+            _minutes_to_sec(3),
+            _minutes_to_sec(4),
+            _minutes_to_sec(5),
+            _minutes_to_sec(6),
+            _minutes_to_sec(7),
+            _minutes_to_sec(8),
+            _minutes_to_sec(9),
+            _minutes_to_sec(10),
+            _minutes_to_sec(20),
+            _minutes_to_sec(30),
+            _minutes_to_sec(40),
+            _minutes_to_sec(50),
+            _hours_to_sec(1),
+            _hours_to_sec(2),
+            _hours_to_sec(3),
+            _hours_to_sec(4),
+            _hours_to_sec(5),
+            _hours_to_sec(10),
+            _hours_to_sec(20),
+            _days_to_sec(1),
+            _days_to_sec(2),
+            _INF,
+        ],
+    )
+
+
+def _ms_to_sec(ms: int) -> float:
+    return ms / 1000.0
+
+
+def _minutes_to_sec(minutes: int) -> float:
+    return minutes * 60.0
+
+
+def _hours_to_sec(hours: int) -> float:
+    return _minutes_to_sec(hours * 60)
+
+
+def _days_to_sec(days: int) -> float:
+    return _hours_to_sec(days * 24)

indexify/executor/monitoring/prometheus_metrics_handler.py

@@ -0,0 +1,18 @@
+import asyncio
+
+from aiohttp import web
+from prometheus_client import CONTENT_TYPE_LATEST, generate_latest
+
+from .handler import Handler
+
+
+class PrometheusMetricsHandler(Handler):
+    async def handle(self, request: web.Request) -> web.Response:
+        # Run the synchronous metrics generation code in ThreadPool thread
+        # to not block the main asyncio loop.
+        return await asyncio.to_thread(self._handle_sync)
+
+    def _handle_sync(self) -> web.Response:
+        return web.Response(
+            body=generate_latest(), headers={"Content-Type": CONTENT_TYPE_LATEST}
+        )

indexify/executor/monitoring/server.py

@@ -0,0 +1,41 @@
+from aiohttp import web
+
+from .handler import Handler
+
+
+class MonitoringServer:
+    def __init__(
+        self,
+        host: str,
+        port: int,
+        startup_probe_handler: Handler,
+        health_probe_handler: Handler,
+        metrics_handler: Handler,
+    ):
+        self._host = host
+        self._port = port
+        self._app: web.Application = web.Application()
+        self._app.add_routes(
+            [
+                web.get("/monitoring/startup", startup_probe_handler.handle),
+                web.get("/monitoring/health", health_probe_handler.handle),
+                web.get("/monitoring/metrics", metrics_handler.handle),
+            ]
+        )
+        self._app_runner: web.AppRunner = web.AppRunner(self._app)
+
+    async def run(self):
+        await self._app_runner.setup()
+        site = web.TCPSite(
+            runner=self._app_runner,
+            host=self._host,
+            port=self._port,
+            # Allow to listen when there's a closed socket in TIME_WAIT state
+            reuse_address=True,
+            # Don't allow other TCP sockets to actively listen on this address
+            reuse_port=False,
+        )
+        await site.start()
+
+    async def shutdown(self):
+        await self._app_runner.cleanup()

indexify/executor/monitoring/startup_probe_handler.py

@@ -0,0 +1,17 @@
+from aiohttp import web
+
+from .handler import Handler
+
+
+class StartupProbeHandler(Handler):
+    def __init__(self):
+        self._ready = False
+
+    def set_ready(self):
+        self._ready = True
+
+    async def handle(self, request: web.Request) -> web.Response:
+        if self._ready:
+            return web.json_response({"status": "ok"})
+        else:
+            return web.json_response({"status": "nok"}, status=503)

indexify/executor/task_fetcher.py

@@ -1,5 +1,5 @@
 import json
-from importlib.metadata import version
+import time
 from typing import AsyncGenerator, List, Optional
 
 import structlog
@@ -7,6 +7,11 @@ from httpx_sse import aconnect_sse
 from tensorlake.utils.http_client import get_httpx_client
 
 from .api_objects import ExecutorMetadata, FunctionURI, Task
+from .metrics.task_fetcher import (
+    metric_server_registration_errors,
+    metric_server_registration_latency,
+    metric_server_registrations,
+)
 from .runtime_probes import ProbeInfo, RuntimeProbes
 
 
@@ -48,6 +53,9 @@ class TaskFetcher:
             url=url,
             executor_version=self._executor_metadata.executor_version,
         )
+        metric_server_registrations.inc()
+        registration_start_time: float = time.monotonic()
+
         async with get_httpx_client(
             config_path=self.config_path, make_async=True
         ) as client:
@@ -61,16 +69,22 @@ class TaskFetcher:
                 try:
                     event_source.response.raise_for_status()
                 except Exception as e:
+                    metric_server_registration_errors.inc()
                     await event_source.response.aread()
                     raise Exception(
                         "failed to register at server. "
                         f"Response code: {event_source.response.status_code}. "
                         f"Response text: '{event_source.response.text}'."
                     ) from e
+                finally:
+                    metric_server_registration_latency.observe(
+                        time.monotonic() - registration_start_time
+                    )
 
                 self._logger.info(
                     "executor_registered", executor_id=self._executor_metadata.id
                 )
+
                 async for sse in event_source.aiter_sse():
                     task_dicts = json.loads(sse.data)
                     for task_dict in task_dicts:

indexify/executor/task_reporter.py

@@ -7,7 +7,17 @@ from httpx import Timeout
 from tensorlake.function_executor.proto.function_executor_pb2 import FunctionOutput
 from tensorlake.utils.http_client import get_httpx_client
 
-from .api_objects import RouterOutput, TaskResult
+from .api_objects import (
+    TASK_OUTCOME_FAILURE,
+    TASK_OUTCOME_SUCCESS,
+    RouterOutput,
+    TaskResult,
+)
+from .metrics.task_reporter import (
+    metric_server_ingest_files_errors,
+    metric_server_ingest_files_latency,
+    metric_server_ingest_files_requests,
+)
 from .task_runner import TaskOutput
 
 
@@ -77,13 +87,17 @@ class TaskReporter:
         }
 
         start_time = time.time()
-        # Run in a separate thread to not block the main event loop.
-        response = await asyncio.to_thread(
-            self._client.post, url=f"{self._base_url}/internal/ingest_files", **kwargs
-        )
+        with metric_server_ingest_files_latency.time():
+            metric_server_ingest_files_requests.inc()
+            # Run in a separate thread to not block the main event loop.
+            response = await asyncio.to_thread(
+                self._client.post,
+                url=f"{self._base_url}/internal/ingest_files",
+                **kwargs,
+            )
         end_time = time.time()
         logger.info(
-            "task_outcome_reported",
+            "task outcome reported",
             response_time=end_time - start_time,
             response_code=response.status_code,
         )
@@ -91,6 +105,7 @@ class TaskReporter:
         try:
             response.raise_for_status()
         except Exception as e:
+            metric_server_ingest_files_errors.inc()
             # Caller catches and logs the exception.
             raise Exception(
                 "failed to report task outcome. "
@@ -115,7 +130,9 @@ class TaskReporter:
         if output is None:
             return task_result, output_files, summary
 
-        task_result.outcome = "success" if output.success else "failure"
+        task_result.outcome = (
+            TASK_OUTCOME_SUCCESS if output.success else TASK_OUTCOME_FAILURE
+        )
         task_result.reducer = output.reducer
 
         _process_function_output(

indexify/executor/task_runner.py

@@ -1,14 +1,27 @@
-import asyncio
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
 from .api_objects import Task
 from .function_executor.function_executor_state import FunctionExecutorState
+from .function_executor.function_executor_states_container import (
+    FunctionExecutorStatesContainer,
+    function_id_with_version,
+)
 from .function_executor.server.function_executor_server_factory import (
     FunctionExecutorServerFactory,
 )
 from .function_executor.single_task_runner import SingleTaskRunner
 from .function_executor.task_input import TaskInput
 from .function_executor.task_output import TaskOutput
+from .metrics.task_runner import (
+    metric_task_policy_errors,
+    metric_task_policy_latency,
+    metric_task_policy_runs,
+    metric_task_run_latency,
+    metric_task_run_platform_errors,
+    metric_task_runs,
+    metric_tasks_blocked_by_policy,
+    metric_tasks_running,
+)
 
 
 class TaskRunner:
@@ -21,8 +34,9 @@ class TaskRunner:
         executor_id: str,
         function_executor_server_factory: FunctionExecutorServerFactory,
         base_url: str,
-        config_path: Optional[str],
         disable_automatic_function_executor_management: bool,
+        function_executor_states: FunctionExecutorStatesContainer,
+        config_path: Optional[str],
     ):
         self._executor_id: str = executor_id
         self._factory: FunctionExecutorServerFactory = function_executor_server_factory
@@ -31,41 +45,61 @@ class TaskRunner:
         self._disable_automatic_function_executor_management: bool = (
             disable_automatic_function_executor_management
         )
-        # The fields below are protected by the lock.
-        self._lock: asyncio.Lock = asyncio.Lock()
-        self._is_shutdown: bool = False
-        self._function_executor_states: Dict[str, FunctionExecutorState] = {}
+        self._function_executor_states: FunctionExecutorStatesContainer = (
+            function_executor_states
+        )
 
     async def run(self, task_input: TaskInput, logger: Any) -> TaskOutput:
         logger = logger.bind(module=__name__)
+        state: Optional[FunctionExecutorState] = None
+
         try:
-            return await self._run(task_input, logger)
+            with (
+                metric_task_policy_errors.count_exceptions(),
+                metric_tasks_blocked_by_policy.track_inprogress(),
+                metric_task_policy_latency.time(),
+            ):
+                metric_task_policy_runs.inc()
+                state = await self._acquire_function_executor_for_task_execution(
+                    task_input, logger
+                )
+
+            with (
+                metric_task_run_platform_errors.count_exceptions(),
+                metric_tasks_running.track_inprogress(),
+                metric_task_run_latency.time(),
+            ):
+                metric_task_runs.inc()
+                return await self._run_task(state, task_input, logger)
         except Exception as e:
             logger.error(
                 "failed running the task:",
                 exc_info=e,
             )
             return TaskOutput.internal_error(task_input.task)
+        finally:
+            if state is not None:
+                state.lock.release()
+
+    async def _acquire_function_executor_for_task_execution(
+        self, task_input: TaskInput, logger: Any
+    ) -> FunctionExecutorState:
+        """Waits untils the task acquires a Function Executor state where the task can run.
+
+        The returned Function Executor state is locked and the caller is responsible for releasing the lock.
+        """
+        logger.info("task is blocked by policy")
+        state = await self._function_executor_states.get_or_create_state(
+            task_input.task
+        )
+        await state.lock.acquire()
 
-    async def _run(self, task_input: TaskInput, logger: Any) -> TaskOutput:
-        state = await self._get_or_create_state(task_input.task)
-        async with state.lock:
+        try:
             await self._run_task_policy(state, task_input.task)
-            return await self._run_task(state, task_input, logger)
-
-    async def _get_or_create_state(self, task: Task) -> FunctionExecutorState:
-        async with self._lock:
-            if self._is_shutdown:
-                raise RuntimeError("Task runner is shutting down.")
-
-            id = _function_id_without_version(task)
-            if id not in self._function_executor_states:
-                state = FunctionExecutorState(
-                    function_id_with_version=_function_id_with_version(task),
-                    function_id_without_version=id,
-                )
-                self._function_executor_states[id] = state
-            return self._function_executor_states[id]
+            return state
+        except Exception:
+            state.lock.release()
+            raise
 
     async def _run_task_policy(self, state: FunctionExecutorState, task: Task) -> None:
         # Current policy for running tasks:
@@ -80,15 +114,16 @@ class TaskRunner:
         if self._disable_automatic_function_executor_management:
             return  # Disable Function Executor destroy in manual management mode.
 
-        if state.function_id_with_version != _function_id_with_version(task):
+        if state.function_id_with_version != function_id_with_version(task):
             await state.destroy_function_executor()
-            state.function_id_with_version = _function_id_with_version(task)
+            state.function_id_with_version = function_id_with_version(task)
             # At this point the state belongs to the version of the function from the task
             # and there are no running tasks in the Function Executor.
 
     async def _run_task(
         self, state: FunctionExecutorState, task_input: TaskInput, logger: Any
     ) -> TaskOutput:
+        logger.info("task execution started")
         runner: SingleTaskRunner = SingleTaskRunner(
             executor_id=self._executor_id,
             function_executor_state=state,
@@ -101,21 +136,4 @@ class TaskRunner:
         return await runner.run()
 
     async def shutdown(self) -> None:
-        # Function Executors are outside the Executor process
-        # so they need to get cleaned up explicitly and reliably.
-        async with self._lock:
-            self._is_shutdown = True  # No new Function Executor States can be created.
-            while self._function_executor_states:
-                id, state = self._function_executor_states.popitem()
-                # Only ongoing tasks who have a reference to the state already can see it.
-                async with state.lock:
-                    await state.shutdown()
-                    # The task running inside the Function Executor will fail because it's destroyed.
-
-
-def _function_id_with_version(task: Task) -> str:
-    return f"versioned/{task.namespace}/{task.compute_graph}/{task.graph_version}/{task.compute_fn}"
-
-
-def _function_id_without_version(task: Task) -> str:
-    return f"not_versioned/{task.namespace}/{task.compute_graph}/{task.compute_fn}"
+        pass

{indexify-0.3.9.dist-info → indexify-0.3.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: indexify
-Version: 0.3.9
+Version: 0.3.10
 Summary: Open Source Indexify components and helper tools
 Home-page: https://github.com/tensorlakeai/indexify
 License: Apache 2.0
@@ -14,15 +14,17 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: aiohttp (>=3.11.0,<4.0.0)
 Requires-Dist: grpcio (==1.70.0)
 Requires-Dist: httpx-sse (>=0.4.0,<0.5.0)
 Requires-Dist: httpx[http2] (>=0.27,<0.28)
 Requires-Dist: nanoid (>=2.0.0,<3.0.0)
+Requires-Dist: prometheus-client (>=0.21.1,<0.22.0)
 Requires-Dist: pydantic (==2.10.4)
 Requires-Dist: pyyaml (>=6,<7)
 Requires-Dist: rich (>=13.9.2,<14.0.0)
 Requires-Dist: structlog (>=24.4.0,<25.0.0)
-Requires-Dist: tensorlake (>=0.1.16)
+Requires-Dist: tensorlake (>=0.1.20)
 Requires-Dist: typer (>=0.12,<0.13)
 Project-URL: Repository, https://github.com/tensorlakeai/indexify
 Description-Content-Type: text/markdown

indexify-0.3.10.dist-info/RECORD

@@ -0,0 +1,46 @@
+indexify/cli/cli.py,sha256=ssXc0zalHS7vbCvetZ0cX4BkxIuPIw590jam3c2YVME,10532
+indexify/executor/README.md,sha256=ozC6_hMkhQQNVCMEpBxwiUALz6lwErPQxNxQfQDqnG4,2029
+indexify/executor/api_objects.py,sha256=TaYwDoo7EjuLBusxH512-KdvAJRtBwbEP2IObWraabU,1100
+indexify/executor/downloader.py,sha256=XjaGCzsGM3ex2HxbKGkIsB50OhlXgdnywWGCjUBdW2k,8127
+indexify/executor/executor.py,sha256=hij_EkB1_lueakCf3pfi_0O3wxSLYFBkvbpwlsMm-ao,9784
+indexify/executor/function_executor/function_executor.py,sha256=BxNhsW0uXxKjdKT5ixMAyIo5F7otdIT2c0FMQ09Lsrs,10234
+indexify/executor/function_executor/function_executor_state.py,sha256=IWPLWa7LaN0Eq8PDu-0kFzkuKJB0COShu7wCO1oyiNA,3141
+indexify/executor/function_executor/function_executor_states_container.py,sha256=x4hlF7ZBWswk9dkA06Rvgeqar6H9TWjZ7Etyy2CzBDE,2682
+indexify/executor/function_executor/health_checker.py,sha256=YT24ajPLdYOpdt2UNyJGviGbivCDXIJpeQOxQofcl50,3258
+indexify/executor/function_executor/invocation_state_client.py,sha256=p-xgM4__cHR1ApvMV9hShrGWee_Je0VDhICZUGjpQY4,9644
+indexify/executor/function_executor/metrics/function_executor.py,sha256=y36cgZEp949HPCBVFF6uFQIxk2PvnSI74QSbxcAalI4,5659
+indexify/executor/function_executor/metrics/function_executor_state.py,sha256=M7cMA7JY8_8FW9xjuSqtp6o2xxUgB31LJowo7kzcexg,352
+indexify/executor/function_executor/metrics/function_executor_state_container.py,sha256=6rrAfml-TivjkHatCM4BLY7jmVs523Wzb6QIysncc-0,302
+indexify/executor/function_executor/metrics/health_checker.py,sha256=EaeIYJPrQ-qqNMGZVGkvjPoeQSCl4FzPKXEv3Cly1NE,456
+indexify/executor/function_executor/metrics/invocation_state_client.py,sha256=6FCW6rXHVZZSmwLquZdpjgQPSmE_99naDLke5rZiwMI,1867
+indexify/executor/function_executor/metrics/single_task_runner.py,sha256=7BJlGkdPGKeufMs3zWNO_1GRVzjINRY5rW3Mp4oWWec,805
+indexify/executor/function_executor/server/client_configuration.py,sha256=gOywMus0cotlX6NKIadEJwvOmBE-LbGE_wvoMi5-HzY,994
+indexify/executor/function_executor/server/function_executor_server.py,sha256=_DLivLDikupZusRk8gVWDk7fWPT9XjZ4un1yWSlOObs,883
+indexify/executor/function_executor/server/function_executor_server_factory.py,sha256=oBEuOwuGsZrvOZsv9v8M4JEtfproirE-cH28XCr0HoY,1739
+indexify/executor/function_executor/server/subprocess_function_executor_server.py,sha256=JekDOqF7oFD4J6zcN3xB0Dxd1cgpEXMOsb_rKZOeBlI,668
+indexify/executor/function_executor/server/subprocess_function_executor_server_factory.py,sha256=xm_EL2Gouwi0qAuKsyJVAQJRBZ0VB-NYsWUM4mOi3nQ,4187
+indexify/executor/function_executor/single_task_runner.py,sha256=Td28vF6pNemKZEs4mNWeLKzy22XRmmMVgp2ipYO_OXU,9262
+indexify/executor/function_executor/task_input.py,sha256=wSrHR4m0juiGClQyeVdhRC37QzDt6Rrjq-ZXJkfBi9k,584
+indexify/executor/function_executor/task_output.py,sha256=Qg7vojYi0WmeHRf2qlC-5h46jcwis13EgiN63OmWpcg,1229
+indexify/executor/metrics/downloader.py,sha256=lctPh8xjkXeLEFJnl1hNrD1yEhLhIl5sggsR4Yoe_Zc,2746
+indexify/executor/metrics/executor.py,sha256=UkJTa8NerbdC1p7jrwl4obLUS2xGSzEYwONPZpoKhT0,2064
+indexify/executor/metrics/task_fetcher.py,sha256=iJEwCLzYr2cuz7hRvNiqaa2nvQP4OrA0hm0iJY0YKG0,736
+indexify/executor/metrics/task_reporter.py,sha256=zUA9RpkSgx5lG_ZqDDuela5VuhtsnC0IKoQcEvHND0Y,730
+indexify/executor/metrics/task_runner.py,sha256=o5ERNePKPmVKknFoSZUr-r597dEOOWvWn3ocbiL2jxI,1699
+indexify/executor/monitoring/function_allowlist.py,sha256=wUGeiv3aAGWMlQXzHXq9O6MVHby6Tu-zY4U0MyWiQu0,683
+indexify/executor/monitoring/handler.py,sha256=Cj1cu_LcsAP0tdviqNhoEtGm4h0OJAxxzW9C2YdNXYU,240
+indexify/executor/monitoring/health_check_handler.py,sha256=e1pEtWFKaVs6H57Z4YLejNECrJtC38PweZc7xTJeqVw,695
+indexify/executor/monitoring/health_checker/generic_health_checker.py,sha256=pqytFlv7I7lnzZSzNJiylc-gtDohmuoT-Yb4lxfIe0E,2686
+indexify/executor/monitoring/health_checker/health_checker.py,sha256=c6UooJUIKaj2dYwU3507nnOglU51TC4FB9npCnLHjbY,838
+indexify/executor/monitoring/metrics.py,sha256=Dx2wPcTKvbd5Y5rGOfeyscFtAQ2DZ16_s5BX6d4nhI8,6660
+indexify/executor/monitoring/prometheus_metrics_handler.py,sha256=KiGqSf7rkXTfbDwThyXFpFe2jnuZD5q-5SBP_0GDo8Y,591
+indexify/executor/monitoring/server.py,sha256=yzdYhcxnmY6uTQUMt3vatF5jilN52ZtfFseOmHyQpTo,1254
+indexify/executor/monitoring/startup_probe_handler.py,sha256=zXXsBU15SMlBx1bSFpxWDfed1VHtKKnwvLQ8-frpG98,425
+indexify/executor/runtime_probes.py,sha256=bo6Dq6AGZpJH099j0DHtVSDEH80tv3j9MXf3VXSx_p8,2182
+indexify/executor/task_fetcher.py,sha256=NpFfHgaY99bSL-K2D5kcDAMNUG2FArq0-qF_mgF-LBQ,3375
+indexify/executor/task_reporter.py,sha256=t7FzSKV7fG1fEtxyTcFh-sTWZ8WXApbG-qXaAMq_gRQ,7363
+indexify/executor/task_runner.py,sha256=tcS7hHdSVQexC3XEIsDTwX51bJK4iSQqC8CbWeNoud0,5590
+indexify-0.3.10.dist-info/METADATA,sha256=WZfdgioEIs_yVFdyELZb9NLcHeKxgsxmxouLpKsZpZM,1428
+indexify-0.3.10.dist-info/WHEEL,sha256=RaoafKOydTQ7I_I3JTrPCg6kUmTgtm4BornzOqyEfJ8,88
+indexify-0.3.10.dist-info/entry_points.txt,sha256=GU9wmsgvN7nQw3N2X0PMYn1RSvF6CrhH9RuC2D8d3Gk,53
+indexify-0.3.10.dist-info/RECORD,,