feat(langchain): Change LLM span operation to generate_text and capture agent name

Update the LangChain integration to track LLM operations as gen_ai.generate_text
instead of gen_ai.pipeline. This provides more specific operation semantics for
LLM invocations. Additionally, capture the agent name when an LLM is invoked
within an agent context using _push_agent/_pop_agent tracking.

- Change span operation from OP.GEN_AI_PIPELINE to OP.GEN_AI_GENERATE_TEXT
- Update span name to include model information
- Add GEN_AI_OPERATION_NAME span data
- Add GEN_AI_AGENT_NAME span data when agent context is active
- Add GEN_AI_PIPELINE_NAME span data when pipeline name is provided
- Update tests to check for new operation type and span data fields

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

Author: ericapisani

sentry_sdk/integrations/langchain.py

@@ -366,15 +366,25 @@ def on_llm_start(
                 or ""
             )
 
+            pipeline_name = kwargs.get("name")
             watched_span = self._create_span(
                 run_id,
                 parent_run_id,
-                op=OP.GEN_AI_PIPELINE,
-                name=kwargs.get("name") or "Langchain LLM call",
+                op=OP.GEN_AI_GENERATE_TEXT,
+                name=f"generate_text {model}".strip(),
                 origin=LangchainIntegration.origin,
             )
             span = watched_span.span
 
+            span.set_data(SPANDATA.GEN_AI_OPERATION_NAME, "generate_text")
+
+            agent_name = _get_current_agent()
+            if agent_name:
+                span.set_data(SPANDATA.GEN_AI_AGENT_NAME, agent_name)
+
+            if pipeline_name:
+                span.set_data(SPANDATA.GEN_AI_PIPELINE_NAME, pipeline_name)
+
             if model:
                 span.set_data(
                     SPANDATA.GEN_AI_REQUEST_MODEL,

tests/integrations/langchain/test_langchain.py

@@ -27,6 +27,8 @@
     SentryLangchainCallback,
     _transform_langchain_content_block,
     _transform_langchain_message_content,
+    _push_agent,
+    _pop_agent,
 )
 
 try:
@@ -851,12 +853,15 @@ def test_langchain_integration_with_langchain_core_only(sentry_init, capture_eve
         assert tx["type"] == "transaction"
 
         llm_spans = [
-            span for span in tx.get("spans", []) if span.get("op") == "gen_ai.pipeline"
+            span
+            for span in tx.get("spans", [])
+            if span.get("op") == "gen_ai.generate_text"
         ]
         assert len(llm_spans) > 0
 
         llm_span = llm_spans[0]
-        assert llm_span["description"] == "Langchain LLM call"
+        assert llm_span["description"] == "generate_text gpt-3.5-turbo"
+        assert llm_span["data"]["gen_ai.operation.name"] == "generate_text"
         assert llm_span["data"]["gen_ai.request.model"] == "gpt-3.5-turbo"
         assert (
             llm_span["data"]["gen_ai.response.text"]
@@ -867,6 +872,110 @@ def test_langchain_integration_with_langchain_core_only(sentry_init, capture_eve
         assert llm_span["data"]["gen_ai.usage.output_tokens"] == 15
 
 
+def test_langchain_llm_span_includes_agent_name(sentry_init, capture_events):
+    from langchain_core.outputs import LLMResult, Generation
+
+    with patch("sentry_sdk.integrations.langchain.AgentExecutor", None):
+        from sentry_sdk.integrations.langchain import (
+            LangchainIntegration,
+            SentryLangchainCallback,
+        )
+
+        sentry_init(
+            integrations=[LangchainIntegration(include_prompts=True)],
+            traces_sample_rate=1.0,
+            send_default_pii=True,
+        )
+        events = capture_events()
+
+        callback = SentryLangchainCallback(max_span_map_size=100, include_prompts=True)
+
+        run_id = "12345678-1234-1234-1234-123456789abc"
+        serialized = {"_type": "openai", "model_name": "gpt-3.5-turbo"}
+        prompts = ["Hello"]
+
+        with start_transaction():
+            _push_agent("test-agent")
+            try:
+                callback.on_llm_start(
+                    serialized=serialized,
+                    prompts=prompts,
+                    run_id=run_id,
+                    invocation_params={"model": "gpt-3.5-turbo"},
+                )
+
+                response = LLMResult(
+                    generations=[[Generation(text="Hi")]],
+                    llm_output={},
+                )
+                callback.on_llm_end(response=response, run_id=run_id)
+            finally:
+                _pop_agent()
+
+        assert len(events) > 0
+        tx = events[0]
+
+        llm_spans = [
+            span
+            for span in tx.get("spans", [])
+            if span.get("op") == "gen_ai.generate_text"
+        ]
+        assert len(llm_spans) == 1
+
+        llm_span = llm_spans[0]
+        assert llm_span["data"][SPANDATA.GEN_AI_AGENT_NAME] == "test-agent"
+
+
+def test_langchain_llm_span_no_agent_name_when_no_agent(sentry_init, capture_events):
+    from langchain_core.outputs import LLMResult, Generation
+
+    with patch("sentry_sdk.integrations.langchain.AgentExecutor", None):
+        from sentry_sdk.integrations.langchain import (
+            LangchainIntegration,
+            SentryLangchainCallback,
+        )
+
+        sentry_init(
+            integrations=[LangchainIntegration(include_prompts=True)],
+            traces_sample_rate=1.0,
+            send_default_pii=True,
+        )
+        events = capture_events()
+
+        callback = SentryLangchainCallback(max_span_map_size=100, include_prompts=True)
+
+        run_id = "12345678-1234-1234-1234-123456789def"
+        serialized = {"_type": "openai", "model_name": "gpt-3.5-turbo"}
+        prompts = ["Hello"]
+
+        with start_transaction():
+            callback.on_llm_start(
+                serialized=serialized,
+                prompts=prompts,
+                run_id=run_id,
+                invocation_params={"model": "gpt-3.5-turbo"},
+            )
+
+            response = LLMResult(
+                generations=[[Generation(text="Hi")]],
+                llm_output={},
+            )
+            callback.on_llm_end(response=response, run_id=run_id)
+
+        assert len(events) > 0
+        tx = events[0]
+
+        llm_spans = [
+            span
+            for span in tx.get("spans", [])
+            if span.get("op") == "gen_ai.generate_text"
+        ]
+        assert len(llm_spans) == 1
+
+        llm_span = llm_spans[0]
+        assert SPANDATA.GEN_AI_AGENT_NAME not in llm_span["data"]
+
+
 def test_langchain_message_role_mapping(sentry_init, capture_events):
     """Test that message roles are properly normalized in langchain integration."""
     global llm_type
@@ -1062,11 +1171,12 @@ def test_langchain_message_truncation(sentry_init, capture_events):
     assert tx["type"] == "transaction"
 
     llm_spans = [
-        span for span in tx.get("spans", []) if span.get("op") == "gen_ai.pipeline"
+        span for span in tx.get("spans", []) if span.get("op") == "gen_ai.generate_text"
     ]
     assert len(llm_spans) > 0
 
     llm_span = llm_spans[0]
+    assert llm_span["data"]["gen_ai.operation.name"] == "generate_text"
     assert SPANDATA.GEN_AI_REQUEST_MESSAGES in llm_span["data"]
 
     messages_data = llm_span["data"][SPANDATA.GEN_AI_REQUEST_MESSAGES]
@@ -1776,11 +1886,12 @@ def test_langchain_response_model_extraction(
     assert tx["type"] == "transaction"
 
     llm_spans = [
-        span for span in tx.get("spans", []) if span.get("op") == "gen_ai.pipeline"
+        span for span in tx.get("spans", []) if span.get("op") == "gen_ai.generate_text"
     ]
     assert len(llm_spans) > 0
 
     llm_span = llm_spans[0]
+    assert llm_span["data"]["gen_ai.operation.name"] == "generate_text"
 
     if expected_model is not None:
         assert SPANDATA.GEN_AI_RESPONSE_MODEL in llm_span["data"]