fix(rotel-visual): resolve compilation errors — unclosed delimiters, shadowed identifiers

Rewrite otlp_logs_handler which had deeply corrupted nesting (dead code
after early return, out-of-scope locals from incorrect merge resolution).
Fix main.rs missing Ok(()) return. Fix test file function/variable shadowing
where  Router collided with  — renamed to test_app.

Author: Claude Sonnet (coordinator)

crates/rotel-visual/src/lib.rs

@@ -410,63 +410,51 @@ struct OtlpIngestResponse {
 #[instrument]
 async fn otlp_logs_handler(
     State(state): State<Arc<AppState>>,
-    Json(req): Json<OtlpLogsRequest>,
+    Json(payload): Json<serde_json::Value>,
 ) -> impl IntoResponse {
-    let request: Result<otlp_json::LogsRequest, _> = serde_json::from_value(payload.clone());
-    match request {
-        Ok(req) => {
-            let mut logs = Vec::new();
-            let mut classified = Vec::new();
-            let mut log_count = 0u64;
-
-            for resource_log in &req.resource_logs {
-                for scope_log in &resource_log.scope_logs {
-                    for record in &scope_log.log_records {
-                        log_count += 1;
-                        let body = record.body.string_value.clone().unwrap_or_default();
-                        let severity = match OTelSeverityNumber::try_from(record.severity_number) {
-                            Ok(s) => s,
-                            Err(e) => {
-                                error!("Invalid severity number: {}", e);
-                                continue;
-                            }
-                        };
-                        let time_unix_nano = match record.time_unix_nano.parse() {
-                            Ok(t) => t,
-                            Err(e) => {
-                                error!("Invalid time_unix_nano '{}': {}", record.time_unix_nano, e);
-                                continue;
-                            }
-                        };
-
-                        let log = OTelLogRecord::new(
-                            time_unix_nano,
-                            severity,
-                            body.clone(),
-                        );
-                        let response = Json(serde_json::json!({
-                            "error": format!(
-                                "invalid OTLP log record timeUnixNano '{}': {}",
-                                record.time_unix_nano, error
-                            )
-                        }));
-                        return (axum::http::StatusCode::BAD_REQUEST, response)
-                            .into_response();
+    let mut logs = Vec::new();
+    let mut classified = Vec::new();
+    let mut log_count = 0u64;
+
+    let request: otlp_json::LogsRequest = match serde_json::from_value(payload) {
+        Ok(r) => r,
+        Err(e) => {
+            error!("Invalid OTLP log structure: {e}");
+            let response = Json(serde_json::json!({
+                "error": format!("invalid OTLP log structure: {e}")
+            }));
+            return (axum::http::StatusCode::BAD_REQUEST, response).into_response();
+        }
+    };
+
+    for resource_log in &request.resource_logs {
+        for scope_log in &resource_log.scope_logs {
+            for record in &scope_log.log_records {
+                log_count += 1;
+                let body = record.body.string_value.clone().unwrap_or_default();
+                let severity = match OTelSeverityNumber::try_from(record.severity_number) {
+                    Ok(s) => s,
+                    Err(e) => {
+                        error!("Invalid severity number: {}", e);
+                        continue;
+                    }
+                };
+                let time_unix_nano: u64 = match record.time_unix_nano.parse() {
+                    Ok(t) => t,
+                    Err(e) => {
+                        error!("Invalid time_unix_nano '{}': {}", record.time_unix_nano, e);
+                        continue;
                     }
                 };
 
-                        let artifacts = state.classifier.classify_log(&log);
-                        for artifact in &artifacts {
-                            classified.push(ClassifiedArtifactView::from(artifact));
-                        }
+                let mut log = OTelLogRecord::new(time_unix_nano, severity, body);
 
-                // Extract log-record-level attributes
                 for attr in &record.attributes {
                     if let Some(val) = &attr.value.string_value {
                         log.attributes.insert(attr.key.clone(), val.clone());
                     }
                 }
-                // Extract resource-level attributes (log record wins on collision)
+
                 if let Some(resource) = &resource_log.resource {
                     for attr in &resource.attributes {
                         if let Some(val) = &attr.value.string_value {
@@ -477,38 +465,24 @@ async fn otlp_logs_handler(
                     }
                 }
 
-            state.metrics.inc_logs_ingested(log_count);
-            state.metrics.inc_logs_classified(classified.len() as u64);
-
-            let telemetry = TelemetryData {
-                logs,
-                metrics: vec![],
-                spans: vec![],
-                classified,
-            };
+                let artifacts = state.classifier.classify_log(&log);
+                for artifact in &artifacts {
+                    classified.push(ClassifiedArtifactView::from(artifact));
+                }
 
-            state.broadcast(telemetry).await;
-
-            let response = Json(OtlpIngestResponse {
-                accepted: true,
-                signal: "log".to_string(),
-                resource_count: req.resource_logs.len(),
-                classification_columns: TelemetryArrowBatch::classification_columns()
-                    .iter()
-                    .map(|s| s.to_string())
-                    .collect(),
-            });
-            (axum::http::StatusCode::ACCEPTED, response).into_response()
-        }
-        Err(error) => {
-            error!("Invalid OTLP JSON payload: {}", error);
-            let response = Json(serde_json::json!({
-                "error": format!("invalid OTLP JSON payload: {error}")
-            }));
-            (axum::http::StatusCode::BAD_REQUEST, response).into_response()
+                logs.push(LogRecord {
+                    timestamp: time_unix_nano.to_string(),
+                    level: format!("{:?}", severity),
+                    message: log.body.clone(),
+                    shape: "otlp_log".to_string(),
+                });
+            }
         }
     }
 
+    state.metrics.inc_logs_ingested(log_count);
+    state.metrics.inc_logs_classified(classified.len() as u64);
+
     let telemetry = TelemetryData {
         logs,
         metrics: vec![],
@@ -521,7 +495,7 @@ async fn otlp_logs_handler(
     let response = Json(OtlpIngestResponse {
         accepted: true,
         signal: "log".to_string(),
-        resource_count: req.resource_logs.len(),
+        resource_count: request.resource_logs.len(),
         classification_columns: TelemetryArrowBatch::classification_columns()
             .iter()
             .map(|s| s.to_string())

crates/rotel-visual/src/main.rs

@@ -4,8 +4,11 @@ async fn main() -> Result<(), anyhow::Error> {
         .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
         .init();
 
-    if let Err(err) = rotel_visual::run_server().await {
-        eprintln!("Fatal: {err}");
-        std::process::exit(1);
+    match rotel_visual::run_server().await {
+        Ok(()) => Ok(()),
+        Err(err) => {
+            eprintln!("Fatal: {err}");
+            std::process::exit(1);
+        }
     }
 }

crates/rotel-visual/tests/health_dashboard_tests.rs

@@ -3,7 +3,7 @@ use axum::http::{Request, StatusCode};
 use serde_json::json;
 use tower::ServiceExt;
 
-fn app() -> axum::Router {
+fn test_app() -> axum::Router {
     rotel_visual::create_app().unwrap()
 }
 
@@ -61,7 +61,7 @@ async fn test_otlp_logs_ingestion_accepts_json_and_returns_202() {
         ]
     });
 
-    let response = app()
+    let response = test_app()
         .oneshot(
             Request::builder()
                 .uri("/v1/logs")
@@ -89,7 +89,7 @@ async fn test_otlp_metrics_ingestion_accepts_json_and_returns_202() {
         ]
     });
 
-    let response = app()
+    let response = test_app()
         .oneshot(
             Request::builder()
                 .uri("/v1/metrics")
@@ -117,7 +117,7 @@ async fn test_otlp_traces_ingestion_accepts_json_and_returns_202() {
         ]
     });
 
-    let response = app()
+    let response = test_app()
         .oneshot(
             Request::builder()
                 .uri("/v1/traces")
@@ -156,8 +156,8 @@ async fn test_classified_artifacts_are_accepted_via_otlp_logs() {
     // This test verifies that an OTLP log payload matching a classification
     // rule is accepted by the ingestion endpoint.
 
-    // Ingest a log that matches the GPU fault rule
     // Ingest a log that matches the GPU fault rule.
+    let body = serde_json::json!({
         "resourceLogs": [
             {
                 "resource": {
@@ -182,7 +182,7 @@ async fn test_classified_artifacts_are_accepted_via_otlp_logs() {
         ]
     });
 
-    let response = app()
+    let response = test_app()
         .clone()
         .oneshot(
             Request::builder()
@@ -226,7 +226,7 @@ async fn test_ring_buffer_populated_after_otlp_log_ingest() {
         ]
     });
 
-    let response = app()
+    let response = test_app()
         .clone()
         .oneshot(
             Request::builder()
@@ -244,7 +244,7 @@ async fn test_ring_buffer_populated_after_otlp_log_ingest() {
 
 #[tokio::test]
 async fn test_metrics_endpoint_returns_self_telemetry() {
-    let response = app()
+    let response = test_app()
         .oneshot(
             Request::builder()
                 .uri("/metrics")
@@ -265,7 +265,7 @@ async fn test_metrics_endpoint_returns_self_telemetry() {
 
 #[tokio::test]
 async fn test_metrics_endpoint_increments_after_ingestion() {
-    let app = app();
+    let app = test_app();
 
     // Get baseline
     let baseline = app
@@ -336,7 +336,7 @@ async fn test_rotel_evaluate_endpoint_returns_sarif() {
         "slo_expected": true
     });
 
-    let response = app()
+    let response = test_app()
         .oneshot(
             Request::builder()
                 .uri("/rotel/evaluate")
@@ -366,7 +366,7 @@ async fn test_rotel_evaluate_detects_slo_failure() {
         "slo_expected": true
     });
 
-    let response = app()
+    let response = test_app()
         .oneshot(
             Request::builder()
                 .uri("/rotel/evaluate")