disable tracing

src/app.py

@@ -139,11 +139,13 @@ def register_middleware(app):
     @app.before_request
     def before_request():
         """Start request timer and generate request ID, create tracing span."""
+        from .utils.tracing import is_tracing_enabled
+        
         g.start_time = time.time()
         g.request_id = request.headers.get("X-Request-ID", os.urandom(8).hex())
         
-        # Skip tracing for health endpoint
-        if request.path == "/health":
+        # Skip tracing if disabled or for health endpoint
+        if not is_tracing_enabled() or request.path == "/health":
             return
         
         # Extract parent span context from headers if present

src/routes/contacts.py

@@ -38,15 +38,24 @@ def list_contacts():
         - search: Filter contacts by name (case-insensitive)
         - sort: Sort order (recent, alphabetical, oldest)
     """
+    from ..utils.tracing import is_tracing_enabled
+    
     tracer = trace.get_tracer(__name__)
     user_id = session.get("user_id")
     search_query = request.args.get("search", "").strip()
     sort_order = request.args.get("sort", "recent")
     
-    with tracer.start_as_current_span("list_contacts") as span:
+    # Only create span if tracing is enabled
+    tracing_enabled = is_tracing_enabled()
+    if tracing_enabled:
+        span = tracer.start_span("list_contacts")
         span.set_attribute("user_id", user_id)
         span.set_attribute("search_query", search_query)
         span.set_attribute("sort_order", sort_order)
+    else:
+        span = None
+    
+    try:
         
         try:
             # Get all contacts for user
@@ -68,8 +77,9 @@ def list_contacts():
                 contacts = sorted(contacts, key=lambda c: c.created_at)
             # Default "recent" is already sorted by last_interaction DESC
             
-            span.set_attribute("contact_count", len(contacts))
-            span.set_attribute("filtered", bool(search_query))
+            if span:
+                span.set_attribute("contact_count", len(contacts))
+                span.set_attribute("filtered", bool(search_query))
             
             return render_template(
                 "contacts/list.html",
@@ -80,11 +90,15 @@ def list_contacts():
             )
             
         except Exception as e:
-            span.set_attribute("error", True)
-            span.add_event("error", {"message": str(e)})
+            if span:
+                span.set_attribute("error", True)
+                span.add_event("error", {"message": str(e)})
             logger.error(f"Error loading contacts for user {user_id}: {e}")
             flash("Error loading contacts. Please try again.", "danger")
             return render_template("contacts/list.html", contacts=[], contact_count=0)
+    finally:
+        if span:
+            span.end()
 
 
 @contacts_bp.route("/", methods=["POST"])

src/services/backend_client.py

@@ -38,9 +38,11 @@ class BackendAPIClient:
         if self.bearer_token:
             headers["Authorization"] = f"Bearer {self.bearer_token}"
         
-        # Inject trace context into headers automatically
+        # Inject trace context into headers automatically (only if tracing enabled)
         try:
-            TraceContextTextMapPropagator().inject(headers)
+            from ..utils.tracing import is_tracing_enabled
+            if is_tracing_enabled():
+                TraceContextTextMapPropagator().inject(headers)
         except Exception:
             # Don't fail request if tracing injection fails
             pass

src/services/storage_service.py

@@ -399,11 +399,19 @@ def list_contact_sessions(
         List of ContactSession objects
     """
     from opentelemetry import trace
+    from ..utils.tracing import is_tracing_enabled
+    
     tracer = trace.get_tracer(__name__)
     
-    with tracer.start_as_current_span("storage.list_contact_sessions") as span:
+    # Only create span if tracing is enabled
+    if is_tracing_enabled():
+        span = tracer.start_span("storage.list_contact_sessions")
         span.set_attribute("user_id", user_id)
         span.set_attribute("sort_by", sort_by)
+    else:
+        span = None
+    
+    try:
         
         conn = get_db_connection()
         cursor = conn.cursor()
@@ -437,8 +445,12 @@ def list_contact_sessions(
             for row in rows
         ]
         
-        span.set_attribute("result_count", len(contacts))
+        if span:
+            span.set_attribute("result_count", len(contacts))
         return contacts
+    finally:
+        if span:
+            span.end()
 
 
 def get_contact_session(session_id: str) -> Optional[ContactSession]:

src/utils/tracing.py

@@ -18,6 +18,16 @@ from opentelemetry.instrumentation.requests import RequestsInstrumentor
 logger = logging.getLogger(__name__)
 
 
+def is_tracing_enabled() -> bool:
+    """
+    Check if tracing is enabled via ENABLE_TRACING environment variable.
+    
+    Returns:
+        True if tracing is enabled (default), False otherwise
+    """
+    return os.getenv("ENABLE_TRACING", "true").lower() in ("true", "1", "yes")
+
+
 def init_tracer(service_name: str) -> trace.Tracer:
     """
     Initialize OpenTelemetry tracer with OTLP HTTP exporter for Jaeger.
@@ -25,12 +35,21 @@ def init_tracer(service_name: str) -> trace.Tracer:
     Uses HTTP protocol like the Go API (instead of unreliable UDP).
     Jaeger >= 1.35 supports OTLP natively on port 4318.
     
+    Can be disabled by setting ENABLE_TRACING=false environment variable.
+    
     Args:
         service_name: Name of the service for tracing
         
     Returns:
-        Configured tracer instance
+        Configured tracer instance (or no-op tracer if disabled)
     """
+    # Check if tracing is enabled
+    if not is_tracing_enabled():
+        print(f"[TRACING] Tracing disabled via ENABLE_TRACING environment variable")
+        logger.info("OpenTelemetry tracing disabled")
+        # Return default no-op tracer
+        return trace.get_tracer(service_name)
+    
     # Jaeger OTLP HTTP endpoint (port 4318)
     otlp_endpoint = os.getenv("OTEL_EXPORTER_OTLP_ENDPOINT", "http://jaeger:4318")
     sampling_rate = float(os.getenv("JAEGER_SAMPLING_RATE", "1.0"))

test_tracing_toggle.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+"""
+Test script to verify ENABLE_TRACING toggle works correctly.
+
+Usage:
+    # Test with tracing enabled (default)
+    python test_tracing_toggle.py
+    
+    # Test with tracing disabled
+    ENABLE_TRACING=false python test_tracing_toggle.py
+"""
+import os
+import sys
+
+# Add src to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
+
+from utils.tracing import is_tracing_enabled, init_tracer
+
+
+def test_is_tracing_enabled():
+    """Test the is_tracing_enabled function with various env values."""
+    print("Testing is_tracing_enabled()...")
+    
+    test_cases = [
+        ("true", True),
+        ("True", True),
+        ("TRUE", True),
+        ("1", True),
+        ("yes", True),
+        ("YES", True),
+        ("false", False),
+        ("False", False),
+        ("FALSE", False),
+        ("0", False),
+        ("no", False),
+        ("NO", False),
+        ("", True),  # Default is enabled
+        (None, True),  # Default is enabled
+    ]
+    
+    for value, expected in test_cases:
+        # Set or unset environment variable
+        if value is None:
+            os.environ.pop("ENABLE_TRACING", None)
+        else:
+            os.environ["ENABLE_TRACING"] = value
+        
+        result = is_tracing_enabled()
+        status = "✓" if result == expected else "✗"
+        print(f"  {status} ENABLE_TRACING={value!r} → {result} (expected {expected})")
+        
+        if result != expected:
+            return False
+    
+    return True
+
+
+def test_init_tracer():
+    """Test that init_tracer respects the ENABLE_TRACING flag."""
+    print("\nTesting init_tracer()...")
+    
+    # Test with tracing disabled
+    os.environ["ENABLE_TRACING"] = "false"
+    os.environ["OTEL_EXPORTER_OTLP_ENDPOINT"] = "http://localhost:4318"
+    
+    print("  Testing with ENABLE_TRACING=false...")
+    tracer = init_tracer("test-service")
+    
+    # Should return a tracer (no-op) but not initialize OpenTelemetry
+    if tracer is None:
+        print("  ✗ init_tracer returned None (should return no-op tracer)")
+        return False
+    
+    print("  ✓ init_tracer returned tracer (no-op)")
+    
+    # Test with tracing enabled
+    os.environ["ENABLE_TRACING"] = "true"
+    print("  Testing with ENABLE_TRACING=true...")
+    
+    # Note: This will actually try to connect to Jaeger if available
+    # but won't fail if Jaeger is down
+    try:
+        tracer = init_tracer("test-service-enabled")
+        print("  ✓ init_tracer returned tracer (full initialization)")
+    except Exception as e:
+        print(f"  ⚠ init_tracer failed: {e}")
+        print("  (This is expected if Jaeger is not running)")
+    
+    return True
+
+
+def test_span_creation():
+    """Test that spans are created/skipped based on toggle."""
+    print("\nTesting span creation...")
+    
+    from opentelemetry import trace
+    
+    # Test with tracing disabled
+    os.environ["ENABLE_TRACING"] = "false"
+    
+    if is_tracing_enabled():
+        print("  ✗ is_tracing_enabled() returned True when ENABLE_TRACING=false")
+        return False
+    
+    # This should be a no-op
+    tracer = trace.get_tracer(__name__)
+    span = tracer.start_span("test-span")
+    span.end()
+    print("  ✓ No-op span created successfully when disabled")
+    
+    # Test with tracing enabled
+    os.environ["ENABLE_TRACING"] = "true"
+    
+    if not is_tracing_enabled():
+        print("  ✗ is_tracing_enabled() returned False when ENABLE_TRACING=true")
+        return False
+    
+    print("  ✓ Tracing enabled check passed")
+    
+    return True
+
+
+def main():
+    """Run all tests."""
+    print("=" * 60)
+    print("ENABLE_TRACING Toggle Test Suite")
+    print("=" * 60)
+    
+    current_value = os.environ.get("ENABLE_TRACING", "<not set>")
+    print(f"\nCurrent ENABLE_TRACING: {current_value}")
+    print()
+    
+    tests = [
+        ("is_tracing_enabled()", test_is_tracing_enabled),
+        ("init_tracer()", test_init_tracer),
+        ("span creation", test_span_creation),
+    ]
+    
+    results = []
+    for name, test_func in tests:
+        try:
+            success = test_func()
+            results.append((name, success))
+        except Exception as e:
+            print(f"\n✗ Test '{name}' raised exception: {e}")
+            results.append((name, False))
+    
+    # Print summary
+    print("\n" + "=" * 60)
+    print("Test Summary")
+    print("=" * 60)
+    
+    passed = sum(1 for _, success in results if success)
+    total = len(results)
+    
+    for name, success in results:
+        status = "✓ PASS" if success else "✗ FAIL"
+        print(f"{status}: {name}")
+    
+    print(f"\n{passed}/{total} tests passed")
+    
+    if passed == total:
+        print("\n✓ All tests passed!")
+        return 0
+    else:
+        print(f"\n✗ {total - passed} test(s) failed")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())