feat(cli): detect repeated production log errors

Author: GaspardKirira

include/vix/cli/commands/logs/LogsAnalyzer.hpp

@@ -0,0 +1,85 @@
+/**
+ *
+ *  @file LogsAnalyzer.hpp
+ *  @author Gaspard Kirira
+ *
+ *  Copyright 2026, Gaspard Kirira.  All rights reserved.
+ *  https://github.com/vixcpp/vix
+ *  Use of this source code is governed by a MIT license
+ *  that can be found in the License file.
+ *
+ *  Vix.cpp
+ */
+#ifndef VIX_LOGS_ANALYZER_HPP
+#define VIX_LOGS_ANALYZER_HPP
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+
+namespace vix::commands::logs::analyzer
+{
+  /**
+   * @struct RepeatedLogEntry
+   * @brief Represents one normalized log message that appears multiple times.
+   */
+  struct RepeatedLogEntry
+  {
+    /**
+     * @brief Normalized log message.
+     */
+    std::string message{};
+
+    /**
+     * @brief Number of times the normalized message appears.
+     */
+    int count{0};
+  };
+
+  /**
+   * @struct RepeatedLogReport
+   * @brief Summary produced by repeated log analysis.
+   */
+  struct RepeatedLogReport
+  {
+    /**
+     * @brief Repeated log entries sorted by descending count.
+     */
+    std::vector<RepeatedLogEntry> entries{};
+
+    /**
+     * @brief Total number of log lines analyzed.
+     */
+    int totalLines{0};
+
+    /**
+     * @brief Number of repeated message groups detected.
+     */
+    int repeatedGroups{0};
+  };
+
+  /**
+   * @brief Analyze log lines and detect repeated normalized error messages.
+   *
+   * This function normalizes variable parts of log lines, such as timestamps,
+   * IP addresses, numbers, and long values, then groups equivalent messages
+   * together.
+   *
+   * @param lines Raw log lines to analyze.
+   * @return Report containing repeated error groups and counters.
+   */
+  RepeatedLogReport analyze_repeated_errors(
+      const std::vector<std::string> &lines);
+
+  /**
+   * @brief Print a repeated error analysis report.
+   *
+   * @param out Output stream.
+   * @param report Repeated error report to print.
+   */
+  void print_repeated_report(
+      std::ostream &out,
+      const RepeatedLogReport &report);
+}
+
+#endif

include/vix/cli/commands/logs/LogsTypes.hpp

@@ -51,6 +51,11 @@ namespace vix::commands::logs
      */
     bool errorsOnly{false};
 
+    /**
+     * @brief Show repeated error summary.
+     */
+    bool repeated{false};
+
     /**
      * @brief Number of lines to show.
      */

src/commands/LogsCommand.cpp

@@ -149,6 +149,8 @@ namespace vix::commands
       options.errorsOnly = options.errorsOnly ||
                            consume_flag(args, "--errors");
 
+      options.repeated = consume_flag(args, "--repeated");
+
       if (!consume_value(args, "--since", options.since))
       {
         ok = false;
@@ -239,6 +241,7 @@ namespace vix::commands
         << "  --follow    Follow logs live\n"
         << "  -f          Alias for --follow\n"
         << "  --errors    Filter logs by common error keywords\n"
+        << "  --repeated  Detect repeated errors\n"
         << "  --since     Filter app logs by systemd time expression\n"
         << "  --lines     Show last N lines\n"
         << "  -n          Alias for --lines\n"
@@ -250,6 +253,7 @@ namespace vix::commands
         << "  vix logs errors\n"
         << "  vix logs --follow\n"
         << "  vix logs --errors\n"
+        << "  vix logs errors --repeated\n"
         << "  vix logs --since \"1 hour ago\"\n"
         << "  vix logs -n 200\n\n"
         << "Config:\n"

src/commands/logs/LogsAnalyzer.cpp

@@ -0,0 +1,175 @@
+/**
+ *
+ *  @file LogsAnalyzer.cpp
+ *  @author Gaspard Kirira
+ *
+ *  Copyright 2026, Gaspard Kirira.  All rights reserved.
+ *  https://github.com/vixcpp/vix
+ *  Use of this source code is governed by a MIT license
+ *  that can be found in the License file.
+ *
+ *  Vix.cpp
+ */
+#include <vix/cli/commands/logs/LogsAnalyzer.hpp>
+#include <vix/cli/util/Ui.hpp>
+
+#include <algorithm>
+#include <cctype>
+#include <ostream>
+#include <regex>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace vix::commands::logs::analyzer
+{
+  namespace
+  {
+    std::string trim_copy(std::string value)
+    {
+      auto not_space = [](unsigned char ch)
+      {
+        return !std::isspace(ch);
+      };
+
+      value.erase(
+          value.begin(),
+          std::find_if(value.begin(), value.end(), not_space));
+
+      value.erase(
+          std::find_if(value.rbegin(), value.rend(), not_space).base(),
+          value.end());
+
+      return value;
+    }
+
+    std::string to_lower_copy(std::string value)
+    {
+      std::transform(
+          value.begin(),
+          value.end(),
+          value.begin(),
+          [](unsigned char ch)
+          {
+            return static_cast<char>(std::tolower(ch));
+          });
+
+      return value;
+    }
+
+    std::string normalize_log_line(std::string line)
+    {
+      line = trim_copy(line);
+
+      line = std::regex_replace(
+          line,
+          std::regex(R"(\b[0-9]{4}-[0-9]{2}-[0-9]{2}[^\s]*\b)"),
+          "<timestamp>");
+
+      line = std::regex_replace(
+          line,
+          std::regex(R"(\b[0-9]{1,3}(\.[0-9]{1,3}){3}\b)"),
+          "<ip>");
+
+      line = std::regex_replace(
+          line,
+          std::regex(R"(\b[0-9]+\b)"),
+          "<num>");
+
+      line = std::regex_replace(
+          line,
+          std::regex("\"([^\"]{32,})\""),
+          "\"<value>\"");
+
+      line = std::regex_replace(
+          line,
+          std::regex(R"('([^']{32,})')"),
+          "'<value>'");
+
+      line = to_lower_copy(line);
+      line = trim_copy(line);
+
+      return line;
+    }
+  }
+
+  RepeatedLogReport analyze_repeated_errors(
+      const std::vector<std::string> &lines)
+  {
+    RepeatedLogReport report;
+    report.totalLines = static_cast<int>(lines.size());
+
+    std::unordered_map<std::string, int> counts;
+
+    for (const std::string &line : lines)
+    {
+      const std::string normalized = normalize_log_line(line);
+
+      if (normalized.empty())
+        continue;
+
+      ++counts[normalized];
+    }
+
+    for (const auto &[message, count] : counts)
+    {
+      if (count <= 1)
+        continue;
+
+      report.entries.push_back(
+          RepeatedLogEntry{
+              message,
+              count});
+    }
+
+    std::sort(
+        report.entries.begin(),
+        report.entries.end(),
+        [](const RepeatedLogEntry &a, const RepeatedLogEntry &b)
+        {
+          if (a.count != b.count)
+            return a.count > b.count;
+
+          return a.message < b.message;
+        });
+
+    report.repeatedGroups =
+        static_cast<int>(report.entries.size());
+
+    return report;
+  }
+
+  void print_repeated_report(
+      std::ostream &out,
+      const RepeatedLogReport &report)
+  {
+    vix::cli::util::section(out, "Repeated Errors");
+
+    vix::cli::util::kv(
+        out,
+        "Analyzed lines",
+        std::to_string(report.totalLines));
+
+    vix::cli::util::kv(
+        out,
+        "Repeated groups",
+        std::to_string(report.repeatedGroups));
+
+    if (report.entries.empty())
+    {
+      vix::cli::util::ok_line(
+          out,
+          "no repeated errors detected");
+
+      return;
+    }
+
+    for (const RepeatedLogEntry &entry : report.entries)
+    {
+      vix::cli::util::kv(
+          out,
+          std::to_string(entry.count) + "x",
+          entry.message);
+    }
+  }
+}