web UI added and refactoring done

data_acq_and_processing/preprocessing/data_preprocessor/src/data_preprocessor.cpp

@@ -141,6 +141,7 @@ void DataPreprocessor::run(const std::atomic<bool>& stop_requested) {
     std::vector<std::uint8_t> serialized_raw{};
     ipc::RawSweepCollection raw_collection{};
     std::uint64_t error_count = 0;
+    std::uint64_t consecutive_errors = 0;
     while (!stop_requested.load(std::memory_order_relaxed)) {
         try {
             if (!try_pop_raw_collection(serialized_raw, &raw_collection)) {
@@ -148,6 +149,7 @@ void DataPreprocessor::run(const std::atomic<bool>& stop_requested) {
             }
             const auto preprocessed_collection = preprocess_collection(raw_collection);
             publish_preprocessed_collection(preprocessed_collection);
+            consecutive_errors = 0;  // made progress; reset the escalation counter
         } catch (const std::exception& exc) {
             // A ring-slot-too-small failure is a permanent config error (the slot
             // cannot hold a serialized collection): swallowing it would silently
@@ -157,12 +159,22 @@ void DataPreprocessor::run(const std::atomic<bool>& stop_requested) {
             }
             // A single malformed or transiently-bad collection must not kill the
             // long-running preprocessor: drop it and keep serving the next sweep.
-            // Logging is throttled so a persistent error cannot flood the log.
-            if (error_count % 100 == 0) {
-                std::cerr << "data_preprocessor: dropped collection after error (count="
-                          << (error_count + 1) << "): " << exc.what() << '\n';
-            }
             ++error_count;
+            ++consecutive_errors;
+            // Escalate a PERSISTENT failure loudly so a deterministic config error
+            // (which drops every collection forever) is not hidden by the throttle.
+            if (consecutive_errors % 500 == 0) {
+                std::cerr << "data_preprocessor: " << consecutive_errors
+                          << " consecutive failures — likely a permanent configuration error: "
+                          << exc.what() << '\n';
+            } else if (error_count % 100 == 1) {
+                std::cerr << "data_preprocessor: dropped collection after error (count="
+                          << error_count << "): " << exc.what() << '\n';
+            }
+            // Back-off floored at 1ms (the empty-ring sleep is never reached while a
+            // persistent error keeps the ring non-empty) so the catch cannot busy-spin
+            // a CPU core even when idle_sleep_ms is configured to 0.
+            std::this_thread::sleep_for(std::chrono::milliseconds(std::max<int>(1, config_.runtime.idle_sleep_ms)));
         }
     }
 }