ls-algorithm-plugin-sdk 0.3.3__tar.gz → 0.3.4__tar.gz

{ls_algorithm_plugin_sdk-0.3.3 → ls_algorithm_plugin_sdk-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ls-algorithm-plugin-sdk
-Version: 0.3.3
+Version: 0.3.4
 Summary: Protocol-independent runtime SDK for dataset algorithms
 Author: Ling Robotics
 License: Proprietary

{ls_algorithm_plugin_sdk-0.3.3 → ls_algorithm_plugin_sdk-0.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ls-algorithm-plugin-sdk"
-version = "0.3.3"
+version = "0.3.4"
 description = "Protocol-independent runtime SDK for dataset algorithms"
 readme = "README.md"
 requires-python = ">=3.10"

{ls_algorithm_plugin_sdk-0.3.3 → ls_algorithm_plugin_sdk-0.3.4}/src/algorithm_plugin_sdk/cli_impl/configure.py

@@ -62,6 +62,16 @@ def configure_parser(parser: argparse.ArgumentParser) -> None:
         help="maximum concurrent executions (default: GPU count, or 1)",
     )
     parser.add_argument("--scratch-dir")
+    parser.add_argument(
+        "--local-scratch",
+        action="store_true",
+        help="override request scratchRoot with <repository>/.scratch",
+    )
+    parser.add_argument(
+        "--local-output",
+        action="store_true",
+        help="override request output paths with <repository>/.output/<job-id>",
+    )
     parser.add_argument(
         "--gpu-ids",
         type=gpu_ids,
@@ -409,6 +419,8 @@ def generate_config(
         webui=args.webui,
         max_concurrency=max_concurrency,
         scratch_dir=args.scratch_dir,
+        local_scratch=args.local_scratch,
+        local_output=args.local_output,
         token=args.service_token,
         registration=registration_from_args(args, repository),
         gpu_ids=args.gpu_ids,

{ls_algorithm_plugin_sdk-0.3.3 → ls_algorithm_plugin_sdk-0.3.4}/src/algorithm_plugin_sdk/cli_impl/serve.py

@@ -81,6 +81,8 @@ def configure_parser(parser: argparse.ArgumentParser) -> None:
 def execute(args: argparse.Namespace) -> int:
     config: DeploymentConfig | None = None
     service: dict[str, object] | None = None
+    local_scratch = False
+    local_output = False
     if args.config:
         # Apply the process mask before refreshing/loading the algorithm.  A
         # repository module may import CUDA during module import.
@@ -91,6 +93,8 @@ def execute(args: argparse.Namespace) -> int:
         args.port = int(service["port"])
         args.max_concurrent_executions = int(service["maxConcurrency"])
         args.scratch_dir = service.get("scratchDir")
+        local_scratch = bool(service.get("localScratch", False))
+        local_output = bool(service.get("localOutput", False))
         args.gpu_ids = list(service.get("gpuIds", []))
         args.webui = bool(service.get("webui"))
         values = config.process_environment()
@@ -120,6 +124,8 @@ def execute(args: argparse.Namespace) -> int:
         ),
         max_concurrent_executions=args.max_concurrent_executions,
         scratch_dir=args.scratch_dir,
+        local_scratch=local_scratch,
+        local_output=local_output,
         gpu_ids=args.gpu_ids,
         runner_factory=create_runner,
         max_attempts=args.max_attempts,

{ls_algorithm_plugin_sdk-0.3.3 → ls_algorithm_plugin_sdk-0.3.4}/src/algorithm_plugin_sdk/deployment.py

@@ -146,6 +146,8 @@ class DeploymentConfig:
         gpu_ids: list[int] | None = None,
         environment: dict[str, str] | None = None,
         default_parameters: dict[str, Any] | None = None,
+        local_scratch: bool = False,
+        local_output: bool = False,
     ) -> "DeploymentConfig":
         repository = repository_root(root)
         _make_repository_importable(repository)
@@ -189,6 +191,8 @@ class DeploymentConfig:
                 "webui": webui,
                 "maxConcurrency": max_concurrency,
                 "scratchDir": _absolute(scratch_dir, repository),
+                "localScratch": local_scratch,
+                "localOutput": local_output,
                 "gpuIds": configured_gpu_ids,
                 "token": token or None,
                 "defaultParameters": dict(default_parameters or {}),
@@ -268,6 +272,9 @@ class DeploymentConfig:
             raise RuntimeError("service port must be in [1, 65535]")
         if concurrency < 1:
             raise RuntimeError("service maxConcurrency must be positive")
+        for name in ("localScratch", "localOutput"):
+            if not isinstance(service.get(name, False), bool):
+                raise RuntimeError(f"service {name} must be a boolean")
         gpu_ids = service.get("gpuIds")
         if not isinstance(gpu_ids, list) or any(
             isinstance(gpu_id, bool) or not isinstance(gpu_id, int) or gpu_id < 0

ls_algorithm_plugin_sdk-0.3.4/src/algorithm_plugin_sdk/log_manager.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+import json
+import logging
+import re
+import threading
+from pathlib import Path
+from typing import Any
+
+from .context import utc_now
+
+_SAFE_NAME = re.compile(r"[^A-Za-z0-9._-]+")
+_TIMESTAMP_GLOB = "[0-9]" * 14
+_FILE_LOCKS_GUARD = threading.Lock()
+_FILE_LOCKS: dict[Path, threading.RLock] = {}
+
+
+def _safe_name(value: str) -> str:
+    cleaned = _SAFE_NAME.sub("_", str(value).strip()).strip("._")
+    return cleaned or "job"
+
+
+def _file_lock(path: Path) -> threading.RLock:
+    with _FILE_LOCKS_GUARD:
+        return _FILE_LOCKS.setdefault(path, threading.RLock())
+
+
+def _timestamp_prefix() -> str:
+    return utc_now().replace("-", "").replace(":", "").replace("T", "")[:14]
+
+
+def _job_log_path(directory: Path, job_id: str) -> Path:
+    safe_job_id = _safe_name(job_id)
+    pattern = f"{_TIMESTAMP_GLOB}-{safe_job_id}.log"
+    with _FILE_LOCKS_GUARD:
+        existing = sorted(directory.glob(pattern))
+        if existing:
+            return existing[0]
+        timestamp = _timestamp_prefix()
+        path = directory / f"{timestamp}-{safe_job_id}.log"
+        path.touch(exist_ok=True)
+        return path
+
+
+class ExecutionLog:
+    """Per-job, line-buffered log sink attached to context.logger."""
+
+    def __init__(
+        self,
+        *,
+        log_dir: str | Path,
+        job_id: str,
+        execution_id: str,
+        logger: logging.Logger,
+        task_id: str | None = None,
+    ) -> None:
+        resolved_task_id = task_id or execution_id
+        self._event_context = {
+            "jobId": job_id,
+            "taskId": resolved_task_id,
+            "executionId": execution_id,
+            "job_id": job_id,
+            "task_id": resolved_task_id,
+            "execution_id": execution_id,
+        }
+        directory = Path(log_dir).expanduser()
+        directory.mkdir(parents=True, exist_ok=True)
+        path = _job_log_path(directory, job_id)
+        self.path = path
+        self._stream = path.open("a", encoding="utf-8", buffering=1)
+        self._lock = _file_lock(path)
+        self._handler = _FlushFileHandler(self._stream, self._lock)
+        self._handler.setFormatter(
+            logging.Formatter(
+                f"%(asctime)s %(levelname)s [executionId={execution_id}] %(message)s"
+            )
+        )
+        self._handler.setLevel(logging.DEBUG)
+        self.logger = logger
+        self.logger.setLevel(logging.DEBUG)
+        self.logger.addHandler(self._handler)
+        self._closed = False
+
+    def write_event(self, event: str, **values: Any) -> None:
+        payload = {
+            "event": event,
+            "timestamp": utc_now(),
+            **self._event_context,
+            **values,
+        }
+        with self._lock:
+            if self._closed:
+                return
+            self._stream.write(json.dumps(payload, ensure_ascii=False, default=str) + "\n")
+            self._stream.flush()
+
+    def close(self) -> None:
+        with self._lock:
+            if self._closed:
+                return
+            self._closed = True
+            self.logger.removeHandler(self._handler)
+            self._handler.close()
+            self._stream.close()
+
+
+class _FlushFileHandler(logging.Handler):
+    def __init__(self, stream: Any, lock: threading.RLock) -> None:
+        super().__init__()
+        self.stream = stream
+        self._lock = lock
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            with self._lock:
+                self.stream.write(self.format(record) + "\n")
+                self.stream.flush()
+        except Exception:
+            self.handleError(record)
+
+    def close(self) -> None:
+        try:
+            self.stream.flush()
+        finally:
+            super().close()

{ls_algorithm_plugin_sdk-0.3.3 → ls_algorithm_plugin_sdk-0.3.4}/src/algorithm_plugin_sdk/service.py

@@ -6,6 +6,7 @@ import logging
 import random
 import threading
 import time
+import traceback
 import uuid
 from concurrent.futures import Future, ThreadPoolExecutor
 from contextlib import asynccontextmanager
@@ -123,6 +124,8 @@ class ExecutionManager:
         scratch_dir: str | None = None,
         repository: str | Path | None = None,
         log_dir: str | Path | None = None,
+        local_scratch: bool = False,
+        local_output: bool = False,
         gpu_ids: list[int] | None = None,
         runner_factory: RunnerFactory | None = None,
         max_attempts: int = MAX_ATTEMPTS,
@@ -138,6 +141,17 @@ class ExecutionManager:
             raise ValueError("retry_seconds must be positive")
         if not 0 <= retry_jitter_ratio <= 1:
             raise ValueError("retry_jitter_ratio must be in [0, 1]")
+        if not isinstance(local_scratch, bool) or not isinstance(
+            local_output, bool
+        ):
+            raise ValueError("local_scratch and local_output must be booleans")
+        repository_path = (
+            Path(repository).expanduser().resolve()
+            if repository is not None
+            else None
+        )
+        if (local_scratch or local_output) and repository_path is None:
+            raise ValueError("repository is required for local scratch or output")
         configured_gpu_ids = None if gpu_ids is None else list(gpu_ids)
         if configured_gpu_ids is not None and (
             any(
@@ -156,10 +170,19 @@ class ExecutionManager:
             raise ValueError("default_parameters must be a JSON object")
         self.default_parameters = dict(default_parameters or {})
         self.scratch_dir = scratch_dir
+        self._local_scratch_root = (
+            repository_path / ".scratch" if local_scratch else None
+        )
+        self._local_output_root = (
+            repository_path / ".output" if local_output else None
+        )
+        for local_root in (self._local_scratch_root, self._local_output_root):
+            if local_root is not None:
+                local_root.mkdir(parents=True, exist_ok=True)
         self.log_dir = (
             Path(log_dir).expanduser()
             if log_dir is not None
-            else (Path(repository).expanduser() / "logs" if repository is not None else None)
+            else (repository_path / "logs" if repository_path is not None else None)
         )
         self.gpu_ids = configured_gpu_ids
         self.max_concurrent_executions = max_concurrent_executions
@@ -191,6 +214,46 @@ class ExecutionManager:
             self.runner.start()
             self._started = True
 
+    def _apply_local_paths(
+        self,
+        request: AlgorithmRequest,
+        job_id: str,
+    ) -> AlgorithmRequest:
+        workspace = dict(request.workspace or {})
+        inputs = request.inputs
+        if self._local_scratch_root is not None:
+            workspace["scratchRoot"] = str(self._local_scratch_root)
+        if self._local_output_root is not None:
+            workspace["outputRoot"] = str(self._local_output_root)
+            job_output = self._job_output_dir(job_id)
+            if len(inputs) == 1:
+                output_paths = [job_output]
+            else:
+                output_paths = [
+                    job_output / f"{index}-{Path(item.output).name or 'output'}"
+                    for index, item in enumerate(inputs)
+                ]
+                for output_path in output_paths:
+                    output_path.mkdir(parents=True, exist_ok=True)
+            inputs = [
+                replace(item, output=str(output_path))
+                for item, output_path in zip(inputs, output_paths)
+            ]
+        return replace(request, inputs=inputs, workspace=workspace or None)
+
+    def _job_output_dir(self, job_id: str) -> Path:
+        assert self._local_output_root is not None
+        if Path(job_id).name != job_id or job_id in {"", ".", ".."}:
+            raise ValueError(f"job ID is unsafe for local output: {job_id!r}")
+        output = (self._local_output_root / job_id).resolve()
+        if (
+            output == self._local_output_root
+            or self._local_output_root not in output.parents
+        ):
+            raise ValueError(f"job output escapes local root: {job_id!r}")
+        output.mkdir(parents=True, exist_ok=True)
+        return output
+
     def submit(
         self,
         request: AlgorithmRequest,
@@ -226,6 +289,7 @@ class ExecutionManager:
         execution_id = f"exec-{uuid.uuid4().hex}"
         resolved_job_id = str(job_id or execution_id)
         resolved_task_id = str(task_id or execution_id)
+        request = self._apply_local_paths(request, resolved_job_id)
         record = ExecutionRecord(
             execution_id=execution_id,
             request=request,
@@ -237,10 +301,9 @@ class ExecutionManager:
         record.context = ExecutionContext(
             execution_id,
             [item.input_dataset for item in request.inputs],
-            scratch_dir=(
-                record.request.workspace["scratchRoot"]
-                if record.request.workspace is not None
-                else self.scratch_dir
+            scratch_dir=(record.request.workspace or {}).get(
+                "scratchRoot",
+                self.scratch_dir,
             ),
             progress_callback=record.add_progress,
         )
@@ -248,6 +311,7 @@ class ExecutionManager:
             record.log = ExecutionLog(
                 log_dir=self.log_dir,
                 job_id=record.job_id,
+                task_id=record.task_id,
                 execution_id=record.execution_id,
                 logger=record.context.logger,
             )
@@ -430,10 +494,16 @@ class ExecutionManager:
                 record.log.write_event("result", state="cancelled", error=str(exc))
         except Exception as exc:
             error = f"{type(exc).__name__}: {exc}"
+            stack_trace = traceback.format_exc()
             record.context.mark_unfinished("failed", error)
             record.set_state("failed", error=error)
             if record.log is not None:
-                record.log.write_event("result", state="failed", error=error)
+                record.log.write_event(
+                    "result",
+                    state="failed",
+                    error=error,
+                    traceback=stack_trace,
+                )
         else:
             record.set_state(result.status, result=result)
             if record.log is not None:
@@ -466,7 +536,7 @@ class ExecutionManager:
                         self.retry_seconds * (1 - self.retry_jitter_ratio),
                         self.retry_seconds * (1 + self.retry_jitter_ratio),
                     )
-                    logger.warning(
+                    record.context.logger.warning(
                         "algorithm execution %s failed on attempt %d/%d; "
                         "releasing and restarting algorithm in %.3f seconds: %s: %s",
                         record.execution_id,
@@ -475,16 +545,18 @@ class ExecutionManager:
                         delay,
                         type(exc).__name__,
                         exc,
+                        exc_info=True,
                     )
                 else:
                     delay = 0.0
-                    logger.error(
+                    record.context.logger.error(
                         "algorithm execution %s exhausted %d attempts; "
                         "releasing and restarting algorithm for future requests: %s: %s",
                         record.execution_id,
                         self.max_attempts,
                         type(exc).__name__,
                         exc,
+                        exc_info=True,
                     )
             finally:
                 self._release_runner()

{ls_algorithm_plugin_sdk-0.3.3 → ls_algorithm_plugin_sdk-0.3.4}/src/ls_algorithm_plugin_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ls-algorithm-plugin-sdk
-Version: 0.3.3
+Version: 0.3.4
 Summary: Protocol-independent runtime SDK for dataset algorithms
 Author: Ling Robotics
 License: Proprietary

{ls_algorithm_plugin_sdk-0.3.3 → ls_algorithm_plugin_sdk-0.3.4}/src/ls_algorithm_plugin_sdk.egg-info/SOURCES.txt

@@ -42,4 +42,5 @@ tests/test_registration.py
 tests/test_release.py
 tests/test_runner.py
 tests/test_sdk_automation.py
+tests/test_serve.py
 tests/test_service.py

{ls_algorithm_plugin_sdk-0.3.3 → ls_algorithm_plugin_sdk-0.3.4}/tests/test_configure.py

@@ -140,6 +140,8 @@ class ConfigureTests(unittest.TestCase):
                 "--no-webui",
                 "--max-concurrency", "3",
                 "--scratch-dir", "scratch",
+                "--local-scratch",
+                "--local-output",
                 "--gpu-ids", "2,0",
                 "--service-token", "secret",
                 "--default-parameters", '{"batchSize": 8, "mode": "fast"}',
@@ -155,6 +157,8 @@ class ConfigureTests(unittest.TestCase):
         self.assertFalse(args.webui)
         self.assertEqual(args.max_concurrency, 3)
         self.assertEqual(args.scratch_dir, "scratch")
+        self.assertTrue(args.local_scratch)
+        self.assertTrue(args.local_output)
         self.assertEqual(args.gpu_ids, [2, 0])
         self.assertEqual(args.service_token, "secret")
         self.assertEqual(
@@ -186,6 +190,8 @@ class ConfigureTests(unittest.TestCase):
                 "--local",
                 "--config-output", "algorithm-plugin.json",
                 "--gpu-ids", "3,1",
+                "--local-scratch",
+                "--local-output",
                 "--env", "DEMO_MODE=fast",
             ]
         )
@@ -207,6 +213,8 @@ class ConfigureTests(unittest.TestCase):
             webui=True,
             max_concurrency=2,
             scratch_dir=None,
+            local_scratch=True,
+            local_output=True,
             token=None,
             registration=None,
             gpu_ids=[3, 1],

{ls_algorithm_plugin_sdk-0.3.3 → ls_algorithm_plugin_sdk-0.3.4}/tests/test_deployment.py

@@ -66,6 +66,8 @@ class DeploymentConfigTests(unittest.TestCase):
                     webui=True,
                     max_concurrency=1,
                     scratch_dir=None,
+                    local_scratch=True,
+                    local_output=True,
                     token=None,
                     registration=None,
                     gpu_ids=[3, 1],
@@ -83,6 +85,8 @@ class DeploymentConfigTests(unittest.TestCase):
                 {"batchSize": 8, "mode": "fast"},
             )
             self.assertEqual(loaded.payload["service"]["gpuIds"], [3, 1])
+            self.assertTrue(loaded.payload["service"]["localScratch"])
+            self.assertTrue(loaded.payload["service"]["localOutput"])
             manifest_path = root / "release-manifest.json"
             manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
             self.assertEqual(

ls_algorithm_plugin_sdk-0.3.4/tests/test_serve.py

@@ -0,0 +1,73 @@
+import os
+import unittest
+from pathlib import Path
+from unittest.mock import Mock, patch
+
+from test_runner import RecordingAlgorithm
+
+from algorithm_plugin_sdk.cli import build_parser
+from algorithm_plugin_sdk.cli_impl.serve import execute
+
+
+class ServeTests(unittest.TestCase):
+    def test_config_passes_local_storage_settings_to_manager(self) -> None:
+        args = build_parser().parse_args(
+            ["serve", "--config", "/srv/demo/algorithm-plugin.json"]
+        )
+        config = Mock()
+        config.algorithm_reference = "demo:Algorithm"
+        config.repository = Path("/srv/demo")
+        config.payload = {
+            "service": {
+                "host": "127.0.0.1",
+                "port": 9000,
+                "maxConcurrency": 2,
+                "scratchDir": None,
+                "localScratch": True,
+                "localOutput": True,
+                "gpuIds": [0],
+                "webui": False,
+                "defaultParameters": {},
+            }
+        }
+        config.process_environment.return_value = dict(os.environ)
+        manager = Mock()
+
+        with (
+            patch(
+                "algorithm_plugin_sdk.cli_impl.serve.DeploymentConfig.load",
+                return_value=config,
+            ),
+            patch(
+                "algorithm_plugin_sdk.cli_impl.serve.apply_gpu_isolation",
+                return_value=[0],
+            ),
+            patch(
+                "algorithm_plugin_sdk.cli_impl.serve.load_algorithm",
+                return_value=RecordingAlgorithm(),
+            ),
+            patch(
+                "algorithm_plugin_sdk.cli_impl.serve.ReleaseManifest.discover",
+                return_value=None,
+            ),
+            patch(
+                "algorithm_plugin_sdk.cli_impl.serve.ExecutionManager",
+                return_value=manager,
+            ) as manager_class,
+            patch(
+                "algorithm_plugin_sdk.cli_impl.serve.PluginRegistrationAgent.from_env",
+                return_value=None,
+            ),
+            patch("algorithm_plugin_sdk.cli_impl.serve.run_server"),
+            patch("algorithm_plugin_sdk.cli_impl.serve.os.chdir"),
+        ):
+            self.assertEqual(execute(args), 0)
+
+        manager_kwargs = manager_class.call_args.kwargs
+        self.assertTrue(manager_kwargs["local_scratch"])
+        self.assertTrue(manager_kwargs["local_output"])
+        self.assertEqual(manager_kwargs["repository"], config.repository)
+
+
+if __name__ == "__main__":
+    unittest.main()

{ls_algorithm_plugin_sdk-0.3.3 → ls_algorithm_plugin_sdk-0.3.4}/tests/test_service.py

@@ -1,7 +1,10 @@
+import json
 import time
 import unittest
 from contextlib import redirect_stdout
 from io import StringIO
+from pathlib import Path
+from tempfile import TemporaryDirectory
 from unittest.mock import patch
 
 from test_runner import RecordingAlgorithm
@@ -57,6 +60,85 @@ class ExecutionManagerTests(unittest.TestCase):
             {"batchSize": 16, "mode": "accurate"},
         )
 
+    def test_local_storage_overrides_request_paths_per_job(self) -> None:
+        with TemporaryDirectory() as repository:
+            root = Path(repository)
+            algorithm = RecordingAlgorithm()
+            manager = ExecutionManager(
+                AlgorithmRunner(algorithm),
+                repository=root,
+                local_scratch=True,
+                local_output=True,
+            )
+            request = AlgorithmRequest(
+                inputs=[
+                    AlgorithmInput(
+                        input_dataset="dataset-a",
+                        output="/remote/output/dataset-a",
+                    )
+                ],
+                workspace={
+                    "inputRoot": "/remote/input",
+                    "outputRoot": "/remote/output",
+                    "scratchRoot": "/remote/scratch",
+                },
+            )
+
+            first = manager.submit(request, job_id="job-local")
+            manager._record(first["executionId"]).future.result(timeout=2)
+            second = manager.submit(request, job_id="job-local")
+            manager._record(second["executionId"]).future.result(timeout=2)
+            manager.close()
+
+            scratch_root = root / ".scratch"
+            output_root = root / ".output"
+            job_output = output_root / "job-local"
+            self.assertTrue(scratch_root.is_dir())
+            self.assertTrue(job_output.is_dir())
+            for actual in algorithm.calls:
+                self.assertEqual(actual.workspace["inputRoot"], "/remote/input")
+                self.assertEqual(actual.workspace["scratchRoot"], str(scratch_root))
+                self.assertEqual(actual.workspace["outputRoot"], str(output_root))
+                self.assertEqual(actual.inputs[0].output, str(job_output))
+
+    def test_local_output_rejects_unsafe_job_id(self) -> None:
+        with TemporaryDirectory() as repository:
+            manager = ExecutionManager(
+                AlgorithmRunner(RecordingAlgorithm()),
+                repository=repository,
+                local_output=True,
+            )
+            with self.assertRaisesRegex(ValueError, "unsafe"):
+                manager.submit(self._request(), job_id="../outside")
+            manager.close()
+
+    def test_local_output_keeps_multiple_input_paths_distinct(self) -> None:
+        with TemporaryDirectory() as repository:
+            root = Path(repository)
+            algorithm = RecordingAlgorithm()
+            manager = ExecutionManager(
+                AlgorithmRunner(algorithm),
+                repository=root,
+                local_output=True,
+            )
+            request = AlgorithmRequest(
+                inputs=[
+                    AlgorithmInput(input_dataset="dataset-a", output="remote/a"),
+                    AlgorithmInput(input_dataset="dataset-b", output="remote/b"),
+                ]
+            )
+
+            accepted = manager.submit(request, job_id="job-local")
+            manager._record(accepted["executionId"]).future.result(timeout=2)
+            manager.close()
+
+            job_output = root / ".output" / "job-local"
+            self.assertEqual(
+                [item.output for item in algorithm.calls[0].inputs],
+                [str(job_output / "0-a"), str(job_output / "1-b")],
+            )
+            self.assertTrue(all(path.is_dir() for path in job_output.iterdir()))
+
     def test_runs_the_same_algorithm_contract(self) -> None:
         manager = ExecutionManager(AlgorithmRunner(RecordingAlgorithm()))
         accepted = manager.submit(
@@ -149,6 +231,96 @@ class ExecutionManagerTests(unittest.TestCase):
         manager.close()
         self.assertTrue(all(algorithm.stopped == 1 for algorithm in algorithms))
 
+    def test_reuses_one_log_file_for_executions_of_same_job(self) -> None:
+        with TemporaryDirectory() as log_dir:
+            first_manager = ExecutionManager(
+                AlgorithmRunner(RecordingAlgorithm()),
+                log_dir=log_dir,
+            )
+            with patch(
+                "algorithm_plugin_sdk.log_manager._timestamp_prefix",
+                return_value="20260910123456",
+            ):
+                first = first_manager.submit(
+                    self._request(),
+                    job_id="job-shared",
+                    task_id="task-a",
+                )
+                first_manager._record(first["executionId"]).future.result(timeout=2)
+            first_manager.close()
+
+            second_manager = ExecutionManager(
+                AlgorithmRunner(RecordingAlgorithm()),
+                log_dir=log_dir,
+            )
+            with patch(
+                "algorithm_plugin_sdk.log_manager._timestamp_prefix",
+                return_value="20260911123456",
+            ):
+                second = second_manager.submit(
+                    self._request(),
+                    job_id="job-shared",
+                    task_id="task-b",
+                )
+                second_manager._record(second["executionId"]).future.result(timeout=2)
+            second_manager.close()
+
+            log_files = list(Path(log_dir).glob("*.log"))
+            self.assertEqual(
+                [path.name for path in log_files],
+                ["20260910123456-job-shared.log"],
+            )
+            events = [
+                json.loads(line)
+                for line in log_files[0].read_text(encoding="utf-8").splitlines()
+            ]
+            request_events = [event for event in events if event["event"] == "request"]
+            self.assertEqual(
+                [event["executionId"] for event in request_events],
+                [first["executionId"], second["executionId"]],
+            )
+            self.assertTrue(
+                all(event["jobId"] == "job-shared" for event in events)
+            )
+            self.assertEqual(
+                {event["taskId"] for event in events},
+                {"task-a", "task-b"},
+            )
+
+    def test_failed_execution_log_includes_full_traceback(self) -> None:
+        def create_runner() -> AlgorithmRunner:
+            return AlgorithmRunner(RestartProbeAlgorithm(fail=True))
+
+        with TemporaryDirectory() as log_dir:
+            manager = ExecutionManager(
+                create_runner(),
+                runner_factory=create_runner,
+                max_attempts=1,
+                log_dir=log_dir,
+            )
+            accepted = manager.submit(self._request(), job_id="job-failed")
+            manager._record(accepted["executionId"]).future.result(timeout=2)
+            manager.close()
+
+            log_files = list(Path(log_dir).glob("??????????????-job-failed.log"))
+            self.assertEqual(len(log_files), 1)
+            contents = log_files[0].read_text(encoding="utf-8")
+            self.assertIn("Traceback (most recent call last):", contents)
+            self.assertIn("RuntimeError: simulated algorithm failure", contents)
+            events = [
+                json.loads(line)
+                for line in contents.splitlines()
+                if line.startswith("{")
+            ]
+            result_event = events[-1]
+            self.assertEqual(result_event["event"], "result")
+            self.assertEqual(result_event["state"], "failed")
+            self.assertEqual(result_event["executionId"], accepted["executionId"])
+            self.assertIn(
+                "RuntimeError: simulated algorithm failure",
+                result_event["traceback"],
+            )
+
     def test_next_request_uses_fresh_algorithm_after_attempts_are_exhausted(self) -> None:
         algorithms = []
 

ls_algorithm_plugin_sdk-0.3.3/src/algorithm_plugin_sdk/log_manager.py

@@ -1,76 +0,0 @@
-from __future__ import annotations
-
-import json
-import logging
-import re
-import threading
-from pathlib import Path
-from typing import Any
-
-from .context import utc_now
-
-_SAFE_NAME = re.compile(r"[^A-Za-z0-9._-]+")
-
-
-def _safe_name(value: str) -> str:
-    cleaned = _SAFE_NAME.sub("_", str(value).strip()).strip("._")
-    return cleaned or "job"
-
-
-class ExecutionLog:
-    """Per-execution, line-buffered log sink attached to context.logger."""
-
-    def __init__(self, *, log_dir: str | Path, job_id: str, execution_id: str, logger: logging.Logger) -> None:
-        directory = Path(log_dir).expanduser()
-        directory.mkdir(parents=True, exist_ok=True)
-        path = directory / f"{_safe_name(job_id)}.log"
-        if path.exists():
-            path = directory / f"{_safe_name(job_id)}-{_safe_name(execution_id)}.log"
-        self.path = path
-        self._stream = path.open("a", encoding="utf-8", buffering=1)
-        self._lock = threading.RLock()
-        self._handler = _FlushFileHandler(self._stream)
-        self._handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(message)s"))
-        self._handler.setLevel(logging.DEBUG)
-        self.logger = logger
-        self.logger.setLevel(logging.DEBUG)
-        self.logger.addHandler(self._handler)
-        self._closed = False
-
-    def write_event(self, event: str, **values: Any) -> None:
-        payload = {"event": event, "timestamp": utc_now(), **values}
-        with self._lock:
-            if self._closed:
-                return
-            self._stream.write(json.dumps(payload, ensure_ascii=False, default=str) + "\n")
-            self._stream.flush()
-
-    def close(self) -> None:
-        with self._lock:
-            if self._closed:
-                return
-            self._closed = True
-            self.logger.removeHandler(self._handler)
-            self._handler.close()
-            self._stream.close()
-
-
-class _FlushFileHandler(logging.Handler):
-    def __init__(self, stream: Any) -> None:
-        super().__init__()
-        self.stream = stream
-        self._lock = threading.RLock()
-
-    def emit(self, record: logging.LogRecord) -> None:
-        try:
-            with self._lock:
-                self.stream.write(self.format(record) + "\n")
-                self.stream.flush()
-        except Exception:
-            self.handleError(record)
-
-    def close(self) -> None:
-        try:
-            self.stream.flush()
-        finally:
-            super().close()