refactor: clean up logging - remove emojis, add prefixes, improve correlation

    Changes:
    - main_traceloop.py: Replace emojis with [INIT], [FLUSH], [SUCCESS], [ERROR] prefixes
    - traceloop_span_processor.py: Add [TL_PROCESSOR] prefix to all logs
    - Simplify debug messages for better log correlation and filtering
    - Make logging more professional and concise
    - Maintain consistent format: [PREFIX] Message: key=value, key=value

Author: adityamehra

instrumentation-genai/opentelemetry-instrumentation-langchain/examples/multi_agent_travel_planner/main_traceloop.py

@@ -114,7 +114,7 @@
     app_name=OTEL_SERVICE_NAME,
     resource_attributes=resource_attributes
 )
-print("✓ Traceloop SDK initialized with zero-code translator")
+print("[INIT] Traceloop SDK initialized with zero-code translator")
 
 
 def _configure_otlp_logging() -> None:
@@ -130,7 +130,7 @@ def _configure_otlp_logging() -> None:
     try:
         existing = get_logger_provider()
         if isinstance(existing, LoggerProvider):
-            print("✓ LoggerProvider already configured")
+            print("[INIT] LoggerProvider already configured")
             return
     except:
         pass
@@ -157,7 +157,7 @@ def _configure_otlp_logging() -> None:
     )
     logger_provider.add_log_record_processor(log_processor)
     set_logger_provider(logger_provider)
-    print(f"✓ OTLP logging configured with endpoint: {log_endpoint}")
+    print(f"[INIT] OTLP logging configured, endpoint={log_endpoint}")
 
 
 # Configure logging for evaluation results
@@ -186,7 +186,7 @@ def _configure_otlp_logging() -> None:
 #
 # Note: langchain-core must be installed for message reconstruction to work,
 # but LangChain instrumentation is NOT needed.
-print("✓ Message reconstruction enabled in translator (no LangChain instrumentation needed)")
+print("[INIT] Message reconstruction enabled in translator (LangChain instrumentation not required)")
 
 # ---------------------------------------------------------------------------
 # Sample data utilities
@@ -602,7 +602,7 @@ def main() -> None:
 
 def flush_telemetry():
     """Flush all OpenTelemetry providers before exit."""
-    print("\n🔄 Flushing telemetry data...", flush=True)
+    print("\n[FLUSH] Starting telemetry flush", flush=True)
 
     # CRITICAL: Wait for all evaluations to complete before flushing
     # Evaluations run asynchronously in a background thread
@@ -613,54 +613,54 @@ def flush_telemetry():
         if handler:
             handler.wait_for_evaluations(200.0)
     except Exception as e:
-        print(f"  ⚠️  Could not wait for evaluations: {e}", flush=True)
+        print(f"[FLUSH] Warning: Could not wait for evaluations: {e}", flush=True)
 
     # Flush traces (Traceloop SDK uses OTel TracerProvider under the hood)
     try:
         from opentelemetry import trace
         tracer_provider = trace.get_tracer_provider()
         if hasattr(tracer_provider, "force_flush"):
-            print("  → Flushing traces (traceloop.* and gen_ai.* spans)...", flush=True)
-            tracer_provider.force_flush(timeout_millis=30000)  # 30 seconds
+            print("[FLUSH] Flushing traces (timeout=30s)", flush=True)
+            tracer_provider.force_flush(timeout_millis=30000)
     except Exception as e:
-        print(f"  ⚠️  Could not flush traces: {e}", flush=True)
+        print(f"[FLUSH] Warning: Could not flush traces: {e}", flush=True)
 
     # Flush logs (if any emitters are using logs)
     try:
         from opentelemetry._logs import get_logger_provider
         logger_provider = get_logger_provider()
         if hasattr(logger_provider, "force_flush"):
-            print("  → Flushing logs...", flush=True)
-            logger_provider.force_flush(timeout_millis=30000)  # 30 seconds
+            print("[FLUSH] Flushing logs (timeout=30s)", flush=True)
+            logger_provider.force_flush(timeout_millis=30000)
     except Exception as e:
-        print(f"  ⚠️  Could not flush logs: {e}", flush=True)
+        print(f"[FLUSH] Warning: Could not flush logs: {e}", flush=True)
 
     # Flush metrics
     try:
         from opentelemetry.metrics import get_meter_provider
         meter_provider = get_meter_provider()
         if hasattr(meter_provider, "force_flush"):
-            print("  → Flushing metrics...", flush=True)
-            meter_provider.force_flush(timeout_millis=30000)  # 30 seconds
+            print("[FLUSH] Flushing metrics (timeout=30s)", flush=True)
+            meter_provider.force_flush(timeout_millis=30000)
     except Exception as e:
-        print(f"  ⚠️  Could not flush metrics: {e}", flush=True)
+        print(f"[FLUSH] Warning: Could not flush metrics: {e}", flush=True)
 
     # Give batch processors time to complete final export operations
-    print("  → Waiting for final batch export...", flush=True)
+    print("[FLUSH] Waiting for final batch export (5s)", flush=True)
     time.sleep(5)
 
-    print("✅ Telemetry flush complete!\n", flush=True)
+    print("[FLUSH] Telemetry flush complete\n", flush=True)
 
 
 if __name__ == "__main__":
     exit_code = 0
     try:
         main()
-        print("\n✓ Workflow completed successfully!")
-        print("✓ Traces exported with traceloop.* attributes")
-        print("✓ Zero-code translator converted to gen_ai.* attributes")
+        print("\n[SUCCESS] Workflow completed")
+        print("[SUCCESS] Traces exported with traceloop.* attributes")
+        print("[SUCCESS] Zero-code translator converted to gen_ai.* attributes")
     except Exception as e:
-        print(f"\n✗ ERROR: Workflow failed: {e}", file=sys.stderr)
+        print(f"\n[ERROR] Workflow failed: {e}", file=sys.stderr)
         import traceback
         traceback.print_exc()
         exit_code = 1

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

@@ -74,7 +74,7 @@ def matches(
                         return False
             except re.error:
                 # Bad regex – treat as non-match but log once
-                logging.warning("Invalid regex in match_scope: %s", pattern)
+                logging.warning("[TL_PROCESSOR] Invalid regex in match_scope: %s", pattern)
                 return False
         if self.match_attributes:
             for k, expected in self.match_attributes.items():
@@ -95,7 +95,7 @@ def _load_rules_from_env() -> List[TransformationRule]:
         data = json.loads(raw)
         rules_spec = data.get("rules") if isinstance(data, dict) else None
         if not isinstance(rules_spec, list):
-            logging.warning("%s must contain a 'rules' list", _ENV_RULES)
+            logging.warning("[TL_PROCESSOR] %s must contain a 'rules' list", _ENV_RULES)
             return []
         rules: List[TransformationRule] = []
         for r in rules_spec:
@@ -121,7 +121,7 @@ def _load_rules_from_env() -> List[TransformationRule]:
             )
         return rules
     except Exception as exc:  # broad: we never want to break app startup
-        logging.warning("Failed to parse %s: %s", _ENV_RULES, exc)
+        logging.warning("[TL_PROCESSOR] Failed to parse %s: %s", _ENV_RULES, exc)
         return []
 
 
@@ -258,10 +258,10 @@ def _process_span_translation(self, span: ReadableSpan) -> Optional[Any]:
 
         # Check if this span should be transformed
         if not self.span_filter(span):
-            logger.debug("Span %s filtered out by span_filter", span.name)
+            logger.debug("[TL_PROCESSOR] Span filtered: name=%s", span.name)
             return None
 
-        logger.debug("Processing span for transformation: %s (kind=%s)",
+        logger.debug("[TL_PROCESSOR] Translating span: name=%s, kind=%s",
                      span.name,
                      span.attributes.get("traceloop.span.kind") if span.attributes else None)
 
@@ -280,7 +280,7 @@ def _process_span_translation(self, span: ReadableSpan) -> Optional[Any]:
                     applied_rule = rule
                     break
             except Exception as match_err:  # pragma: no cover - defensive
-                logging.warning("Rule match error ignored: %s", match_err)
+                logging.warning("[TL_PROCESSOR] Rule match error: %s", match_err)
 
         sentinel = {"_traceloop_processed": True}
         # Decide which transformation config to apply
@@ -375,7 +375,7 @@ def on_end(self, span: ReadableSpan) -> None:
             # STEP 2: Check if this is an LLM span that needs evaluation
             if self._is_llm_span(span):
                 _logger.debug(
-                    "🔍 TRACELOOP PROCESSOR: LLM span '%s' detected! Processing immediately for evaluations",
+                    "[TL_PROCESSOR] LLM span detected: %s, processing for evaluations",
                     span.name
                 )
                 # Process LLM spans IMMEDIATELY - create synthetic span and trigger evaluations
@@ -386,16 +386,17 @@ def on_end(self, span: ReadableSpan) -> None:
                     try:
                         handler.stop_llm(invocation)
                         _logger.debug(
-                            "🔍 TRACELOOP PROCESSOR: LLM invocation completed, evaluations should trigger"
+                            "[TL_PROCESSOR] LLM invocation completed: %s",
+                            span.name
                         )
                     except Exception as stop_err:
                         _logger.warning(
-                            "Failed to stop LLM invocation: %s", stop_err
+                            "[TL_PROCESSOR] Failed to stop LLM invocation: %s", stop_err
                         )
             else:
                 # Non-LLM spans (tasks, workflows, tools) - buffer for optional batch processing
                 _logger.debug(
-                    "🔍 TRACELOOP PROCESSOR: Non-LLM span '%s', buffering (%d in buffer)",
+                    "[TL_PROCESSOR] Non-LLM span buffered: %s (buffer_size=%d)",
                     span.name,
                     len(self._span_buffer) + 1
                 )
@@ -404,7 +405,8 @@ def on_end(self, span: ReadableSpan) -> None:
                 # Process buffer when root span arrives (optional, for synthetic spans of workflows)
                 if span.parent is None and not self._processing_buffer:
                     _logger.debug(
-                        "🔍 TRACELOOP PROCESSOR: ROOT SPAN detected, processing buffered non-LLM spans"
+                        "[TL_PROCESSOR] Root span detected, processing buffered spans (count=%d)",
+                        len(self._span_buffer)
                     )
                     self._processing_buffer = True
                     try:
@@ -437,7 +439,7 @@ def on_end(self, span: ReadableSpan) -> None:
         except Exception as e:
             # Don't let transformation errors break the original span processing
             logging.warning(
-                f"TraceloopSpanProcessor failed to transform span: {e}"
+                "[TL_PROCESSOR] Span transformation failed: %s", e
             )
 
     def _sort_spans_by_hierarchy(
@@ -519,16 +521,15 @@ def _is_llm_span(self, span: ReadableSpan) -> bool:
         )
 
         if has_input_messages or has_output_messages:
-            # This is a task/agent span with message data - PERFECT for evaluations!
             _logger.debug(
-                "Span '%s' (kind=%s) has message data (input=%s, output=%s) - WILL EVALUATE",
-                span.name, span_kind, has_input_messages, has_output_messages
+                "[TL_PROCESSOR] Span evaluable (has_messages): name=%s, kind=%s",
+                span.name, span_kind
             )
             return True
 
         # PRIORITY 2: Check for explicit LLM span kind (even without messages, for compatibility)
         if span_kind == "llm":
-            _logger.debug("Span '%s' has span_kind='llm' - WILL EVALUATE", span.name)
+            _logger.debug("[TL_PROCESSOR] Span evaluable (kind=llm): name=%s", span.name)
             return True
 
         # PRIORITY 3: Detect ReAct agent/task spans by kind
@@ -539,7 +540,7 @@ def _is_llm_span(self, span: ReadableSpan) -> bool:
             exclude_keywords = ["should_continue", "model_to_tools", "tools_to_model", "__start__", "__end__"]
             if not any(ex in span_name_lower for ex in exclude_keywords):
                 _logger.debug(
-                    "Span '%s' (kind=%s) is agent/task/workflow - WILL EVALUATE", 
+                    "[TL_PROCESSOR] Span evaluable (agent/task/workflow): name=%s, kind=%s", 
                     span.name, span_kind
                 )
                 return True
@@ -550,25 +551,24 @@ def _is_llm_span(self, span: ReadableSpan) -> bool:
             "gen_ai.request.model",
             "ai.model.name"
         ]):
-            _logger.debug("Span '%s' has model attribute - WILL EVALUATE", span.name)
+            _logger.debug("[TL_PROCESSOR] Span evaluable (has_model_attr): name=%s", span.name)
             return True
 
         # PRIORITY 5: Name-based detection for agent/specialist patterns
         # Match patterns like: flight_specialist, hotel_specialist, coordinator_agent, etc.
         agent_patterns = ["_specialist", "_agent", "coordinator", "synthesizer"]
         if any(pattern in span_name_lower for pattern in agent_patterns):
-            _logger.debug("Span '%s' matches agent pattern - WILL EVALUATE", span.name)
+            _logger.debug("[TL_PROCESSOR] Span evaluable (agent_pattern): name=%s", span.name)
             return True
 
         # PRIORITY 6: Name-based detection for LLM providers (ChatOpenAI.chat, etc.)
         llm_indicators = ["chatopenai", "chatgoogleai", "chatanthropic", "chatvertexai", "openai.chat", "completion",
                           "gpt-", "claude-", "gemini-", "llama-"]
         for indicator in llm_indicators:
             if indicator in span_name_lower:
-                _logger.debug("Span '%s' matches LLM indicator '%s' - WILL EVALUATE", span.name, indicator)
+                _logger.debug("[TL_PROCESSOR] Span evaluable (llm_indicator=%s): name=%s", indicator, span.name)
                 return True
 
-        _logger.debug("Span '%s' is NOT an evaluation span (no indicators found)", span.name)
         return False
 
     def _mutate_span_if_needed(self, span: ReadableSpan) -> None:
@@ -592,7 +592,7 @@ def _mutate_span_if_needed(self, span: ReadableSpan) -> None:
                     applied_rule = rule
                     break
             except Exception as match_err:  # pragma: no cover - defensive
-                logging.warning("Rule match error ignored: %s", match_err)
+                logging.warning("[TL_PROCESSOR] Rule match error: %s", match_err)
 
         # Decide which transformation config to apply
         if applied_rule is not None: