Formatted src/services/logging

tooling/pipeline/src/services/logging/log_dispatcher.cc

@@ -16,25 +16,25 @@
 namespace {
 [[nodiscard]] constexpr std::string_view PipelinePhaseToString(
     PipelinePhase phase) {
-  switch (phase) {
+   switch (phase) {
-    case PipelinePhase::Startup:
+      case PipelinePhase::Startup:
-      return "Startup";
+         return "Startup";
-    case PipelinePhase::Enrichment:
+      case PipelinePhase::Enrichment:
-      return "Enrichment";
+         return "Enrichment";
-    case PipelinePhase::UserGeneration:
+      case PipelinePhase::UserGeneration:
-      return "User Generation";
+         return "User Generation";
-    case PipelinePhase::BreweryAndBeerGeneration:
+      case PipelinePhase::BreweryAndBeerGeneration:
-      return "Brewery & Beer Gen";
+         return "Brewery & Beer Gen";
-    case PipelinePhase::CheckinGeneration:
+      case PipelinePhase::CheckinGeneration:
-      return "Checkin Gen";
+         return "Checkin Gen";
-    case PipelinePhase::RatingGeneration:
+      case PipelinePhase::RatingGeneration:
-      return "Rating Gen";
+         return "Rating Gen";
-    case PipelinePhase::FollowGeneration:
+      case PipelinePhase::FollowGeneration:
-      return "Follow Gen";
+         return "Follow Gen";
-    case PipelinePhase::Teardown:
+      case PipelinePhase::Teardown:
-      return "Teardown";
+         return "Teardown";
-  }
+   }
-  return "Unknown";
+   return "Unknown";
 }
 }  // namespace
 
@@ -42,35 +42,35 @@ LogDispatcher::LogDispatcher(BoundedChannel<LogEntry>& channel)
     : channel_(channel) {}
 
 void LogDispatcher::Run() {
-  auto logger = spdlog::default_logger();
+   auto logger = spdlog::default_logger();
 
-  while (true) {
+   while (true) {
-    auto entry = channel_.Receive();
+      auto entry = channel_.Receive();
-    if (!entry.has_value()) {
+      if (!entry.has_value()) {
-      // Channel is closed and drained.
+         // Channel is closed and drained.
-      break;
+         break;
-    }
+      }
 
-    const auto& log = entry.value();
+      const auto& log = entry.value();
 
-    logger->log(ToSpdlogLevel(log.level),
+      logger->log(ToSpdlogLevel(log.level),
-                "{:<20} │ thread: {:016x} │ [{}:{}] │ {}",
+                  "{:<20} │ thread: {:016x} │ [{}:{}] │ {}",
-                PipelinePhaseToString(log.phase),
+                  PipelinePhaseToString(log.phase),
-                std::hash<std::thread::id>{}(log.thread_id),
+                  std::hash<std::thread::id>{}(log.thread_id),
-                log.origin.file_name(), log.origin.line(), log.message);
+                  log.origin.file_name(), log.origin.line(), log.message);
-  }
+   }
 }
 
 spdlog::level::level_enum LogDispatcher::ToSpdlogLevel(LogLevel level) {
-  switch (level) {
+   switch (level) {
-    case LogLevel::Debug:
+      case LogLevel::Debug:
-      return spdlog::level::debug;
+         return spdlog::level::debug;
-    case LogLevel::Info:
+      case LogLevel::Info:
-      return spdlog::level::info;
+         return spdlog::level::info;
-    case LogLevel::Warn:
+      case LogLevel::Warn:
-      return spdlog::level::warn;
+         return spdlog::level::warn;
-    case LogLevel::Error:
+      case LogLevel::Error:
-      return spdlog::level::err;
+         return spdlog::level::err;
-  }
+   }
-  return spdlog::level::info;
+   return spdlog::level::info;
 }