fix(langfuse): fix trace name bug and address Copilot review comments

- Remove `TraceMetadata` import (removed in Langfuse v4)
- Use `langfuse.propagate_attributes(trace_name=...)` in `LangfuseTracer.trace()`
  via ExitStack so trace-level metadata covers the full span lifetime (fixes
  trace name showing as component name 'tracer' instead of pipeline name)
- Remove `update_trace()` calls from `create_span()` and `handle()` (method
  removed in v4); replace pipeline IO call with `set_trace_io()`
- Use `span.raw_span().set_trace_as_public()` instead of `span._span...`
  to avoid accessing private attribute (Copilot comment 2)
- Add `set_trace_io` and `set_trace_as_public` to MockSpan; add
  `MockPropagateAttributesContextManager` helper
- Add unit test for `public=True` trace path (Copilot comment 4)

Author: SyedShahmeerAli12

integrations/langfuse/src/haystack_integrations/tracing/langfuse/tracer.py

@@ -22,7 +22,7 @@
 
 import langfuse
 from langfuse import LangfuseSpan as LangfuseClientSpan
-from langfuse.types import TraceContext, TraceMetadata
+from langfuse.types import TraceContext
 
 logger = logging.getLogger(__name__)
 
@@ -308,22 +308,8 @@ def create_span(self, context: SpanContext) -> LangfuseSpan:
             # Create LangfuseSpan which will handle entering the context manager
             span = LangfuseSpan(span_context_manager)
 
-            # Build trace metadata from context
-            trace_metadata: TraceMetadata = {
-                "name": context.trace_name,
-                "user_id": tracing_ctx.get("user_id"),
-                "session_id": tracing_ctx.get("session_id"),
-                "version": tracing_ctx.get("version"),
-                "metadata": None,
-                "tags": tracing_ctx.get("tags"),
-                "public": context.public,
-                "release": None,
-            }
-
-            # Filter out None values and apply trace attributes
-            trace_attrs = {k: v for k, v in trace_metadata.items() if v is not None}
-            if trace_attrs:
-                span._span.update_trace(**trace_attrs)
+            if context.public:
+                span.raw_span().set_trace_as_public()
 
             return span
 
@@ -356,7 +342,7 @@ def handle(self, span: LangfuseSpan, component_type: str | None) -> None:
         if at_pipeline_level:
             coerced_input = tracing_utils.coerce_tag_value(span.get_data().get(_PIPELINE_INPUT_KEY))
             coerced_output = tracing_utils.coerce_tag_value(span.get_data().get(_PIPELINE_OUTPUT_KEY))
-            span.raw_span().update_trace(input=coerced_input, output=coerced_output)
+            span.raw_span().set_trace_io(input=coerced_input, output=coerced_output)
         # special case for ToolInvoker (to update the span name to be: `original_component_name - [tool_names]`)
         if component_type == "ToolInvoker":
             tool_names: list[str] = []
@@ -469,6 +455,8 @@ def trace(
         span_name = tags.get(_COMPONENT_NAME_KEY, operation_name)
         component_type = tags.get(_COMPONENT_TYPE_KEY)
 
+        is_root_span = not (parent_span or self.current_span())
+
         # Create a new span context
         span_context = SpanContext(
             name=span_name,
@@ -482,74 +470,90 @@ def trace(
             public=self._public,
         )
 
-        # Create span using the handler
-        span = self._span_handler.create_span(span_context)
+        tracing_ctx = tracing_context_var.get({})
 
-        # Build new span hierarchy: copy existing stack, add new span, save for restoration
-        prev_stack = span_stack_var.get()
-        new_stack = (prev_stack or []).copy()
-        new_stack.append(span)
-        token = span_stack_var.set(new_stack)
+        with contextlib.ExitStack() as stack:
+            if is_root_span:
+                # propagate_attributes sets trace-level metadata (trace name, user, session, etc.)
+                # for the root span and all child spans created within this context
+                stack.enter_context(
+                    langfuse.propagate_attributes(
+                        trace_name=self._name,
+                        user_id=tracing_ctx.get("user_id") or None,
+                        session_id=tracing_ctx.get("session_id") or None,
+                        version=tracing_ctx.get("version") or None,
+                        tags=tracing_ctx.get("tags") or None,
+                    )
+                )
 
-        span.set_tags(tags)
+            # Create span using the handler
+            span = self._span_handler.create_span(span_context)
 
-        try:
-            yield span
-        except Exception:
-            # Exception occurred - capture exception info and pass to __exit__
-            # This allows Langfuse/OpenTelemetry to properly mark the span with ERROR level
-            exc_info = sys.exc_info()
-            try:
-                # Process span data (may fail with nested pipeline exceptions)
-                self._span_handler.handle(span, component_type)
-
-                # End span with exception info (may fail if span data is corrupted)
-                raw_span = span.raw_span()
-                if span._context_manager is not None:
-                    # Pass actual exception info to mark span as failed with ERROR level
-                    span._context_manager.__exit__(*exc_info)
-                elif hasattr(raw_span, "end"):
-                    # Only call end() if it's not a context manager
-                    raw_span.end()
-            except Exception as cleanup_error:
-                # Log cleanup errors but don't let them corrupt context
-                logger.warning(
-                    "Error during span cleanup for {operation_name}: {cleanup_error}",
-                    operation_name=operation_name,
-                    cleanup_error=cleanup_error,
-                )
+            # Build new span hierarchy: copy existing stack, add new span, save for restoration
+            prev_stack = span_stack_var.get()
+            new_stack = (prev_stack or []).copy()
+            new_stack.append(span)
+            token = span_stack_var.set(new_stack)
 
-            # Re-raise the original exception
-            raise
-        else:
-            # No exception - clean exit with success status
-            # This preserves any manually-set log levels (WARNING, DEBUG)
-            try:
-                # Process span data
-                self._span_handler.handle(span, component_type)
-
-                # End span successfully
-                raw_span = span.raw_span()
-                # In v3, we need to properly exit context managers
-                if span._context_manager is not None:
-                    # No exception - pass None to indicate success
-                    span._context_manager.__exit__(None, None, None)
-                elif hasattr(raw_span, "end"):
-                    # Only call end() if it's not a context manager
-                    raw_span.end()
-            except Exception as cleanup_error:
-                # Log cleanup errors but don't let them corrupt context
-                logger.warning(
-                    "Error during span cleanup for {operation_name}: {cleanup_error}",
-                    operation_name=operation_name,
-                    cleanup_error=cleanup_error,
-                )
-        finally:
-            # Restore previous span stack using saved token
-            span_stack_var.reset(token)
+            span.set_tags(tags)
 
-            if self.enforce_flush:
-                self.flush()
+            try:
+                yield span
+            except Exception:
+                # Exception occurred - capture exception info and pass to __exit__
+                # This allows Langfuse/OpenTelemetry to properly mark the span with ERROR level
+                exc_info = sys.exc_info()
+                try:
+                    # Process span data (may fail with nested pipeline exceptions)
+                    self._span_handler.handle(span, component_type)
+
+                    # End span with exception info (may fail if span data is corrupted)
+                    raw_span = span.raw_span()
+                    if span._context_manager is not None:
+                        # Pass actual exception info to mark span as failed with ERROR level
+                        span._context_manager.__exit__(*exc_info)
+                    elif hasattr(raw_span, "end"):
+                        # Only call end() if it's not a context manager
+                        raw_span.end()
+                except Exception as cleanup_error:
+                    # Log cleanup errors but don't let them corrupt context
+                    logger.warning(
+                        "Error during span cleanup for {operation_name}: {cleanup_error}",
+                        operation_name=operation_name,
+                        cleanup_error=cleanup_error,
+                    )
+
+                # Re-raise the original exception
+                raise
+            else:
+                # No exception - clean exit with success status
+                # This preserves any manually-set log levels (WARNING, DEBUG)
+                try:
+                    # Process span data
+                    self._span_handler.handle(span, component_type)
+
+                    # End span successfully
+                    raw_span = span.raw_span()
+                    # In v3, we need to properly exit context managers
+                    if span._context_manager is not None:
+                        # No exception - pass None to indicate success
+                        span._context_manager.__exit__(None, None, None)
+                    elif hasattr(raw_span, "end"):
+                        # Only call end() if it's not a context manager
+                        raw_span.end()
+                except Exception as cleanup_error:
+                    # Log cleanup errors but don't let them corrupt context
+                    logger.warning(
+                        "Error during span cleanup for {operation_name}: {cleanup_error}",
+                        operation_name=operation_name,
+                        cleanup_error=cleanup_error,
+                    )
+            finally:
+                # Restore previous span stack using saved token
+                span_stack_var.reset(token)
+
+                if self.enforce_flush:
+                    self.flush()
 
     def flush(self) -> None:
         """Flush all pending spans to Langfuse."""

integrations/langfuse/tests/test_tracer.py

@@ -63,9 +63,16 @@ def span(self, name=None):
         # Return a new mock span for child spans
         return MockSpan(name=name or "child_span")
 
-    def update_trace(self, **kwargs):
-        # v3 API method for updating trace-level data
-        self._data.update(kwargs)
+    def set_trace_io(self, *, input=None, output=None):
+        # v4 API method for setting trace-level input/output
+        if input is not None:
+            self._data["input"] = input
+        if output is not None:
+            self._data["output"] = output
+
+    def set_trace_as_public(self):
+        # v4 API method for marking trace as public
+        self._data["public"] = True
 
     def generation(self, name=None):
         # Return a new mock span for generation spans
@@ -84,6 +91,16 @@ def flush(self):
         pass
 
 
+class MockPropagateAttributesContextManager:
+    """No-op context manager for propagate_attributes mock."""
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        pass
+
+
 class MockLangfuseClient:
     """Mock Langfuse client that has all the required methods"""
 
@@ -274,6 +291,25 @@ def test_create_span_root_trace(self):
         finally:
             tracing_context_var.reset(token)
 
+    def test_create_span_root_trace_public(self):
+        """Test that public=True calls set_trace_as_public on the span."""
+        mock_client = Mock()
+        mock_client.start_as_current_observation = Mock(return_value=MockContextManager())
+
+        handler = DefaultSpanHandler()
+        handler.init_tracer(mock_client)
+
+        context = MagicMock(spec=SpanContext)
+        context.parent_span = None
+        context.trace_name = "public_trace"
+        context.operation_name = "haystack.pipeline.run"
+        context.public = True
+
+        result = handler.create_span(context)
+
+        # set_trace_as_public should have been called on the raw span
+        assert result.raw_span()._data.get("public") is True
+
     def test_handle_generator(self):
         mock_span = Mock()
         mock_span.raw_span.return_value = mock_span