test: parameterize activity logging tests, revert unrelated README changes

- Merge test_activity_logging and test_activity_logging_flatten_mode
  into a single pytest-parameterized test covering dict and flatten modes
- Revert README import path changes that were unrelated to this PR

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: harsh543

README.md

@@ -164,7 +164,7 @@ from temporalio import workflow
 
 # Import our activity, passing it through the sandbox
 with workflow.unsafe.imports_passed_through():
-    from activities import say_hello
+    from .activities import say_hello
 
 @workflow.defn
 class SayHello:
@@ -184,8 +184,8 @@ from temporalio.client import Client
 from temporalio.worker import Worker
 
 # Import the activity and workflow from our other files
-from activities import say_hello
-from workflows import SayHello
+from .activities import say_hello
+from .workflows import SayHello
 
 async def main():
     # Create client connected to server at the given address
@@ -220,7 +220,7 @@ import asyncio
 from temporalio.client import Client
 
 # Import the workflow from the previous code
-from workflows import SayHello
+from .workflows import SayHello
 
 async def main():
     # Create client connected to server at the given address

tests/worker/test_activity.py

@@ -1008,91 +1008,63 @@ async def some_activity():
     )
 
 
+@pytest.mark.parametrize("temporal_extra_mode", ["dict", "flatten"])
 async def test_activity_logging(
     client: Client,
     worker: ExternalWorker,
     shared_state_manager: SharedStateManager,
+    temporal_extra_mode: str,
 ):
-    @activity.defn
-    async def say_hello(name: str) -> str:
-        activity.logger.info(f"Called with arg: {name}")
-        return f"Hello, {name}!"
-
-    # Create a queue, add handler to logger, call normal activity, then check
-    handler = logging.handlers.QueueHandler(queue.Queue())
-    with LogHandler.apply(activity.logger.base_logger, handler):
-        activity.logger.base_logger.setLevel(logging.INFO)
-        result = await _execute_workflow_with_activity(
-            client,
-            worker,
-            say_hello,
-            "Temporal",
-            shared_state_manager=shared_state_manager,
-        )
-    assert result.result == "Hello, Temporal!"
-    records: list[logging.LogRecord] = list(handler.queue.queue)  # type: ignore
-    assert len(records) > 0
-    assert records[-1].message.startswith(
-        "Called with arg: Temporal ({'activity_id': '"
-    )
-    assert records[-1].__dict__["temporal_activity"]["activity_type"] == "say_hello"
-
-
-async def test_activity_logging_flatten_mode(
-    client: Client,
-    worker: ExternalWorker,
-    shared_state_manager: SharedStateManager,
-):
-    """Test that activity logger flatten mode produces OTel-safe scalar attributes."""
+    """Test that activity logger produces correct log records for each extra mode."""
 
     @activity.defn
-    async def say_hello_flatten(name: str) -> str:
+    async def say_hello(name: str) -> str:
         activity.logger.info(f"Called with arg: {name}")
         return f"Hello, {name}!"
 
     original_mode = activity.logger.temporal_extra_mode
-    activity.logger.temporal_extra_mode = "flatten"
+    activity.logger.temporal_extra_mode = temporal_extra_mode
 
     handler = logging.handlers.QueueHandler(queue.Queue())
-    activity.logger.base_logger.addHandler(handler)
-    prev_level = activity.logger.base_logger.level
-    activity.logger.base_logger.setLevel(logging.INFO)
     try:
-        result = await _execute_workflow_with_activity(
-            client,
-            worker,
-            say_hello_flatten,
-            "Temporal",
-            shared_state_manager=shared_state_manager,
-        )
+        with LogHandler.apply(activity.logger.base_logger, handler):
+            activity.logger.base_logger.setLevel(logging.INFO)
+            result = await _execute_workflow_with_activity(
+                client,
+                worker,
+                say_hello,
+                "Temporal",
+                shared_state_manager=shared_state_manager,
+            )
     finally:
-        activity.logger.base_logger.removeHandler(handler)
-        activity.logger.base_logger.setLevel(prev_level)
         activity.logger.temporal_extra_mode = original_mode
 
     assert result.result == "Hello, Temporal!"
     records: list[logging.LogRecord] = list(handler.queue.queue)  # type: ignore
     assert len(records) > 0
     record = records[-1]
 
-    # Should NOT have nested dict
-    assert "temporal_activity" not in record.__dict__
-
-    # Should have flattened keys with temporal.activity prefix
-    assert record.__dict__["temporal.activity.activity_type"] == "say_hello_flatten"
-    assert "temporal.activity.activity_id" in record.__dict__
-    assert "temporal.activity.workflow_id" in record.__dict__
-    assert "temporal.activity.workflow_run_id" in record.__dict__
-    assert "temporal.activity.namespace" in record.__dict__
-    assert "temporal.activity.task_queue" in record.__dict__
-    assert record.__dict__["temporal.activity.attempt"] == 1
-
-    # Verify all temporal.activity.* values are primitives (OTel-safe)
-    for key, value in record.__dict__.items():
-        if key.startswith("temporal.activity."):
-            assert isinstance(
-                value, (str, int, float, bool, type(None))
-            ), f"Key {key} has non-primitive value: {type(value)}"
+    if temporal_extra_mode == "dict":
+        # Dict mode appends context to message and uses nested dict
+        assert record.message.startswith("Called with arg: Temporal ({'activity_id': '")
+        assert record.__dict__["temporal_activity"]["activity_type"] == "say_hello"
+    else:
+        # Flatten mode uses OTel-safe scalar attributes
+        assert "temporal_activity" not in record.__dict__
+        assert record.__dict__["temporal.activity.activity_type"] == "say_hello"
+        assert "temporal.activity.activity_id" in record.__dict__
+        assert "temporal.activity.workflow_id" in record.__dict__
+        assert "temporal.activity.workflow_run_id" in record.__dict__
+        assert "temporal.activity.namespace" in record.__dict__
+        assert "temporal.activity.task_queue" in record.__dict__
+        assert record.__dict__["temporal.activity.attempt"] == 1
+
+        # Verify all temporal.activity.* values are primitives (OTel-safe)
+        for key, value in record.__dict__.items():
+            if key.startswith("temporal.activity."):
+                assert isinstance(
+                    value, (str, int, float, bool, type(None))
+                ), f"Key {key} has non-primitive value: {type(value)}"
 
 
 async def test_activity_worker_shutdown(