fixed check runs and updated dependencies

Author: wrisa

instrumentation-genai/opentelemetry-instrumentation-langchain/CHANGELOG.md

@@ -5,4 +5,7 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## Unreleased
+## Unreleased
+
+- Added span support for genAI langchain llm invocation.
+  ([#3665](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/3665))

instrumentation-genai/opentelemetry-instrumentation-langchain/examples/manual/main.py

@@ -1,9 +1,11 @@
 from langchain_core.messages import HumanMessage, SystemMessage
 from langchain_openai import ChatOpenAI
 
-from opentelemetry.instrumentation.langchain import LangChainInstrumentor
 from opentelemetry import trace
-from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
+from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
+    OTLPSpanExporter,
+)
+from opentelemetry.instrumentation.langchain import LangChainInstrumentor
 from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import BatchSpanProcessor
 
@@ -42,4 +44,4 @@ def main():
     LangChainInstrumentor().uninstrument()
 
 if __name__ == "__main__":
-    main()
+    main()

instrumentation-genai/opentelemetry-instrumentation-langchain/examples/manual/requirements.txt

@@ -1,7 +1,7 @@
 langchain==0.3.21
 langchain_openai
-opentelemetry-sdk~=1.30.0
-opentelemetry-exporter-otlp-proto-grpc~=1.30.0
+opentelemetry-sdk~=1.36.0
+opentelemetry-exporter-otlp-proto-grpc~=1.36.0
 
 # Uncomment after lanchain instrumetation is released
 # opentelemetry-instrumentation-langchain~=2.0b0.dev

instrumentation-genai/opentelemetry-instrumentation-langchain/examples/zero-code/main.py

@@ -1,9 +1,18 @@
 from langchain_core.messages import HumanMessage, SystemMessage
 from langchain_openai import ChatOpenAI
 
-def main():
 
-    llm = ChatOpenAI(model="gpt-3.5-turbo")
+def main():
+    llm = ChatOpenAI(
+        model="gpt-3.5-turbo",
+        temperature=0.1,
+        max_tokens=100,
+        top_p=0.9,
+        frequency_penalty=0.5,
+        presence_penalty=0.5,
+        stop_sequences=["\n", "Human:", "AI:"],
+        seed=100,
+    )
 
     messages = [
         SystemMessage(content="You are a helpful assistant!"),
@@ -14,4 +23,5 @@ def main():
     print("LLM output:\n", result)
 
 if __name__ == "__main__":
-    main()
+    main()
+

instrumentation-genai/opentelemetry-instrumentation-langchain/examples/zero-code/requirements.txt

@@ -1,7 +1,8 @@
 langchain==0.3.21
 langchain_openai
-opentelemetry-sdk~=1.30.0
-opentelemetry-exporter-otlp-proto-grpc~=1.30.0
+opentelemetry-sdk~=1.36.0
+opentelemetry-exporter-otlp-proto-grpc~=1.36.0
+opentelemetry-distro~=0.57b0
 
 # Uncomment after lanchain instrumetation is released
 # opentelemetry-instrumentation-langchain~=2.0b0.dev

instrumentation-genai/opentelemetry-instrumentation-langchain/pyproject.toml

@@ -25,9 +25,9 @@ classifiers = [
   "Programming Language :: Python :: 3.13",
 ]
 dependencies = [
-  "opentelemetry-api == 1.30",
-  "opentelemetry-instrumentation == 0.51b0",
-  "opentelemetry-semantic-conventions == 0.51b0"
+  "opentelemetry-api == 1.36.0",
+  "opentelemetry-instrumentation == 0.57b0",
+  "opentelemetry-semantic-conventions == 0.57b0"
 ]
 
 [project.optional-dependencies]

instrumentation-genai/opentelemetry-instrumentation-langchain/src/opentelemetry/instrumentation/langchain/__init__.py

@@ -36,20 +36,20 @@
 ---
 """
 
-from typing import Collection
+from typing import Any, Callable, Collection, Optional
 
-from wrapt import wrap_function_wrapper
+from wrapt import wrap_function_wrapper  # type: ignore
 
-from opentelemetry.instrumentation.langchain.config import Config
-from opentelemetry.instrumentation.langchain.version import __version__
-from opentelemetry.instrumentation.langchain.package import _instruments
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from opentelemetry.instrumentation.langchain.callback_handler import (
     OpenTelemetryLangChainCallbackHandler,
 )
-from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.instrumentation.langchain.config import Config
+from opentelemetry.instrumentation.langchain.package import _instruments
+from opentelemetry.instrumentation.langchain.version import __version__
 from opentelemetry.instrumentation.utils import unwrap
-from opentelemetry.trace import get_tracer
 from opentelemetry.semconv.schemas import Schemas
+from opentelemetry.trace import get_tracer
 
 
 class LangChainInstrumentor(BaseInstrumentor):
@@ -59,14 +59,14 @@ class LangChainInstrumentor(BaseInstrumentor):
     to capture LLM telemetry.
     """
 
-    def __init__(self, exception_logger=None):
+    def __init__(self, exception_logger: Optional[Callable[[Exception], Any]] = None):
         super().__init__()
         Config.exception_logger = exception_logger
 
     def instrumentation_dependencies(self) -> Collection[str]:
         return _instruments
 
-    def _instrument(self, **kwargs):
+    def _instrument(self, **kwargs: Any):
         """
         Enable Langchain instrumentation.
         """
@@ -88,7 +88,7 @@ def _instrument(self, **kwargs):
             wrapper=_BaseCallbackManagerInitWrapper(otel_callback_handler),
         )
 
-    def _uninstrument(self, **kwargs):
+    def _uninstrument(self, **kwargs: Any):
         """
         Cleanup instrumentation (unwrap).
         """
@@ -100,14 +100,14 @@ class _BaseCallbackManagerInitWrapper:
     Wrap the BaseCallbackManager __init__ to insert custom callback handler in the manager's handlers list.
     """
 
-    def __init__(self, callback_handler):
+    def __init__(self, callback_handler: OpenTelemetryLangChainCallbackHandler):
         self._otel_handler = callback_handler
 
-    def __call__(self, wrapped, instance, args, kwargs):
+    def __call__(self, wrapped: Callable[..., None], instance: Any, args: tuple[Any, ...], kwargs: dict[str, Any]):
         wrapped(*args, **kwargs)
         # Ensure our OTel callback is present if not already.
         for handler in instance.inheritable_handlers:
             if isinstance(handler, type(self._otel_handler)):
                 break
         else:
-            instance.add_handler(self._otel_handler, inherit=True)
+            instance.add_handler(self._otel_handler, inherit=True)

instrumentation-genai/opentelemetry-instrumentation-langchain/src/opentelemetry/instrumentation/langchain/callback_handler.py

@@ -1,19 +1,23 @@
 import time
 from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional
 from uuid import UUID
 
-from langchain_core.callbacks import BaseCallbackHandler
-from langchain_core.messages import BaseMessage
-from langchain_core.outputs import LLMResult
+from langchain_core.callbacks import BaseCallbackHandler  # type: ignore
+from langchain_core.messages import BaseMessage  # type: ignore
+from langchain_core.outputs import LLMResult  # type: ignore
 
-from opentelemetry.context import get_current, Context
-from opentelemetry.semconv._incubating.attributes import gen_ai_attributes as GenAI
-from opentelemetry.semconv.attributes import error_attributes as ErrorAttributes
-from opentelemetry.trace import Span, SpanKind, set_span_in_context, use_span
+from opentelemetry.context import Context, get_current
+from opentelemetry.instrumentation.langchain.utils import dont_throw
+from opentelemetry.semconv._incubating.attributes import (
+    gen_ai_attributes as GenAI,
+)
+from opentelemetry.semconv.attributes import (
+    error_attributes as ErrorAttributes,
+)
+from opentelemetry.trace import Span, SpanKind, Tracer, set_span_in_context
 from opentelemetry.trace.status import Status, StatusCode
 
-from opentelemetry.instrumentation.langchain.utils import dont_throw
 
 @dataclass
 class _SpanState:
@@ -23,16 +27,16 @@ class _SpanState:
     children: List[UUID] = field(default_factory=list)
 
 
-class OpenTelemetryLangChainCallbackHandler(BaseCallbackHandler):
+class OpenTelemetryLangChainCallbackHandler(BaseCallbackHandler): # type: ignore[misc]
     """
     A callback handler for LangChain that uses OpenTelemetry to create spans for LLM calls and chains, tools etc,. in future.
     """
 
     def __init__(
         self,
-        tracer,
+        tracer: Tracer,
     ) -> None:
-        super().__init__()
+        super().__init__() # type: ignore
         self._tracer = tracer
 
         # Map from run_id -> _SpanState, to keep track of spans and parent/child relationships
@@ -80,30 +84,31 @@ def _create_llm_span(
 
         return span
 
-    def _end_span(self, run_id: UUID):
+    def _end_span(self, run_id: UUID) -> None:
         state = self.spans[run_id]
         for child_id in state.children:
             child_state = self.spans.get(child_id)
-            if child_state and child_state.span.end_time is None:
+            if child_state:
+                # Always end child spans as OpenTelemetry spans don't expose end_time directly
                 child_state.span.end()
-        if state.span.end_time is None:
-            state.span.end()
+            # Always end the span as OpenTelemetry spans don't expose end_time directly
+        state.span.end()
 
     def _get_span(self, run_id: UUID) -> Span:
         return self.spans[run_id].span
 
     @dont_throw
     def on_chat_model_start(
             self,
-            serialized: dict,
-            messages: List[List[BaseMessage]],
+            serialized: Dict[str, Any],
+            messages: List[List[BaseMessage]], # type: ignore
             *,
             run_id: UUID,
-            tags: Optional[list[str]] = None,
+            tags: Optional[List[str]] = None,
             parent_run_id: Optional[UUID] = None,
-            metadata: Optional[dict[str, Any]] = None,
-            **kwargs,
-    ):
+            metadata: Optional[Dict[str, Any]] = None,
+            **kwargs: Any,
+    ) -> None:
         name = serialized.get("name") or kwargs.get("name") or "ChatLLM"
         span = self._create_llm_span(
             run_id=run_id,
@@ -113,7 +118,7 @@ def on_chat_model_start(
 
         invocation_params = kwargs.get("invocation_params")
         if invocation_params is not None:
-            request_model = kwargs.get("invocation_params").get("model_name")
+            request_model = invocation_params.get("model_name")
             if request_model is not None:
                 span.set_attribute(GenAI.GEN_AI_REQUEST_MODEL, request_model)
             top_p = invocation_params.get("top_p")
@@ -129,7 +134,7 @@ def on_chat_model_start(
             if stop_sequences is not None:
                 span.set_attribute(GenAI.GEN_AI_REQUEST_STOP_SEQUENCES, stop_sequences)
             seed = invocation_params.get("seed")
-            if stop_sequences is not None:
+            if seed is not None:
                 span.set_attribute(GenAI.GEN_AI_REQUEST_SEED, seed)
 
 
@@ -148,41 +153,44 @@ def on_chat_model_start(
     @dont_throw
     def on_llm_end(
             self,
-            response: LLMResult,
+            response: LLMResult, # type: ignore
             *,
             run_id: UUID,
-            parent_run_id: Union[UUID, None] = None,
-            **kwargs,
-    ):
+            parent_run_id: Optional[UUID] = None,
+            **kwargs: Any,
+    ) -> None:
         span = self._get_span(run_id)
 
-        finish_reasons = []
-        for generation in getattr(response, "generations", []):
-            for index, chat_generation in enumerate(generation):
-                generation_info = chat_generation.generation_info
+        finish_reasons: List[str] = []
+        for generation in getattr(response, "generations", []): # type: ignore
+            for chat_generation in generation:
+                generation_info = getattr(chat_generation, "generation_info", None)
                 if generation_info is not None:
                     finish_reason = generation_info.get("finish_reason")
                     if finish_reason is not None:
-                        finish_reasons.append(finish_reason or "error")
+                        finish_reasons.append(str(finish_reason) or "error")
 
         span.set_attribute(GenAI.GEN_AI_RESPONSE_FINISH_REASONS, finish_reasons)
 
-        if response.llm_output is not None:
-            response_model = response.llm_output.get("model_name") or response.llm_output.get("model")
+        llm_output = getattr(response, "llm_output", None) # type: ignore
+        if llm_output is not None:
+            response_model = llm_output.get("model_name") or llm_output.get("model")
             if response_model is not None:
-                span.set_attribute(GenAI.GEN_AI_RESPONSE_MODEL, response_model)
+                span.set_attribute(GenAI.GEN_AI_RESPONSE_MODEL, str(response_model))
 
-            response_id = response.llm_output.get("id")
+            response_id = llm_output.get("id")
             if response_id is not None:
-                span.set_attribute(GenAI.GEN_AI_RESPONSE_ID, response_id)
+                span.set_attribute(GenAI.GEN_AI_RESPONSE_ID, str(response_id))
 
             # usage
-            usage = response.llm_output.get("usage") or response.llm_output.get("token_usage")
+            usage = llm_output.get("usage") or llm_output.get("token_usage")
             if usage:
                 prompt_tokens = usage.get("prompt_tokens", 0)
                 completion_tokens = usage.get("completion_tokens", 0)
-                span.set_attribute(GenAI.GEN_AI_USAGE_INPUT_TOKENS, prompt_tokens)
-                span.set_attribute(GenAI.GEN_AI_USAGE_OUTPUT_TOKENS, completion_tokens)
+                span.set_attribute(GenAI.GEN_AI_USAGE_INPUT_TOKENS,
+                                   int(prompt_tokens) if prompt_tokens is not None else 0)
+                span.set_attribute(GenAI.GEN_AI_USAGE_OUTPUT_TOKENS,
+                                   int(completion_tokens) if completion_tokens is not None else 0)
 
         # End the LLM span
         self._end_span(run_id)
@@ -194,12 +202,12 @@ def on_llm_error(
             *,
             run_id: UUID,
             parent_run_id: Optional[UUID] = None,
-            **kwargs,
-    ):
+            **kwargs: Any,
+    ) -> None:
         self._handle_error(error, run_id)
 
     def _handle_error(self, error: BaseException, run_id: UUID):
         span = self._get_span(run_id)
         span.set_status(Status(StatusCode.ERROR, str(error)))
         span.set_attribute(ErrorAttributes.ERROR_TYPE, type(error).__qualname__)
-        self._end_span(run_id)
+        self._end_span(run_id)

instrumentation-genai/opentelemetry-instrumentation-langchain/src/opentelemetry/instrumentation/langchain/config.py

@@ -11,11 +11,13 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from typing import Any, Callable, Optional
+
 
 class Config:
     """
     Shared static config for LangChain OTel instrumentation.
     """
 
     # Logger to handle exceptions during instrumentation
-    exception_logger = None
+    exception_logger: Optional[Callable[[Exception], Any]] = None