fixed ruff error

Author: wrisa

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

@@ -14,8 +14,8 @@
 span_processor = BatchSpanProcessor(OTLPSpanExporter())
 trace.get_tracer_provider().add_span_processor(span_processor)
 
-def main():
 
+def main():
     # Set up instrumentation
     LangChainInstrumentor().instrument()
 
@@ -43,5 +43,6 @@ def main():
     # Un-instrument after use
     LangChainInstrumentor().uninstrument()
 
+
 if __name__ == "__main__":
     main()

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

@@ -22,6 +22,6 @@ def main():
     result = llm.invoke(messages).content
     print("LLM output:\n", result)
 
+
 if __name__ == "__main__":
     main()
-

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

@@ -59,7 +59,9 @@ class LangChainInstrumentor(BaseInstrumentor):
     to capture LLM telemetry.
     """
 
-    def __init__(self, exception_logger: Optional[Callable[[Exception], Any]] = None):
+    def __init__(
+        self, exception_logger: Optional[Callable[[Exception], Any]] = None
+    ):
         super().__init__()
         Config.exception_logger = exception_logger
 
@@ -100,10 +102,18 @@ class _BaseCallbackManagerInitWrapper:
     Wrap the BaseCallbackManager __init__ to insert custom callback handler in the manager's handlers list.
     """
 
-    def __init__(self, callback_handler: OpenTelemetryLangChainCallbackHandler):
+    def __init__(
+        self, callback_handler: OpenTelemetryLangChainCallbackHandler
+    ):
         self._otel_handler = callback_handler
 
-    def __call__(self, wrapped: Callable[..., None], instance: Any, args: tuple[Any, ...], kwargs: dict[str, Any]):
+    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:

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

@@ -27,7 +27,7 @@ class _SpanState:
     children: List[UUID] = field(default_factory=list)
 
 
-class OpenTelemetryLangChainCallbackHandler(BaseCallbackHandler): # type: ignore[misc]
+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.
     """
@@ -36,7 +36,7 @@ def __init__(
         self,
         tracer: Tracer,
     ) -> None:
-        super().__init__() # type: ignore
+        super().__init__()  # type: ignore
         self._tracer = tracer
 
         # Map from run_id -> _SpanState, to keep track of spans and parent/child relationships
@@ -53,7 +53,9 @@ def _create_span(
         if parent_run_id is not None and parent_run_id in self.spans:
             parent_span = self.spans[parent_run_id].span
             ctx = set_span_in_context(parent_span)
-            span = self._tracer.start_span(name=span_name, kind=kind, context=ctx)
+            span = self._tracer.start_span(
+                name=span_name, kind=kind, context=ctx
+            )
         else:
             # top-level or missing parent
             span = self._tracer.start_span(name=span_name, kind=kind)
@@ -72,14 +74,16 @@ def _create_llm_span(
         parent_run_id: Optional[UUID],
         name: str,
     ) -> Span:
-
         span = self._create_span(
             run_id=run_id,
             parent_run_id=parent_run_id,
             span_name=f"{name}.{GenAI.GenAiOperationNameValues.CHAT.value}",
             kind=SpanKind.CLIENT,
         )
-        span.set_attribute(GenAI.GEN_AI_OPERATION_NAME, GenAI.GenAiOperationNameValues.CHAT.value)
+        span.set_attribute(
+            GenAI.GEN_AI_OPERATION_NAME,
+            GenAI.GenAiOperationNameValues.CHAT.value,
+        )
         span.set_attribute(GenAI.GEN_AI_SYSTEM, name)
 
         return span
@@ -99,15 +103,15 @@ def _get_span(self, run_id: UUID) -> Span:
 
     @dont_throw
     def on_chat_model_start(
-            self,
-            serialized: Dict[str, Any],
-            messages: List[List[BaseMessage]], # type: ignore
-            *,
-            run_id: UUID,
-            tags: Optional[List[str]] = None,
-            parent_run_id: Optional[UUID] = None,
-            metadata: Optional[Dict[str, Any]] = None,
-            **kwargs: Any,
+        self,
+        serialized: Dict[str, Any],
+        messages: List[List[BaseMessage]],  # type: ignore
+        *,
+        run_id: UUID,
+        tags: Optional[List[str]] = None,
+        parent_run_id: Optional[UUID] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
     ) -> None:
         name = serialized.get("name") or kwargs.get("name") or "ChatLLM"
         span = self._create_llm_span(
@@ -126,18 +130,23 @@ def on_chat_model_start(
                 span.set_attribute(GenAI.GEN_AI_REQUEST_TOP_P, top_p)
             frequency_penalty = invocation_params.get("frequency_penalty")
             if frequency_penalty is not None:
-                span.set_attribute(GenAI.GEN_AI_REQUEST_FREQUENCY_PENALTY, frequency_penalty)
+                span.set_attribute(
+                    GenAI.GEN_AI_REQUEST_FREQUENCY_PENALTY, frequency_penalty
+                )
             presence_penalty = invocation_params.get("presence_penalty")
             if presence_penalty is not None:
-                span.set_attribute(GenAI.GEN_AI_REQUEST_PRESENCE_PENALTY, presence_penalty)
+                span.set_attribute(
+                    GenAI.GEN_AI_REQUEST_PRESENCE_PENALTY, presence_penalty
+                )
             stop_sequences = invocation_params.get("stop")
             if stop_sequences is not None:
-                span.set_attribute(GenAI.GEN_AI_REQUEST_STOP_SEQUENCES, stop_sequences)
+                span.set_attribute(
+                    GenAI.GEN_AI_REQUEST_STOP_SEQUENCES, stop_sequences
+                )
             seed = invocation_params.get("seed")
             if seed is not None:
                 span.set_attribute(GenAI.GEN_AI_REQUEST_SEED, seed)
 
-
         if metadata is not None:
             max_tokens = metadata.get("ls_max_tokens")
             if max_tokens is not None:
@@ -148,35 +157,45 @@ def on_chat_model_start(
                 span.set_attribute("gen_ai.provider.name", provider)
             temperature = metadata.get("ls_temperature")
             if temperature is not None:
-                span.set_attribute(GenAI.GEN_AI_REQUEST_TEMPERATURE, temperature)
+                span.set_attribute(
+                    GenAI.GEN_AI_REQUEST_TEMPERATURE, temperature
+                )
 
     @dont_throw
     def on_llm_end(
-            self,
-            response: LLMResult, # type: ignore
-            *,
-            run_id: UUID,
-            parent_run_id: Optional[UUID] = None,
-            **kwargs: Any,
+        self,
+        response: LLMResult,  # type: ignore
+        *,
+        run_id: UUID,
+        parent_run_id: Optional[UUID] = None,
+        **kwargs: Any,
     ) -> None:
         span = self._get_span(run_id)
 
         finish_reasons: List[str] = []
-        for generation in getattr(response, "generations", []): # type: ignore
+        for generation in getattr(response, "generations", []):  # type: ignore
             for chat_generation in generation:
-                generation_info = getattr(chat_generation, "generation_info", None)
+                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(str(finish_reason) or "error")
 
-        span.set_attribute(GenAI.GEN_AI_RESPONSE_FINISH_REASONS, finish_reasons)
+        span.set_attribute(
+            GenAI.GEN_AI_RESPONSE_FINISH_REASONS, finish_reasons
+        )
 
-        llm_output = getattr(response, "llm_output", None) # type: ignore
+        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")
+            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, str(response_model))
+                span.set_attribute(
+                    GenAI.GEN_AI_RESPONSE_MODEL, str(response_model)
+                )
 
             response_id = llm_output.get("id")
             if response_id is not None:
@@ -187,27 +206,35 @@ def on_llm_end(
             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,
-                                   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)
+                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)
 
     @dont_throw
     def on_llm_error(
-            self,
-            error: BaseException,
-            *,
-            run_id: UUID,
-            parent_run_id: Optional[UUID] = None,
-            **kwargs: Any,
+        self,
+        error: BaseException,
+        *,
+        run_id: UUID,
+        parent_run_id: Optional[UUID] = None,
+        **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__)
+        span.set_attribute(
+            ErrorAttributes.ERROR_TYPE, type(error).__qualname__
+        )
         self._end_span(run_id)

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

@@ -20,11 +20,13 @@
 
 F = TypeVar("F", bound=Callable[..., Any])
 
+
 def dont_throw(func: F) -> F:
     """
     Decorator that catches and logs exceptions, rather than re-raising them,
     to avoid interfering with user code if instrumentation fails.
     """
+
     def wrapper(*args: Any, **kwargs: Any) -> Optional[Any]:
         try:
             return func(*args, **kwargs)
@@ -35,7 +37,9 @@ def wrapper(*args: Any, **kwargs: Any) -> Optional[Any]:
                 traceback.format_exc(),
             )
             from opentelemetry.instrumentation.langchain.config import Config
+
             if Config.exception_logger:
                 Config.exception_logger(e)
             return None
+
     return wrapper  # type: ignore

instrumentation-genai/opentelemetry-instrumentation-langchain/tests/conftest.py

@@ -20,12 +20,14 @@ def fixture_span_exporter():
     exporter = InMemorySpanExporter()
     yield exporter
 
+
 @pytest.fixture(scope="function", name="tracer_provider")
 def fixture_tracer_provider(span_exporter):
     provider = TracerProvider()
     provider.add_span_processor(SimpleSpanProcessor(span_exporter))
     return provider
 
+
 @pytest.fixture(scope="function")
 def start_instrumentation(
     tracer_provider,
@@ -38,6 +40,7 @@ def start_instrumentation(
     yield instrumentor
     instrumentor.uninstrument()
 
+
 @pytest.fixture(autouse=True)
 def environment():
     if not os.getenv("OPENAI_API_KEY"):
@@ -48,6 +51,7 @@ def environment():
 def chatOpenAI_client():
     return ChatOpenAI()
 
+
 @pytest.fixture(scope="module")
 def vcr_config():
     return {
@@ -61,10 +65,12 @@ def vcr_config():
         "before_record_response": scrub_response_headers,
     }
 
+
 class LiteralBlockScalar(str):
     """Formats the string as a literal block scalar, preserving whitespace and
     without interpreting escape characters"""
 
+
 def literal_block_scalar_presenter(dumper, data):
     """Represents a scalar string as a literal block, via '|' syntax"""
     return dumper.represent_scalar("tag:yaml.org,2002:str", data, style="|")
@@ -134,4 +140,3 @@ def scrub_response_headers(response):
     response["headers"]["openai-organization"] = "test_openai_org_id"
     response["headers"]["Set-Cookie"] = "test_set_cookie"
     return response
-