feat(langfuse): add embedder usage metrics for langfuse (#2542)

* add: langfuse log levels

* fix: dry finally block

* add: embedder cost extraction

* fix: static typing

Author: Hansehart

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

@@ -395,6 +395,30 @@ def handle(self, span: LangfuseSpan, component_type: Optional[str]) -> None:
                 usage = meta[0].get("usage")
                 sanitized_usage = _sanitize_usage_data(usage) if usage else None
                 span.raw_span().update(usage_details=sanitized_usage, model=meta[0].get("model"))
+        elif component_type and component_type.endswith("Embedder"):
+            # Extract usage data from embedder output
+            output = span.get_data().get(_COMPONENT_OUTPUT_KEY, {})
+            meta = output.get("meta")
+
+            if meta and isinstance(meta, dict):
+                # Build update parameters with available data
+                update_params: dict[str, Any] = {}
+
+                # Try both common formats: 'usage' (OpenAI) or 'billed_units' (Cohere)
+                usage = meta.get("usage") or meta.get("billed_units")
+                if usage:
+                    sanitized_usage = _sanitize_usage_data(usage)
+                    if sanitized_usage:
+                        update_params["usage_details"] = sanitized_usage
+
+                # Some embedders may provide model information
+                model = meta.get("model")
+                if model and isinstance(model, str):
+                    update_params["model"] = model
+
+                # Single update call if we have data to update
+                if update_params:
+                    span.raw_span().update(**update_params)
 
 
 class LangfuseTracer(Tracer):

integrations/langfuse/tests/test_tracer.py

@@ -411,6 +411,91 @@ def test_create_span_non_component(self):
         # Verify start_as_current_span was called for the actual span creation (not just parent)
         assert mock_client.start_as_current_span.call_count == 2  # Once for parent, once for the span
 
+    def test_handle_embedder_with_openai_format(self):
+        """Test that embedder usage is extracted in OpenAI format."""
+        mock_span = Mock()
+        mock_span.raw_span.return_value = mock_span
+        mock_span.get_data.return_value = {
+            "haystack.component.type": "OpenAITextEmbedder",
+            "haystack.component.output": {
+                "embedding": [0.1, 0.2, 0.3],
+                "meta": {"model": "custom-model", "usage": {"prompt_tokens": 15, "total_tokens": 15}},
+            },
+        }
+
+        handler = DefaultSpanHandler()
+        handler.handle(mock_span, component_type="OpenAITextEmbedder")
+
+        assert mock_span.update.call_count == 1
+        assert mock_span.update.call_args_list[0][1] == {
+            "usage_details": {"prompt_tokens": 15, "total_tokens": 15},
+            "model": "custom-model",
+        }
+
+    def test_handle_embedder_with_cohere_format(self):
+        """Test that embedder usage is extracted in Cohere billed_units format."""
+        mock_span = Mock()
+        mock_span.raw_span.return_value = mock_span
+        mock_span.get_data.return_value = {
+            "haystack.component.type": "CohereTextEmbedder",
+            "haystack.component.output": {
+                "embedding": [0.1, 0.2, 0.3],
+                "meta": {"api_version": {"version": "1"}, "billed_units": {"input_tokens": 4}},
+            },
+        }
+
+        handler = DefaultSpanHandler()
+        handler.handle(mock_span, component_type="CohereTextEmbedder")
+
+        assert mock_span.update.call_count == 1
+        assert mock_span.update.call_args_list[0][1] == {"usage_details": {"input_tokens": 4}}
+
+    def test_handle_embedder_without_usage(self):
+        """Test that embedders without usage data are handled gracefully."""
+        mock_span = Mock()
+        mock_span.raw_span.return_value = mock_span
+        mock_span.get_data.return_value = {
+            "haystack.component.type": "SentenceTransformersTextEmbedder",
+            "haystack.component.output": {
+                "embedding": [0.1, 0.2, 0.3],
+                "meta": {},  # No usage data
+            },
+        }
+
+        handler = DefaultSpanHandler()
+        handler.handle(mock_span, component_type="SentenceTransformersTextEmbedder")
+
+        # Should not call update when no usage data is available
+        assert mock_span.update.call_count == 0
+
+    def test_handle_embedder_with_nested_usage(self):
+        """Test that embedders with nested usage data are sanitized correctly."""
+        mock_span = Mock()
+        mock_span.raw_span.return_value = mock_span
+        mock_span.get_data.return_value = {
+            "haystack.component.type": "CustomEmbedder",
+            "haystack.component.output": {
+                "embedding": [0.1, 0.2, 0.3],
+                "meta": {
+                    "model": "custom-model",
+                    "usage": {
+                        "cache_creation": {"input_tokens": 10},
+                        "cache_read": {"input_tokens": 5},
+                        "total_tokens": 15,
+                    },
+                },
+            },
+        }
+
+        handler = DefaultSpanHandler()
+        handler.handle(mock_span, component_type="CustomEmbedder")
+
+        assert mock_span.update.call_count == 1
+        assert mock_span.update.call_args_list[0][1] == {
+            "usage_details": {"cache_creation.input_tokens": 10, "cache_read.input_tokens": 5, "total_tokens": 15},
+            "model": "custom-model",
+        }
+
 
 class TestCustomSpanHandler:
     def test_handle(self):