Fix additional ruff linting errors

- Remove unused imports (extract_span_context, store_span_context)
- Fix import sorting in traceloop files
- Remove unnecessary f-string without placeholders
- Fix undefined logger references (changed to _LOGGER)
- Apply ruff formatting to affected files

All files now pass 'ruff check' and 'ruff format --check'

Author: shuningc

util/opentelemetry-util-genai-evals/src/opentelemetry/util/genai/evals/env.py

@@ -49,6 +49,7 @@ def read_aggregation_flag(
         return None
     return raw.strip().lower() in _TRUTHY
 
+
 __all__ = [
     "read_raw_evaluators",
     "read_interval",

util/opentelemetry-util-genai-evals/src/opentelemetry/util/genai/evals/manager.py

@@ -15,7 +15,6 @@
 from ..environment_variables import (
     OTEL_INSTRUMENTATION_GENAI_EVALS_EVALUATORS,
 )
-from ..span_context import extract_span_context, store_span_context
 from ..types import (
     AgentCreation,
     AgentInvocation,

util/opentelemetry-util-genai-traceloop-translator/examples/traceloop_processor_example.py

@@ -3,15 +3,16 @@
 from __future__ import annotations
 
 import os
+
 from dotenv import load_dotenv
 
 # Load .env first
 load_dotenv()
 
 try:
-    from traceloop.sdk import Traceloop
-    from traceloop.sdk.decorators import task, workflow, agent, tool
     from openai import OpenAI
+    from traceloop.sdk import Traceloop
+    from traceloop.sdk.decorators import agent, task, tool, workflow
 
     # Initialize Traceloop - this will also trigger TraceloopSpanProcessor registration
     Traceloop.init(disable_batch=True, api_endpoint="http://localhost:4318")
@@ -48,7 +49,7 @@ def translate_joke_to_pirate(joke: str):
 def history_jokes_tool():
     completion = client.chat.completions.create(
         model="gpt-3.5-turbo",
-        messages=[{"role": "user", "content": f"get some history jokes"}],
+        messages=[{"role": "user", "content": "get some history jokes"}],
     )
 
     return completion.choices[0].message.content

util/opentelemetry-util-genai-traceloop-translator/src/opentelemetry/util/genai/processor/traceloop_span_processor.py

@@ -26,12 +26,11 @@
 from opentelemetry.context import Context
 from opentelemetry.sdk.trace import ReadableSpan, SpanProcessor
 from opentelemetry.trace import Span
-
-from opentelemetry.util.genai.types import LLMInvocation
 from opentelemetry.util.genai.handler import (
-    get_telemetry_handler,
     TelemetryHandler,
+    get_telemetry_handler,
 )
+from opentelemetry.util.genai.types import LLMInvocation
 
 from .content_normalizer import normalize_traceloop_content
 

util/opentelemetry-util-genai-traceloop-translator/tests/test_traceloop_integration.py

@@ -6,17 +6,14 @@
 
 import json
 import os
+
 import pytest
-from unittest.mock import Mock, patch
 
-from opentelemetry import trace
-from opentelemetry.sdk.trace import TracerProvider, ReadableSpan
+from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import SimpleSpanProcessor
 from opentelemetry.sdk.trace.export.in_memory_span_exporter import (
     InMemorySpanExporter,
 )
-from opentelemetry.trace import SpanKind
-
 from opentelemetry.util.genai.processor.traceloop_span_processor import (
     TraceloopSpanProcessor,
 )
@@ -122,9 +119,9 @@ def test_simple_workflow_with_tasks(self, setup_tracer):
             and s.attributes.get("gen_ai.workflow.name")
             == "pirate_joke_generator"
         ]
-        assert len(workflow_spans) >= 1, (
-            "Should have at least one workflow span"
-        )
+        assert (
+            len(workflow_spans) >= 1
+        ), "Should have at least one workflow span"
 
         # Find task spans
         task_spans = [
@@ -150,9 +147,9 @@ def test_simple_workflow_with_tasks(self, setup_tracer):
                 traceloop_keys = [
                     k for k in traceloop_keys if k != "_traceloop_processed"
                 ]
-                assert len(traceloop_keys) == 0, (
-                    f"Span {span.name} should not have traceloop.* attributes, found: {traceloop_keys}"
-                )
+                assert (
+                    len(traceloop_keys) == 0
+                ), f"Span {span.name} should not have traceloop.* attributes, found: {traceloop_keys}"
 
     def test_nested_agent_with_tool(self, setup_tracer):
         """Test @agent pattern with nested @tool calls."""
@@ -247,9 +244,9 @@ def test_nested_agent_with_tool(self, setup_tracer):
             input_data = json.loads(
                 agent_with_input[0].attributes["gen_ai.input.messages"]
             )
-            assert isinstance(input_data, list), (
-                "Input should be normalized to message array"
-            )
+            assert isinstance(
+                input_data, list
+            ), "Input should be normalized to message array"
 
 
 class TestParentChildRelationships:
@@ -288,9 +285,9 @@ def test_parent_child_hierarchy_preserved(self, setup_tracer):
             if child.parent and child.parent.span_id in span_map:
                 valid_parent_refs += 1
 
-        assert valid_parent_refs >= 1, (
-            "At least one child should have a valid parent reference"
-        )
+        assert (
+            valid_parent_refs >= 1
+        ), "At least one child should have a valid parent reference"
 
 
 class TestContentNormalization:
@@ -345,22 +342,22 @@ def test_normalize_entity_input_output(self, setup_tracer):
         ]
 
         # Should have at least the mutated original span with gen_ai.input.messages
-        assert len(spans_with_input) >= 1, (
-            f"Should have spans with normalized input, got {len(spans)} spans total"
-        )
+        assert (
+            len(spans_with_input) >= 1
+        ), f"Should have spans with normalized input, got {len(spans)} spans total"
 
         # Verify normalization
         for span in spans_with_input:
             input_str = span.attributes.get("gen_ai.input.messages")
             if input_str:
                 input_data = json.loads(input_str)
-                assert isinstance(input_data, list), (
-                    "Input should be list of messages"
-                )
+                assert isinstance(
+                    input_data, list
+                ), "Input should be list of messages"
                 if input_data:
-                    assert "role" in input_data[0], (
-                        "Messages should have role field"
-                    )
+                    assert (
+                        "role" in input_data[0]
+                    ), "Messages should have role field"
 
         # Check output normalization
         spans_with_output = [
@@ -374,9 +371,9 @@ def test_normalize_entity_input_output(self, setup_tracer):
                 "gen_ai.output.messages"
             )
             output_data = json.loads(output_str)
-            assert isinstance(output_data, list), (
-                "Output should be list of messages"
-            )
+            assert isinstance(
+                output_data, list
+            ), "Output should be list of messages"
 
     def test_normalize_string_input(self, setup_tracer):
         """Test normalization of simple string inputs."""
@@ -402,9 +399,9 @@ def test_normalize_string_input(self, setup_tracer):
             and any(k.startswith("gen_ai.") for k in s.attributes.keys())
         ]
 
-        assert len(spans_with_genai) >= 1, (
-            "Should have spans with gen_ai.* attributes after processing"
-        )
+        assert (
+            len(spans_with_genai) >= 1
+        ), "Should have spans with gen_ai.* attributes after processing"
 
     def test_normalize_list_of_strings(self, setup_tracer):
         """Test normalization of list inputs."""
@@ -431,9 +428,9 @@ def test_normalize_list_of_strings(self, setup_tracer):
             for s in spans
             if s.attributes and "gen_ai.span.kind" in s.attributes
         ]
-        assert len(spans_with_genai) >= 1, (
-            "Should have processed spans with gen_ai attributes"
-        )
+        assert (
+            len(spans_with_genai) >= 1
+        ), "Should have processed spans with gen_ai attributes"
 
 
 class TestModelInference:
@@ -480,9 +477,9 @@ def test_preserve_explicit_model(self, setup_tracer):
             and s.attributes.get("gen_ai.request.model") == "gpt-4"
         ]
 
-        assert len(spans_with_model) >= 1, (
-            "Should preserve explicit model attribute"
-        )
+        assert (
+            len(spans_with_model) >= 1
+        ), "Should preserve explicit model attribute"
 
 
 class TestSpanFiltering:
@@ -500,18 +497,18 @@ def test_filters_non_llm_spans(self, setup_tracer):
         spans = exporter.get_finished_spans()
 
         # Should only have the original span, no synthetic spans
-        assert len(spans) == 1, (
-            f"Expected 1 span (non-LLM filtered), got {len(spans)}"
-        )
+        assert (
+            len(spans) == 1
+        ), f"Expected 1 span (non-LLM filtered), got {len(spans)}"
 
         # Original span should not have gen_ai.* attributes
         span = spans[0]
         gen_ai_attrs = [
             k for k in span.attributes.keys() if k.startswith("gen_ai.")
         ]
-        assert len(gen_ai_attrs) == 0, (
-            "Non-LLM span should not have gen_ai.* attributes"
-        )
+        assert (
+            len(gen_ai_attrs) == 0
+        ), "Non-LLM span should not have gen_ai.* attributes"
 
     def test_includes_traceloop_spans(self, setup_tracer):
         """Test that Traceloop task/workflow spans are included."""
@@ -534,9 +531,9 @@ def test_includes_traceloop_spans(self, setup_tracer):
             for s in spans
             if s.attributes and s.attributes.get("gen_ai.span.kind") == "task"
         ]
-        assert len(spans_with_kind) >= 1, (
-            f"Traceloop task should be transformed, got {len(spans)} spans"
-        )
+        assert (
+            len(spans_with_kind) >= 1
+        ), f"Traceloop task should be transformed, got {len(spans)} spans"
 
 
 class TestOperationInference:
@@ -560,9 +557,9 @@ def test_infer_chat_operation(self, setup_tracer):
             if s.attributes and "gen_ai.system" in s.attributes
         ]
 
-        assert len(spans_with_genai) >= 1, (
-            f"Should have processed spans with gen_ai attributes, got {len(spans)} total spans"
-        )
+        assert (
+            len(spans_with_genai) >= 1
+        ), f"Should have processed spans with gen_ai attributes, got {len(spans)} total spans"
 
     def test_infer_embedding_operation(self, setup_tracer):
         """Test that 'embedding' operation is inferred from span name."""
@@ -587,9 +584,9 @@ def test_infer_embedding_operation(self, setup_tracer):
             in s.attributes.get("gen_ai.request.model", "")
         ]
 
-        assert len(spans_with_embedding) >= 1, (
-            f"Should process embedding spans, got {len(spans)} total spans"
-        )
+        assert (
+            len(spans_with_embedding) >= 1
+        ), f"Should process embedding spans, got {len(spans)} total spans"
 
 
 class TestComplexWorkflow:
@@ -673,9 +670,9 @@ def test_full_pirate_joke_workflow(self, setup_tracer):
         spans = exporter.get_finished_spans()
 
         # Should have many spans (original mutated + synthetic)
-        assert len(spans) >= 8, (
-            f"Expected at least 8 spans in full workflow, got {len(spans)}"
-        )
+        assert (
+            len(spans) >= 8
+        ), f"Expected at least 8 spans in full workflow, got {len(spans)}"
 
         # Verify workflow span exists - look for spans with the workflow name
         workflow_spans = [
@@ -685,9 +682,9 @@ def test_full_pirate_joke_workflow(self, setup_tracer):
             and s.attributes.get("gen_ai.workflow.name")
             == "pirate_joke_generator"
         ]
-        assert len(workflow_spans) >= 1, (
-            f"Should have workflow span, got {len(spans)} total spans, workflow_spans={len(workflow_spans)}"
-        )
+        assert (
+            len(workflow_spans) >= 1
+        ), f"Should have workflow span, got {len(spans)} total spans, workflow_spans={len(workflow_spans)}"
 
         # Verify all task names are present
         task_names = {"joke_creation", "signature_generation"}
@@ -698,9 +695,9 @@ def test_full_pirate_joke_workflow(self, setup_tracer):
                 if agent_name in task_names:
                     found_tasks.add(agent_name)
 
-        assert len(found_tasks) >= 1, (
-            f"Should find task spans, found: {found_tasks}"
-        )
+        assert (
+            len(found_tasks) >= 1
+        ), f"Should find task spans, found: {found_tasks}"
 
         # Verify no traceloop.* attributes remain (mutation)
         for span in spans:
@@ -711,9 +708,9 @@ def test_full_pirate_joke_workflow(self, setup_tracer):
                     if k.startswith("traceloop.")
                     and k != "_traceloop_processed"
                 ]
-                assert len(traceloop_keys) == 0, (
-                    f"Span {span.name} should not have traceloop.* attributes"
-                )
+                assert (
+                    len(traceloop_keys) == 0
+                ), f"Span {span.name} should not have traceloop.* attributes"
 
 
 class TestEdgeCases:

util/opentelemetry-util-genai/src/opentelemetry/util/genai/config.py

@@ -115,15 +115,17 @@ def parse_env() -> Settings:
     ).strip()
     emit_legacy_event = legacy_event_flag.lower() in {"1", "true", "yes"}
 
-    evaluation_sample_rate = os.environ.get(OTEL_INSTRUMENTATION_GENAI_EVALUATION_SAMPLE_RATE)
+    evaluation_sample_rate = os.environ.get(
+        OTEL_INSTRUMENTATION_GENAI_EVALUATION_SAMPLE_RATE
+    )
     if evaluation_sample_rate is None or evaluation_sample_rate.strip() == "":
         evaluation_sample_rate = 1.0
     try:
         evaluation_sample_rate = float(evaluation_sample_rate)
     except ValueError:
-        evaluation_sample_rate =  1.0
+        evaluation_sample_rate = 1.0
     if evaluation_sample_rate < 0.0:
-        evaluation_sample_rate =  0.0
+        evaluation_sample_rate = 0.0
     if evaluation_sample_rate > 1.0:
         evaluation_sample_rate = 1.0
 

util/opentelemetry-util-genai/src/opentelemetry/util/genai/emitters/span.py

@@ -112,8 +112,9 @@ def _apply_gen_ai_semconv_attributes(
         except Exception:  # pragma: no cover - defensive
             pass
 
+
 def _apply_sampled_for_evaluation(
-    span:  Span,
+    span: Span,
     is_sampled: bool,
 ) -> None:
     span.set_attribute("gen_ai.evaluation.sampled", is_sampled)
@@ -324,7 +325,9 @@ def on_start(
             self._apply_start_attrs(invocation)
 
     def on_end(self, invocation: LLMInvocation | EmbeddingInvocation) -> None:
-        _apply_sampled_for_evaluation(invocation.span, invocation.sample_for_evaluation)# type: ignore[override]
+        _apply_sampled_for_evaluation(
+            invocation.span, invocation.sample_for_evaluation
+        )  # type: ignore[override]
         if isinstance(invocation, Workflow):
             self._finish_workflow(invocation)
         elif isinstance(invocation, (AgentCreation, AgentInvocation)):