Fase 2 voltooid: Configureerbare parser, async indexering en UI verbeteringen

- Geïmplementeerd: PatternLogParser met regex-based custom log formats
- Toegevoegd: Async indexering voor grote bestanden (10GB+ support)
- Verbeterd: Memory allocatie strategie (reserve based on fileSize/120)
- Gerefactored: LogParser -> StandardLogParser + ILogParser interface
- Toegevoegd: About dialog en parser configuratie UI
- Verbeterd: Resource bundling voor macOS (achtergrond, fonts, icoon)
- Vergroot: Standaard venstergrootte naar 1600x900
- Vernieuwd: App icoon met transparante achtergrond
- Toegevoegd: vcpkg.json voor dependency management
- Opgeschoond: Repository structuur en .gitignore

Author: parvenuprompting

.gitignore

@@ -1,28 +1,35 @@
-# Build artifacts
+# Build Artifacts
+build/
 *.o
+*.app
+*.dSYM
+
+# Executables (if not in build/)
 log_analyzer
 log_analyzer_gui
+log_analyzer_gui_*
 test_parser
 test_analyzers
+test_catch2
+unit_tests
 
-# Output files
-out_report.txt
-test_output.txt
+# Runtime & Config
 *.log
+resources/MyIcon.iconset
+log_analyzer_config.ini
+imgui.ini
+
+# Test Output
+test_output.txt
+tests/test_output.txt
+out_report.txt
+large_test.log
+large_report.txt
 
-# IDE
+# OS & IDE
+.DS_Store
 .vscode/
 .idea/
 *.swp
 *.swo
 *~
-
-# macOS
-.DS_Store
-
-# External libraries (downloaded)
-external/imgui/
-
-# Test artifacts
-large_test.log
-large_report.txt

CMakeLists.txt

@@ -43,7 +43,8 @@ target_link_libraries(imgui PUBLIC glfw)
 
 # --- Core Sources ---
 set(CORE_SOURCES
-    core/LogParser.cpp
+    core/StandardLogParser.cpp
+    core/PatternLogParser.cpp
     core/Timestamp.cpp
     core/ConfigManager.cpp
     io/MemoryMappedFile.cpp
@@ -65,11 +66,19 @@ add_executable(log_analyzer
 )
 
 # --- GUI Executable ---
-add_executable(log_analyzer_gui
+add_executable(log_analyzer_gui MACOSX_BUNDLE
     ${CORE_SOURCES}
     gui/GuiController.cpp
     gui/LogViewer.cpp
     gui/main_gui.cpp
+    resources/AppIcon.icns
+    resources/background_calm.png
+    resources/fa-solid-900.ttf
+)
+
+set_target_properties(log_analyzer_gui PROPERTIES
+    MACOSX_BUNDLE_ICON_FILE "AppIcon.icns"
+    RESOURCE "resources/AppIcon.icns;resources/background_calm.png;resources/fa-solid-900.ttf"
 )
 # Link imgui (which links glfw), and macOS frameworks
 target_link_libraries(log_analyzer_gui PRIVATE imgui ${COCOA_LIB} ${IOKIT_LIB} ${COREVIDEO_LIB} OpenGL::GL)
@@ -81,6 +90,7 @@ add_executable(unit_tests
     ${CORE_SOURCES}
     tests/test_parser_catch2.cpp
     tests/test_analyzers_catch2.cpp
+    tests/test_pattern_parser.cpp
     tests/test_main_catch2.cpp
     external/catch2/catch_amalgamated.cpp
 )

analysis/AnalysisContext.h

@@ -10,6 +10,7 @@ struct AnalysisContext {
   std::optional<Timestamp> fromTs;
   std::optional<Timestamp> toTs;
   std::optional<std::string> keyword;
+  std::string customPattern; // If non-empty, use PatternLogParser
 };
 
 } // namespace loganalyzer

analysis/AnalysisResult.cpp

@@ -20,6 +20,19 @@ void AnalysisResult::merge(const AnalysisResult &other) {
     levelCounts[level] += count;
   }
 
+  // Merge Heatmap
+  for (size_t d = 0; d < 7; ++d) {
+    for (size_t h = 0; h < 24; ++h) {
+      heatmap[d][h] += other.heatmap[d][h];
+    }
+  }
+
+  // Merge Timeline
+  // NOTE: Simple concatenation. Sorting should happen at the end of pipeline.
+  // Ideally, specialized merging that buckets by minute would be better,
+  // but for now, append and let the GUI or finalizer sort it.
+  timeline.insert(timeline.end(), other.timeline.begin(), other.timeline.end());
+
   // Merge topErrors
   // Strategy: Combine both vectors into a map to sum counts, then recreate
   // vector

analysis/AnalysisResult.h

@@ -2,6 +2,7 @@
 
 #include "../core/LogLevel.h"
 #include "../core/ParseError.h"
+#include <array>
 #include <cstdint>
 #include <map>
 #include <string>
@@ -24,6 +25,22 @@ struct AnalysisResult {
   // Top 10 ERROR messages: (message, count), deterministically sorted
   std::vector<std::pair<std::string, uint64_t>> topErrors;
 
+  // Timeline Data: Minute-by-minute error/warning counts
+  // Storing simple counts per minute bucket (relative to start time or
+  // absolute?) Let's store absolute timestamps (rounded to minute) -> count
+  // Using vector of pairs for determinism and easy plotting
+  struct TimelineBucket {
+    uint64_t timestamp; // Unix timestamp for minute
+    uint32_t errorCount;
+    uint32_t warningCount;
+  };
+  std::vector<TimelineBucket> timeline;
+
+  // Heatmap Data: 7 Days x 24 Hours
+  // heatmap[day_of_week][hour_of_day] = count
+  // day 0 = Sunday, 1 = Monday ... 6 = Saturday
+  std::array<std::array<uint32_t, 24>, 7> heatmap = {};
+
   void merge(const AnalysisResult &other);
 };
 

analysis/Pipeline.cpp

@@ -1,5 +1,6 @@
 #include "Pipeline.h"
-#include "../core/LogParser.h"
+#include "../core/PatternLogParser.h"
+#include "../core/StandardLogParser.h"
 #include "../io/MemoryMappedFile.h"
 #include "KeywordHitAnalyzer.h"
 #include "LevelCountAnalyzer.h"
@@ -141,6 +142,18 @@ AnalysisResult Pipeline::run(const std::string &inputPath,
     const uint64_t progressReportInterval = 1024 * 1024; // 1MB
     uint64_t bytesSinceLastReport = 0;
 
+    // Thread-local timeline aggregator
+    std::map<uint64_t, std::pair<uint32_t, uint32_t>>
+        localTimeline; // Key -> {Error, Warning}
+
+    // Setup parser
+    std::unique_ptr<ILogParser> parser;
+    if (!context.customPattern.empty()) {
+      parser = std::make_unique<PatternLogParser>(context.customPattern);
+    } else {
+      parser = std::make_unique<StandardLogParser>();
+    }
+
     while (currentPos < endOffset) {
       if (wasCancelled && *wasCancelled)
         return localResult;
@@ -161,7 +174,7 @@ AnalysisResult Pipeline::run(const std::string &inputPath,
       lineNumber++;
 
       // Parse
-      ParseResult parseResult = LogParser::parse(line, lineNumber);
+      ParseResult parseResult = parser->parse(line, lineNumber);
 
       if (std::holds_alternative<LogEntry>(parseResult)) {
         localResult.parsedLines++; // thread-local count
@@ -173,6 +186,52 @@ AnalysisResult Pipeline::run(const std::string &inputPath,
           for (auto &analyzer : analyzers) {
             analyzer->process(entry);
           }
+
+          // --- Populate Heatmap & Timeline ---
+          if (entry.ts.month > 0) { // Valid check heuristic
+            // Calculate day of week (0=Sunday)
+            // Zeller's congruence or just std::tm if we reused it?
+            // Optimization: We manually parsed ts, so we don't have tm
+            // directly. Let's rely on a helper or basic calculation. For speed,
+            // C++20 chrono is best but we are C++17 here (mostly). Let's do a
+            // simple Zeller for Day of Week. Zeller algorithm (0=Saturday,
+            // 1=Sunday.. for the math, adjusted to 0=Sun):
+            int y = entry.ts.year;
+            int m = entry.ts.month;
+            int q = entry.ts.day;
+            if (m < 3) {
+              m += 12;
+              y -= 1;
+            }
+            int K = y % 100;
+            int J = y / 100;
+            int h = (q + 13 * (m + 1) / 5 + K + K / 4 + J / 4 + 5 * J) % 7;
+            // h is 0=Saturday, 1=Sunday...6=Friday
+            // Map to 0=Sunday...6=Saturday
+            int dayIdx = (h + 1) % 7; // Now 0=Sun, 1=Mon...6=Sat
+
+            int hourIdx = entry.ts.hour;
+            if (dayIdx >= 0 && dayIdx < 7 && hourIdx >= 0 && hourIdx < 24) {
+              localResult.heatmap[dayIdx][hourIdx]++;
+            }
+
+            // Timeline: Bucket by minute
+            // We need a monotonic timestamp.
+            // Let's assume entry.ts can convert to unix time approx or we just
+            // use the raw components. Let's use a simplified 64-bit sort key:
+            // YYYYMMDDHHMM This is sufficient for sorting and buckets.
+            uint64_t timeKey = (uint64_t)entry.ts.year * 100000000 +
+                               (uint64_t)entry.ts.month * 1000000 +
+                               (uint64_t)entry.ts.day * 10000 +
+                               (uint64_t)entry.ts.hour * 100 +
+                               (uint64_t)entry.ts.minute;
+
+            if (entry.level == LogLevel::ERROR) {
+              localTimeline[timeKey].first++;
+            } else if (entry.level == LogLevel::WARNING) {
+              localTimeline[timeKey].second++;
+            }
+          }
         }
       } else {
         localResult.invalidLines++;
@@ -208,6 +267,13 @@ AnalysisResult Pipeline::run(const std::string &inputPath,
     for (auto &analyzer : analyzers) {
       analyzer->finalize(localResult);
     }
+
+    // Flatten timeline map to vector
+    localResult.timeline.reserve(localTimeline.size());
+    for (const auto &[timeKey, counts] : localTimeline) {
+      localResult.timeline.push_back({timeKey, counts.first, counts.second});
+    }
+
     return localResult;
   };
 

app/AppRequest.h

@@ -11,6 +11,7 @@ struct AppRequest {
   std::optional<Timestamp> fromTimestamp;
   std::optional<Timestamp> toTimestamp;
   std::optional<std::string> keyword;
+  std::string customPattern;
 };
 
 } // namespace loganalyzer

app/Application.cpp

@@ -38,6 +38,7 @@ void Application::runHeadless(const AppRequest &request, AppResult &result,
   context.fromTs = request.fromTimestamp;
   context.toTs = request.toTimestamp;
   context.keyword = request.keyword;
+  context.customPattern = request.customPattern;
 
   // Run pipeline with progress callback
   try {

core/ILogParser.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "ParseResult.h"
+#include <string_view>
+
+namespace loganalyzer {
+
+class ILogParser {
+public:
+  virtual ~ILogParser() = default;
+
+  // Thread-safe parse method
+  virtual ParseResult parse(std::string_view line, size_t lineNumber) const = 0;
+};
+
+} // namespace loganalyzer