add opentelemetery

Author: Lekssays

README.md

@@ -263,6 +263,12 @@ MAX_REPO_SIZE_MB=500
 QUERY_TIMEOUT=30
 QUERY_CACHE_ENABLED=true
 QUERY_CACHE_TTL=300
+
+# Telemetry (OpenTelemetry)
+OTEL_ENABLED=false
+OTEL_SERVICE_NAME=codebadger
+OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317
+OTEL_EXPORTER_OTLP_PROTOCOL=grpc
 ```
 
 ### Config File
@@ -275,6 +281,71 @@ cp config.example.yaml config.yaml
 
 Then customize as needed.
 
+## Telemetry (OpenTelemetry)
+
+CodeBadger has built-in OpenTelemetry support for distributed tracing. When enabled, all MCP tool calls are automatically traced, plus custom spans for CPG generation, Joern server management, and query execution.
+
+### Quick Start
+
+1. Install the telemetry dependencies (included in `requirements.txt`):
+
+```bash
+pip install opentelemetry-sdk opentelemetry-exporter-otlp
+```
+
+2. Enable via environment variables:
+
+```bash
+export OTEL_ENABLED=true
+export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317
+python main.py
+```
+
+Or via `config.yaml`:
+
+```yaml
+telemetry:
+  enabled: true
+  service_name: codebadger
+  otlp_endpoint: http://localhost:4317
+  otlp_protocol: grpc  # or "http/protobuf"
+```
+
+### Local Development with Jaeger
+
+```bash
+# Start Jaeger (provides UI at http://localhost:16686)
+docker run -d --name jaeger \
+  -p 16686:16686 \
+  -p 4317:4317 \
+  jaegertracing/all-in-one:latest
+
+# Start CodeBadger with telemetry
+OTEL_ENABLED=true python main.py
+```
+
+### What Gets Traced
+
+| Span | Description |
+|------|-------------|
+| `tools/call {name}` | Every MCP tool invocation (automatic via FastMCP) |
+| `cpg.generate` | Full CPG generation pipeline |
+| `cpg.joern_cli_exec` | Joern CLI command execution inside Docker |
+| `cpg.spawn_server` | Joern server instance creation |
+| `cpg.load_cpg` | CPG file loading into Joern server |
+| `query.execute` | CPGQL query execution with timing and success attributes |
+
+### Configuration Reference
+
+| Setting | Env Variable | Default | Description |
+|---------|-------------|---------|-------------|
+| `enabled` | `OTEL_ENABLED` | `false` | Enable/disable telemetry |
+| `service_name` | `OTEL_SERVICE_NAME` | `codebadger` | Service name in traces |
+| `otlp_endpoint` | `OTEL_EXPORTER_OTLP_ENDPOINT` | `http://localhost:4317` | OTLP collector endpoint |
+| `otlp_protocol` | `OTEL_EXPORTER_OTLP_PROTOCOL` | `grpc` | Export protocol (`grpc` or `http/protobuf`) |
+
+When telemetry is disabled (default), all tracing is no-op with zero overhead.
+
 
 
 

config.example.yaml

@@ -954,3 +954,8 @@ storage:
   workspace_root: ${WORKSPACE_ROOT:/tmp/codebadger}
   cleanup_on_shutdown: ${CLEANUP_ON_SHUTDOWN:true}
 
+telemetry:
+  enabled: ${OTEL_ENABLED:false}
+  service_name: ${OTEL_SERVICE_NAME:codebadger}
+  otlp_endpoint: ${OTEL_EXPORTER_OTLP_ENDPOINT:http://localhost:4317}
+  otlp_protocol: ${OTEL_EXPORTER_OTLP_PROTOCOL:grpc}

main.py

@@ -36,6 +36,42 @@
 logger = logging.getLogger(__name__)
 
 
+def _setup_telemetry(config) -> None:
+    """Configure OpenTelemetry SDK if telemetry is enabled.
+
+    Must be called before FastMCP tools are invoked so the tracer provider
+    is in place when FastMCP's built-in instrumentation fires.
+    """
+    telemetry = config.telemetry
+    if not telemetry.enabled:
+        logger.debug("Telemetry disabled, skipping OpenTelemetry setup")
+        return
+
+    try:
+        from opentelemetry import trace
+        from opentelemetry.sdk.trace import TracerProvider
+        from opentelemetry.sdk.trace.export import BatchSpanProcessor
+        from opentelemetry.sdk.resources import Resource
+
+        resource = Resource.create({"service.name": telemetry.service_name})
+        provider = TracerProvider(resource=resource)
+
+        if telemetry.otlp_protocol == "grpc":
+            from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
+        else:
+            from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+
+        exporter = OTLPSpanExporter(endpoint=telemetry.otlp_endpoint)
+        provider.add_span_processor(BatchSpanProcessor(exporter))
+        trace.set_tracer_provider(provider)
+
+        logger.info(f"OpenTelemetry enabled: exporting to {telemetry.otlp_endpoint} via {telemetry.otlp_protocol}")
+    except ImportError:
+        logger.warning("OpenTelemetry packages not installed. Install with: pip install opentelemetry-sdk opentelemetry-exporter-otlp")
+    except Exception as e:
+        logger.warning(f"Failed to initialize OpenTelemetry: {e}")
+
+
 async def _graceful_shutdown():
     """Gracefully shutdown all services"""
     logger.info("Performing graceful shutdown...")
@@ -76,6 +112,9 @@ async def app_lifespan(server: FastMCP):
     setup_logging(config.server.log_level)
     logger.info("Starting CodeBadger Server")
 
+    # Setup OpenTelemetry (must happen before tool invocations)
+    _setup_telemetry(config)
+
     # Ensure required directories exist
     os.makedirs(config.storage.workspace_root, exist_ok=True)
 

requirements.txt

@@ -10,6 +10,11 @@ docker==7.1.0
 gitpython==3.1.46
 PyYAML==6.0.3
 
+# Telemetry (optional - OpenTelemetry)
+opentelemetry-api>=1.33.0
+opentelemetry-sdk>=1.33.0
+opentelemetry-exporter-otlp>=1.33.0
+
 # Development dependencies
 pytest==8.4.2
 pytest-asyncio==1.2.0

src/config.py

@@ -13,6 +13,7 @@
     QueryConfig,
     ServerConfig,
     StorageConfig,
+    TelemetryConfig,
 )
 
 
@@ -72,6 +73,12 @@ def load_config(config_path: Optional[str] = None) -> Config:
                 cleanup_on_shutdown=os.getenv("CLEANUP_ON_SHUTDOWN", str(defaults.CLEANUP_ON_SHUTDOWN)).lower()
                 == "true",
             ),
+            telemetry=TelemetryConfig(
+                enabled=os.getenv("OTEL_ENABLED", "false").lower() == "true",
+                service_name=os.getenv("OTEL_SERVICE_NAME", "codebadger"),
+                otlp_endpoint=os.getenv("OTEL_EXPORTER_OTLP_ENDPOINT", "http://localhost:4317"),
+                otlp_protocol=os.getenv("OTEL_EXPORTER_OTLP_PROTOCOL", "grpc"),
+            ),
         )
 
 
@@ -158,4 +165,5 @@ def convert_config_section(config_class, values):
         cpg=convert_config_section(CPGConfig, cpg_data),
         query=convert_config_section(QueryConfig, data.get("query", {})),
         storage=convert_config_section(StorageConfig, data.get("storage", {})),
+        telemetry=convert_config_section(TelemetryConfig, data.get("telemetry", {})),
     )

src/models.py

@@ -163,6 +163,16 @@ class StorageConfig:
     cleanup_on_shutdown: bool = True
 
 
+@dataclass
+class TelemetryConfig:
+    """OpenTelemetry configuration"""
+
+    enabled: bool = False
+    service_name: str = "codebadger"
+    otlp_endpoint: str = "http://localhost:4317"
+    otlp_protocol: str = "grpc"  # "grpc" or "http/protobuf"
+
+
 @dataclass
 class Config:
     """Main configuration"""
@@ -172,6 +182,7 @@ class Config:
     cpg: CPGConfig = field(default_factory=CPGConfig)
     query: QueryConfig = field(default_factory=QueryConfig)
     storage: StorageConfig = field(default_factory=StorageConfig)
+    telemetry: TelemetryConfig = field(default_factory=TelemetryConfig)
 
 
 @dataclass