expt-logger 0.1.0.dev18__tar.gz → 0.1.0.dev20__tar.gz

expt_logger-0.1.0.dev18/README.md → expt_logger-0.1.0.dev20/PKG-INFO

@@ -1,3 +1,12 @@
+Metadata-Version: 2.4
+Name: expt-logger
+Version: 0.1.0.dev20
+Summary: Simple experiment logging library
+Requires-Python: >=3.10
+Requires-Dist: requests>=2.31.0
+Requires-Dist: typing-extensions>=4.1.0
+Description-Content-Type: text/markdown
+
 # expt_logger
 
 Simple experiment tracking for RL training with a W&B-style API.
@@ -244,15 +253,23 @@ init(
     config: dict[str, Any] | None = None,
     api_key: str | None = None,
     base_url: str | None = None,
-    is_main_process: bool = True
+    is_main_process: bool = True,
+    experiment_id: str | None = None
 ) -> Run
 ```
 
-- `name`: Experiment name (auto-generated if not provided)
-- `config`: Initial hyperparameters
+- `name`: Experiment name (auto-generated if not provided, used only when creating new experiments)
+- `config`: Initial hyperparameters (synced to server when provided)
 - `api_key`: API key (or set `EXPT_LOGGER_API_KEY`)
 - `base_url`: Custom server URL (or set `EXPT_LOGGER_BASE_URL`)
 - `is_main_process`: If `False`, read experiment ID from temp file instead of creating a new experiment (for multi-process logging)
+- `experiment_id`: Optional experiment ID to attach to an existing experiment (overrides all other resolution methods)
+
+**Behavior:**
+- If `experiment_id` is provided: attach to that specific experiment (overrides all)
+- Else if `EXPT_LOGGER_EXPERIMENT_ID` env var exists: attach to that experiment
+- Else if `is_main_process=True`: create a new experiment
+- Else if `is_main_process=False`: read from temp file (multi-process)
 
 **Note:** When creating a new experiment (main process), `init()` automatically sets `EXPT_LOGGER_EXPERIMENT_ID` and writes to a temp file so subprocesses can discover it.
 
@@ -280,7 +297,7 @@ log_rollout(
     messages: list[dict[str, str]],
     rewards: dict[str, float],
     step: int | None = None,
-    mode: str = "train",
+    mode: str | None = None,
     commit: bool = True
 )
 ```
@@ -289,7 +306,7 @@ log_rollout(
 - `messages`: List of `{"role": ..., "content": ...}` dicts (both must be strings)
 - `rewards`: Dict of reward names to numeric values (must be valid numbers, not NaN/Inf)
 - `step`: Step number (must be non-negative integer if provided)
-- `mode`: `"train"` or `"eval"` (must be non-empty string)
+- `mode`: Optional mode (defaults to `"train"` if not provided)
 - `commit`: If `True` (default), commit immediately and increment step. If `False`, buffer metrics until commit.
 
 **Input Validation:**
@@ -297,6 +314,24 @@ log_rollout(
 - Invalid inputs raise `ValidationError` with descriptive error messages
 - Metric and reward values must be numeric (int/float) and cannot be NaN or Infinity
 
+### `expt_logger.log_error()`
+
+```python
+log_error(
+    error: Exception | str,
+    step: int | None = None,
+    mode: str | None = None,
+    include_traceback: bool = True,
+    commit: bool = True
+)
+```
+
+- `error`: The error (Exception object or string message)
+- `step`: Step number (overrides automatic step counter if provided)
+- `mode`: Optional mode (e.g., "train", "eval")
+- `include_traceback`: Whether to include the traceback (only for Exception objects, default: `True`)
+- `commit`: If `True` (default), commit immediately and increment step. If `False`, buffer until commit.
+
 ### `expt_logger.commit()`
 
 ```python

expt_logger-0.1.0.dev18/PKG-INFO → expt_logger-0.1.0.dev20/README.md

@@ -1,11 +1,3 @@
-Metadata-Version: 2.4
-Name: expt-logger
-Version: 0.1.0.dev18
-Summary: Simple experiment logging library
-Requires-Python: >=3.10
-Requires-Dist: requests>=2.31.0
-Description-Content-Type: text/markdown
-
 # expt_logger
 
 Simple experiment tracking for RL training with a W&B-style API.
@@ -252,15 +244,23 @@ init(
     config: dict[str, Any] | None = None,
     api_key: str | None = None,
     base_url: str | None = None,
-    is_main_process: bool = True
+    is_main_process: bool = True,
+    experiment_id: str | None = None
 ) -> Run
 ```
 
-- `name`: Experiment name (auto-generated if not provided)
-- `config`: Initial hyperparameters
+- `name`: Experiment name (auto-generated if not provided, used only when creating new experiments)
+- `config`: Initial hyperparameters (synced to server when provided)
 - `api_key`: API key (or set `EXPT_LOGGER_API_KEY`)
 - `base_url`: Custom server URL (or set `EXPT_LOGGER_BASE_URL`)
 - `is_main_process`: If `False`, read experiment ID from temp file instead of creating a new experiment (for multi-process logging)
+- `experiment_id`: Optional experiment ID to attach to an existing experiment (overrides all other resolution methods)
+
+**Behavior:**
+- If `experiment_id` is provided: attach to that specific experiment (overrides all)
+- Else if `EXPT_LOGGER_EXPERIMENT_ID` env var exists: attach to that experiment
+- Else if `is_main_process=True`: create a new experiment
+- Else if `is_main_process=False`: read from temp file (multi-process)
 
 **Note:** When creating a new experiment (main process), `init()` automatically sets `EXPT_LOGGER_EXPERIMENT_ID` and writes to a temp file so subprocesses can discover it.
 
@@ -288,7 +288,7 @@ log_rollout(
     messages: list[dict[str, str]],
     rewards: dict[str, float],
     step: int | None = None,
-    mode: str = "train",
+    mode: str | None = None,
     commit: bool = True
 )
 ```
@@ -297,7 +297,7 @@ log_rollout(
 - `messages`: List of `{"role": ..., "content": ...}` dicts (both must be strings)
 - `rewards`: Dict of reward names to numeric values (must be valid numbers, not NaN/Inf)
 - `step`: Step number (must be non-negative integer if provided)
-- `mode`: `"train"` or `"eval"` (must be non-empty string)
+- `mode`: Optional mode (defaults to `"train"` if not provided)
 - `commit`: If `True` (default), commit immediately and increment step. If `False`, buffer metrics until commit.
 
 **Input Validation:**
@@ -305,6 +305,24 @@ log_rollout(
 - Invalid inputs raise `ValidationError` with descriptive error messages
 - Metric and reward values must be numeric (int/float) and cannot be NaN or Infinity
 
+### `expt_logger.log_error()`
+
+```python
+log_error(
+    error: Exception | str,
+    step: int | None = None,
+    mode: str | None = None,
+    include_traceback: bool = True,
+    commit: bool = True
+)
+```
+
+- `error`: The error (Exception object or string message)
+- `step`: Step number (overrides automatic step counter if provided)
+- `mode`: Optional mode (e.g., "train", "eval")
+- `include_traceback`: Whether to include the traceback (only for Exception objects, default: `True`)
+- `commit`: If `True` (default), commit immediately and increment step. If `False`, buffer until commit.
+
 ### `expt_logger.commit()`
 
 ```python

{expt_logger-0.1.0.dev18 → expt_logger-0.1.0.dev20}/pyproject.toml

@@ -1,11 +1,12 @@
 [project]
 name = "expt-logger"
-version = "0.1.0.dev18"
+version = "0.1.0.dev20"
 description = "Simple experiment logging library"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
     "requests>=2.31.0",
+    "typing_extensions>=4.1.0",
 ]
 
 [dependency-groups]

{expt_logger-0.1.0.dev18 → expt_logger-0.1.0.dev20}/src/expt_logger/__init__.py

@@ -112,6 +112,7 @@ def log_rollout(
     step: int | None = None,
     mode: str | None = None,
     commit: bool = True,
+    id: str | None = None,
 ) -> None:
     """Log a rollout (conversation + rewards).
 
@@ -151,9 +152,28 @@ def log_rollout(
         step=step,
         mode=mode,
         commit=commit,
+        id=id
     )
 
 
+def log_environment(
+    rollout_id: str,
+    content: str,
+) -> None:
+    """Log an environment log entry associated with a rollout.
+
+    Args:
+        rollout_id: ID of the rollout this log entry is associated with
+        content: Log content string
+
+    Raises:
+        RuntimeError: If no active run exists
+    """
+    if _active_run is None:
+        raise RuntimeError("No active run. Call init() first.")
+    _active_run.log_environment(rollout_id=rollout_id, content=content)
+
+
 def log_error(
     error: Exception | str,
     step: int | None = None,
@@ -297,6 +317,7 @@ __all__ = [
     "init",
     "log",
     "log_rollout",
+    "log_environment",
     "log_error",
     "commit",
     "end",

{expt_logger-0.1.0.dev18 → expt_logger-0.1.0.dev20}/src/expt_logger/client.py

@@ -280,6 +280,47 @@ class APIClient:
             payload = {"rollouts": chunk}
             self._request("POST", url, json=payload)
 
+    def log_env_logs(
+        self,
+        experiment_id: str,
+        rollout_id: str,
+        content: str,
+    ) -> None:
+        """Log an environment log entry for an experiment.
+
+        Args:
+            experiment_id: Experiment ID
+            rollout_id: Rollout ID this log entry is associated with
+            content: Log content string
+
+        Raises:
+            APIError: If request fails
+        """
+        url = f"{self.base_url}/api/experiments/{experiment_id}/env-logs"
+        payload = {"rolloutId": rollout_id, "content": content}
+        self._request("POST", url, json=payload)
+
+    def get_env_logs(
+        self,
+        experiment_id: str,
+        rollout_id: str,
+    ) -> list[dict]:
+        """Fetch environment logs for a specific rollout.
+
+        Args:
+            experiment_id: Experiment ID
+            rollout_id: Rollout ID to filter logs by
+
+        Returns:
+            List of env log entries
+
+        Raises:
+            APIError: If request fails
+        """
+        url = f"{self.base_url}/api/experiments/{experiment_id}/env-logs"
+        response = self._request("GET", url, params={"rolloutId": rollout_id})
+        return response.json()["logs"]
+
     def log_errors(
         self,
         experiment_id: str,

{expt_logger-0.1.0.dev18 → expt_logger-0.1.0.dev20}/src/expt_logger/run.py

@@ -23,6 +23,7 @@ from expt_logger.types import (
     ConfigUpdateCommand,
     ErrorItem,
     LogCommand,
+    LogEnvironmentCommand,
     LogErrorCommand,
     LogRolloutCommand,
     MessageItem,
@@ -228,6 +229,7 @@ class Run:
         step: int | None = None,
         mode: str | None = None,
         commit: bool = True,
+        id: str | None = None,
     ) -> None:
         """Log a rollout (conversation + rewards).
 
@@ -238,6 +240,7 @@ class Run:
             step: Optional step number (overrides worker's step counter if provided)
             mode: Optional mode (defaults to "train")
             commit: Whether to flush buffer after logging
+            id: Optional identifier for this rollout
         """
         from expt_logger.validation import (
             validate_messages,
@@ -273,6 +276,7 @@ class Run:
             "rewards": reward_items,
             "mode": mode or "train",
             "step": step,
+            "id": id,
         }
 
         try:
@@ -283,6 +287,26 @@ class Run:
         if commit:
             self.commit()
 
+    def log_environment(
+        self,
+        rollout_id: str,
+        content: str,
+    ) -> None:
+        """Log an environment log entry associated with a rollout.
+
+        Args:
+            rollout_id: ID of the rollout this log entry is associated with
+            content: Log content string
+        """
+        env_cmd: LogEnvironmentCommand = {
+            "rollout_id": rollout_id,
+            "content": content,
+        }
+        try:
+            self._queue.put_nowait(("log_environment", env_cmd))
+        except Full:
+            logger.warning(f"Command queue full, dropping environment log for rollout: {rollout_id}")
+
     def log_error(
         self,
         error: Exception | str,
@@ -312,7 +336,11 @@ class Run:
         if isinstance(error, Exception):
             message = str(error)
             error_type = type(error).__name__
-            traceback_str = "".join(tb.format_exception(type(error), error, error.__traceback__)) if include_traceback else None
+            traceback_str = (
+                "".join(tb.format_exception(type(error), error, error.__traceback__))
+                if include_traceback
+                else None
+            )
         else:
             message = error
             error_type = "Error"
@@ -418,6 +446,8 @@ class Run:
                             self._handle_log(cast(LogCommand, data))
                         elif command == "log_rollout":
                             self._handle_log_rollout(cast(LogRolloutCommand, data))
+                        elif command == "log_environment":
+                            self._handle_log_environment(cast(LogEnvironmentCommand, data))
                         elif command == "log_error":
                             self._handle_log_error(cast(LogErrorCommand, data))
                         elif command == "commit":
@@ -528,9 +558,22 @@ class Run:
             "messages": data["messages"],
             "rewards": data["rewards"],
         }
+        if data["id"] is not None:
+            rollout["id"] = data["id"]
 
         self._buffer.add_rollout(rollout)
 
+    def _handle_log_environment(self, data: LogEnvironmentCommand) -> None:
+        """Handle log_environment command.
+
+        Args:
+            data: Log environment command data with rollout_id and content
+        """
+        try:
+            self._client.log_env_logs(self._experiment_id, data["rollout_id"], data["content"])
+        except Exception as e:
+            logger.error(f"Error logging environment log: {e}", exc_info=True)
+
     def _handle_log_error(self, data: LogErrorCommand) -> None:
         """Handle log_error command.
 

{expt_logger-0.1.0.dev18 → expt_logger-0.1.0.dev20}/src/expt_logger/types.py

@@ -1,6 +1,8 @@
 """Type definitions for expt-logger."""
 
-from typing import Any, NotRequired, TypedDict
+from typing import Any, TypedDict
+
+from typing_extensions import NotRequired
 
 
 class ScalarItem(TypedDict):
@@ -34,6 +36,7 @@ class RolloutItem(TypedDict):
     promptText: str
     messages: list[MessageItem]
     rewards: list[RewardItem]
+    id: NotRequired[str]
 
 
 class ErrorItem(TypedDict):
@@ -73,6 +76,7 @@ class LogRolloutCommand(TypedDict):
     rewards: list[RewardItem]
     mode: str
     step: int | None
+    id: str | None
 
 
 class LogErrorCommand(TypedDict):
@@ -85,6 +89,13 @@ class LogErrorCommand(TypedDict):
     step: int | None
 
 
+class LogEnvironmentCommand(TypedDict):
+    """Command to log an environment log entry."""
+
+    rollout_id: str
+    content: str
+
+
 class CommitCommand(TypedDict):
     """Command to commit (flush) the buffer."""
 

{expt_logger-0.1.0.dev18 → expt_logger-0.1.0.dev20}/tests/test_client.py

@@ -294,6 +294,18 @@ def test_log_rollouts(client):
         assert call_args[1]["json"] == {"rollouts": rollouts}
 
 
+def test_log_env_logs(client):
+    """Test logging environment logs."""
+    with patch.object(client, "_request") as mock_request:
+        client.log_env_logs("exp-123", "rollout-456", "step 1 observation")
+
+        mock_request.assert_called_once()
+        call_args = mock_request.call_args
+        assert call_args[0][0] == "POST"
+        assert call_args[0][1] == "https://test.example.com/api/experiments/exp-123/env-logs"
+        assert call_args[1]["json"] == {"rolloutId": "rollout-456", "content": "step 1 observation"}
+
+
 def test_log_errors(client):
     """Test logging errors."""
     with patch.object(client, "_request") as mock_request:

{expt_logger-0.1.0.dev18 → expt_logger-0.1.0.dev20}/tests/test_global_api.py

@@ -134,6 +134,28 @@ def test_log_rollout_raises_if_no_active_run(mock_run):
     assert "No active run" in str(exc_info.value)
 
 
+def test_log_environment_delegates_to_run(mock_run):
+    """Test log_environment() delegates to the active run."""
+    _, run_instance = mock_run
+
+    expt_logger.init()
+    expt_logger.log_environment(rollout_id="rollout-abc", content="step 1 observation")
+
+    run_instance.log_environment.assert_called_once_with(
+        rollout_id="rollout-abc",
+        content="step 1 observation",
+    )
+
+
+def test_log_environment_raises_if_no_active_run():
+    """Test log_environment() raises RuntimeError if no active run."""
+    with pytest.raises(RuntimeError) as exc_info:
+        expt_logger.log_environment("rollout-abc", "some content")
+
+    assert "No active run" in str(exc_info.value)
+    assert "init()" in str(exc_info.value)
+
+
 def test_log_error_delegates_to_run(mock_run):
     """Test log_error() delegates to the active run."""
     _, run_instance = mock_run
@@ -393,6 +415,7 @@ def test_all_exports():
         "init",
         "log",
         "log_rollout",
+        "log_environment",
         "log_error",
         "commit",
         "end",

{expt_logger-0.1.0.dev18 → expt_logger-0.1.0.dev20}/tests/test_integration_e2e.py

@@ -112,6 +112,22 @@ def fetch_rollouts(shared_api_key: str, base_url: str):
     return _fetch
 
 
+@pytest.fixture
+def fetch_env_logs(shared_api_key: str, base_url: str):
+    """Factory fixture for fetching environment log data."""
+
+    def _fetch(experiment_id: str, rollout_id: str):
+        response = requests.get(
+            f"{base_url}/api/experiments/{experiment_id}/env-logs",
+            params={"rolloutId": rollout_id},
+            headers={"Authorization": f"Bearer {shared_api_key}"},
+        )
+        assert response.status_code == 200
+        return response.json()["logs"]
+
+    return _fetch
+
+
 # ============================================================================
 # Test Class 1: Basic Workflow Tests
 # ============================================================================
@@ -1054,3 +1070,117 @@ class TestMultiProcess:
         # Worker metrics
         for i in range(num_workers):
             assert f"worker-{i + 1}-metric" in scalars
+
+
+# ============================================================================
+# Test Class 12: Environment Log Tests
+# ============================================================================
+
+
+@pytest.mark.integration
+class TestEnvironmentLogs:
+    """Environment log functionality."""
+
+    def test_log_environment_basic(
+        self,
+        shared_api_key: str,
+        base_url: str,
+        cleanup_experiments: list[str],
+        fetch_env_logs,
+    ) -> None:
+        """Test basic environment log persists to server."""
+        run = expt_logger.init(
+            name="test-env-log-basic",
+            api_key=shared_api_key,
+            base_url=base_url,
+        )
+        cleanup_experiments.append(run._experiment_id)
+
+        expt_logger.log_environment("00000000-0000-0000-0000-000000000001", "observation: step=1, reward=0.9")
+        time.sleep(0.5)
+
+        env_logs = fetch_env_logs(run._experiment_id, "00000000-0000-0000-0000-000000000001")
+        assert len(env_logs) == 1
+        assert env_logs[0]["content"] == "observation: step=1, reward=0.9"
+
+        expt_logger.end()
+
+    def test_log_environment_multiple_for_same_rollout(
+        self,
+        shared_api_key: str,
+        base_url: str,
+        cleanup_experiments: list[str],
+        fetch_env_logs,
+    ) -> None:
+        """Test multiple environment logs for the same rollout are all stored."""
+        run = expt_logger.init(
+            name="test-env-log-multiple",
+            api_key=shared_api_key,
+            base_url=base_url,
+        )
+        cleanup_experiments.append(run._experiment_id)
+
+        expt_logger.log_environment("00000000-0000-0000-0000-000000000002", "step 1: action=left")
+        expt_logger.log_environment("00000000-0000-0000-0000-000000000002", "step 2: action=right")
+        expt_logger.log_environment("00000000-0000-0000-0000-000000000002", "step 3: action=jump")
+        time.sleep(0.5)
+
+        env_logs = fetch_env_logs(run._experiment_id, "00000000-0000-0000-0000-000000000002")
+        assert len(env_logs) == 3
+        contents = {log["content"] for log in env_logs}
+        assert contents == {"step 1: action=left", "step 2: action=right", "step 3: action=jump"}
+
+        expt_logger.end()
+
+    def test_log_environment_different_rollouts(
+        self,
+        shared_api_key: str,
+        base_url: str,
+        cleanup_experiments: list[str],
+        fetch_env_logs,
+    ) -> None:
+        """Test environment logs for different rollouts stay separate."""
+        run = expt_logger.init(
+            name="test-env-log-separate",
+            api_key=shared_api_key,
+            base_url=base_url,
+        )
+        cleanup_experiments.append(run._experiment_id)
+
+        expt_logger.log_environment("00000000-0000-0000-0000-00000000003a", "log for rollout A")
+        expt_logger.log_environment("00000000-0000-0000-0000-00000000003b", "log for rollout B")
+        time.sleep(0.5)
+
+        logs_a = fetch_env_logs(run._experiment_id, "00000000-0000-0000-0000-00000000003a")
+        logs_b = fetch_env_logs(run._experiment_id, "00000000-0000-0000-0000-00000000003b")
+        assert len(logs_a) == 1
+        assert logs_a[0]["content"] == "log for rollout A"
+        assert len(logs_b) == 1
+        assert logs_b[0]["content"] == "log for rollout B"
+
+        expt_logger.end()
+
+    def test_log_environment_multiline_content(
+        self,
+        shared_api_key: str,
+        base_url: str,
+        cleanup_experiments: list[str],
+        fetch_env_logs,
+    ) -> None:
+        """Test environment log with multiline content."""
+        run = expt_logger.init(
+            name="test-env-log-multiline",
+            api_key=shared_api_key,
+            base_url=base_url,
+        )
+        cleanup_experiments.append(run._experiment_id)
+
+        content = "obs: {x: 1.0, y: 2.0}\nreward: 0.5\ndone: false\ninfo: {step: 10}"
+        expt_logger.log_environment("00000000-0000-0000-0000-000000000004", content)
+        time.sleep(0.5)
+
+        env_logs = fetch_env_logs(run._experiment_id, "00000000-0000-0000-0000-000000000004")
+        assert len(env_logs) == 1
+        assert env_logs[0]["content"] == content
+
+        expt_logger.end()

{expt_logger-0.1.0.dev18 → expt_logger-0.1.0.dev20}/tests/test_run.py

@@ -1480,3 +1480,88 @@ def test_log_error_with_invalid_mode_empty(mock_client):
 
     assert "non-empty" in str(exc_info.value)
     run.end()
+
+
+# ========== log_environment Tests ==========
+
+
+def test_log_environment_calls_client(mock_client):
+    """Test log_environment() calls client with correct args."""
+    _, client_instance = mock_client
+
+    run = Run(name="test-run", api_key="test-key", base_url="https://test.example.com")
+
+    run.log_environment("rollout-abc", "step 1 observation")
+
+    # Give worker time to process
+    time.sleep(0.1)
+
+    assert client_instance.log_env_logs.called
+    call_args = client_instance.log_env_logs.call_args
+    assert call_args[0][0] == "test-exp-id"
+    assert call_args[0][1] == "rollout-abc"
+    assert call_args[0][2] == "step 1 observation"
+
+    run.end()
+
+
+def test_log_environment_multiple_calls(mock_client):
+    """Test log_environment() can be called multiple times for different rollouts."""
+    _, client_instance = mock_client
+
+    run = Run(name="test-run", api_key="test-key", base_url="https://test.example.com")
+
+    run.log_environment("rollout-1", "log content 1")
+    run.log_environment("rollout-2", "log content 2")
+
+    # Give worker time to process
+    time.sleep(0.1)
+
+    assert client_instance.log_env_logs.call_count == 2
+    first_call = client_instance.log_env_logs.call_args_list[0]
+    second_call = client_instance.log_env_logs.call_args_list[1]
+    assert first_call[0][1] == "rollout-1"
+    assert first_call[0][2] == "log content 1"
+    assert second_call[0][1] == "rollout-2"
+    assert second_call[0][2] == "log content 2"
+
+    run.end()
+
+
+def test_log_environment_queue_full_handling(mock_client):
+    """Test that queue full is handled gracefully for environment logs."""
+    _, _ = mock_client
+
+    run = Run(name="test-run", api_key="test-key", base_url="https://test.example.com")
+    run._queue = queue.Queue(maxsize=1)
+
+    with patch("expt_logger.run.logger") as mock_logger:
+        run.log_environment("rollout-1", "log 1")
+        run.log_environment("rollout-2", "log 2")  # Should trigger queue full
+
+        assert mock_logger.warning.called
+        warning_msg = mock_logger.warning.call_args[0][0]
+        assert "queue full" in warning_msg.lower()
+
+    run.end()
+
+
+def test_log_environment_api_error_is_logged(mock_client):
+    """Test that API errors from log_environment are caught and logged, not raised."""
+    _, client_instance = mock_client
+
+    client_instance.log_env_logs.side_effect = APIError("Server error")
+
+    run = Run(name="test-run", api_key="test-key", base_url="https://test.example.com")
+
+    with patch("expt_logger.run.logger") as mock_logger:
+        run.log_environment("rollout-abc", "some content")
+
+        # Give worker time to process and handle error
+        time.sleep(0.2)
+
+        assert run._worker_thread is not None
+        assert run._worker_thread.is_alive()
+        assert mock_logger.error.called
+
+    run.end()

expt_logger-0.1.0.dev18/.claude/settings.local.json

@@ -1,29 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(uv run mypy:*)",
-      "Bash(uv run pytest:*)",
-      "Bash(python -m pytest:*)",
-      "Bash(python example_config_validation.py:*)",
-      "Bash(uv run python:*)",
-      "Bash(ls:*)",
-      "Bash(curl:*)",
-      "Bash(cat:*)",
-      "Bash(EXPT_LOGGER_LOG_LEVEL=DEBUG uv run pytest:*)",
-      "Bash(EXPT_LOGGER_API_KEY=test EXPT_LOGGER_BASE_URL=http://localhost:3000 uv run python:*)",
-      "Bash(EXPT_LOGGER_API_KEY=test uv run python:*)",
-      "Bash(uv sync:*)",
-      "Bash(python -m json.tool:*)",
-      "Bash(uv run ruff:*)",
-      "Bash(find:*)",
-      "Bash(uv add:*)",
-      "Bash(python:*)",
-      "Bash(EXPT_LOGGER_LOG_LEVEL=DEBUG uv run python:*)",
-      "Bash(uv run:*)",
-      "Bash(git restore:*)",
-      "Bash(git checkout:*)",
-      "Bash(git rebase:*)",
-      "Bash(git add:*)"
-    ]
-  }
-}