ci: sentry implementaion

.github/workflows/build.yml

@@ -126,9 +126,9 @@ jobs:
         run: |
             git submodule update --init --recursive
 
-      - name: Install sonar-scanner
+      - name: Install sonar-scanner and build-wrapper
         if: ${{ matrix.os == 'ubuntu-22.04' }}
-        uses: sonarsource/sonarcloud-github-c-cpp@v3
+        uses: SonarSource/sonarqube-scan-action/install-build-wrapper@v4
 
       - name: Install latest CMake and Ninja
         uses: lukka/get-cmake@latest
@@ -209,13 +209,15 @@ jobs:
 
       - name: Run sonar-scanner
         if: ${{ matrix.os == 'ubuntu-22.04' }}
+        continue-on-error: true  # SonarScanner has intermittent internal bugs
+        uses: SonarSource/sonarqube-scan-action@v4
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           SONAR_TOKEN: ${{ secrets.SONARCLOUD_TOKEN }}
-        run: |
-          sonar-scanner \
-            --define sonar.cfamily.compile-commands="./build/compile_commands.json" \
-            --define sonar.coverageReportPaths=coverage.xml
+        with:
+          args: >
+            -Dsonar.cfamily.compile-commands=./build/compile_commands.json
+            -Dsonar.coverageReportPaths=coverage.xml
 
       - name: Install nexoEditor
         shell: bash

.github/workflows/codeql.yml

@@ -114,7 +114,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3
+        uses: github/codeql-action/init@v4
         env:
           USERNAME: NexoEngine
         with:
@@ -140,6 +140,6 @@ jobs:
           CMAKE_CXX_COMPILER: ${{ matrix.compiler == 'clang' && steps.set-up-clang.outputs.clangxx || matrix.compiler == 'gcc' && steps.set-up-gcc.outputs.gxx || '' }}
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v3
+        uses: github/codeql-action/analyze@v4
         with:
           category: "/language:${{matrix.language}}"

.gitignore

@@ -172,3 +172,4 @@ html/
 _CPack_Packages/
 
 myinstall/
+*.gcov

CMakeLists.txt

@@ -13,6 +13,15 @@ set(NEXO_BOOTSTRAP_VCPKG OFF CACHE BOOL "Enable vcpkg bootstrap")
 set(NEXO_BUILD_TESTS ON CACHE BOOL "Enable tests")
 set(NEXO_BUILD_EXAMPLES OFF CACHE BOOL "Enable examples")
 set(NEXO_GRAPHICS_API "OpenGL" CACHE STRING "Graphics API to use")
+set(NEXO_ENABLE_SENTRY ON CACHE BOOL "Enable Sentry crash tracking")
+set(NEXO_SENTRY_DEBUG_MODE OFF CACHE BOOL "Enable Sentry debug mode (local file output)")
+
+if (CMAKE_BUILD_TYPE STREQUAL "Debug")
+    set(NEXO_ENABLE_SENTRY OFF CACHE BOOL "Enable Sentry crash tracking" FORCE)
+    if (NOT DEFINED NEXO_SENTRY_DEBUG_MODE OR NEXO_SENTRY_DEBUG_MODE)
+        set(NEXO_SENTRY_DEBUG_MODE ON CACHE BOOL "Enable Sentry debug mode (local file output)" FORCE)
+    endif()
+endif()
 
 if (CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
     set(NEXO_COMPILER_FLAGS_ALL --std=c++${CMAKE_CXX_STANDARD})
@@ -23,15 +32,25 @@ if (CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
     set(NEXO_LINKER_FLAGS_ALL "")
     set(NEXO_LINKER_FLAGS_DEBUG "")
     set(NEXO_LINKER_FLAGS_RELEASE "-flto")
+
+    if (NEXO_ENABLE_SENTRY OR NEXO_SENTRY_DEBUG_MODE)
+        list(APPEND NEXO_COMPILER_FLAGS_RELEASE -g -funwind-tables -fno-omit-frame-pointer)
+        list(APPEND NEXO_COMPILER_FLAGS_DEBUG -funwind-tables -fno-omit-frame-pointer)
+    endif()
 elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
     set(NEXO_COMPILER_FLAGS_ALL /nologo /W4 /std:c++${CMAKE_CXX_STANDARD} /Zc:preprocessor /utf-8)
     set(NEXO_COMPILER_FLAGS_DEBUG /Zi /Od /Zc:preprocessor /MDd /D_DEBUG /D_ITERATOR_DEBUG_LEVEL=2 /D_SECURE_SCL=1)
     set(NEXO_COMPILER_FLAGS_RELEASE /O2 /Zc:preprocessor /DNDEBUG /MD)
-    set(NEXO_COVERAGE_FLAGS "")  # MSVC doesn't support coverage in the same way
+    set(NEXO_COVERAGE_FLAGS "")
 
     set(NEXO_LINKER_FLAGS_ALL "")
     set(NEXO_LINKER_FLAGS_DEBUG "")
     set(NEXO_LINKER_FLAGS_RELEASE "/LTCG")
+
+    if (NEXO_ENABLE_SENTRY OR NEXO_SENTRY_DEBUG_MODE)
+        list(APPEND NEXO_COMPILER_FLAGS_RELEASE /Zi)
+        list(APPEND NEXO_LINKER_FLAGS_RELEASE /DEBUG /OPT:REF /OPT:ICF)
+    endif()
 else()
     message(WARNING "Unsupported compiler: ${CMAKE_CXX_COMPILER_ID}, using default flags")
 endif()
@@ -106,6 +125,39 @@ message(STATUS "Running VCPKG...")
 include("${CMAKE_CURRENT_SOURCE_DIR}/vcpkg/scripts/buildsystems/vcpkg.cmake")
 message(STATUS "VCPKG done.")
 
+# SENTRY CONFIGURATION
+if (NEXO_ENABLE_SENTRY OR NEXO_SENTRY_DEBUG_MODE)
+    message(STATUS "Sentry crash tracking enabled")
+    find_package(sentry CONFIG REQUIRED)
+
+    if (NEXO_ENABLE_SENTRY)
+        add_compile_definitions(NEXO_SENTRY_ENABLED)
+        message(STATUS "  Mode: Production (network reporting)")
+    endif()
+
+    if (NEXO_SENTRY_DEBUG_MODE)
+        add_compile_definitions(NEXO_SENTRY_DEBUG_MODE)
+        message(STATUS "  Mode: Debug (local file output)")
+    endif()
+
+    find_package(Git QUIET)
+    if(GIT_FOUND)
+        execute_process(
+            COMMAND ${GIT_EXECUTABLE} describe --tags --always --dirty
+            WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+            OUTPUT_VARIABLE NEXO_GIT_VERSION
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+            ERROR_QUIET
+        )
+        if(NEXO_GIT_VERSION)
+            add_compile_definitions(NEXO_SENTRY_RELEASE="${NEXO_GIT_VERSION}")
+            message(STATUS "  Release version: ${NEXO_GIT_VERSION}")
+        endif()
+    endif()
+else()
+    message(STATUS "Sentry crash tracking disabled")
+endif()
+
 # SETUP EDITOR
 include("${CMAKE_CURRENT_SOURCE_DIR}/editor/CMakeLists.txt")
 # SETUP ENGINE

common/Exception.cpp

@@ -20,6 +20,10 @@
 
 #include <format>
 
+#if defined(NEXO_SENTRY_ENABLED) || defined(NEXO_SENTRY_DEBUG_MODE)
+namespace nexo::crash { class CrashTracker; }
+#endif
+
 namespace nexo {
     const char *Exception::what() const noexcept
     {

common/String.hpp

@@ -19,7 +19,10 @@
 #pragma once
 
 #include <string_view>
+#include <string>
+#include <vector>
 #include <ranges>
+#include <algorithm>
 
 namespace nexo {
     /**
@@ -37,5 +40,219 @@ namespace nexo {
             });
     }
 
+    /**
+     * @brief Convert a string to lowercase.
+     *
+     * @param str The string to convert.
+     * @return A new string with all characters in lowercase.
+     */
+    [[nodiscard]] inline std::string toLower(std::string_view str) {
+        std::string result;
+        result.reserve(str.size());
+        std::ranges::transform(str, std::back_inserter(result), [](const char c) {
+            return static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
+        });
+        return result;
+    }
+
+    /**
+     * @brief Convert a string to uppercase.
+     *
+     * @param str The string to convert.
+     * @return A new string with all characters in uppercase.
+     */
+    [[nodiscard]] inline std::string toUpper(std::string_view str) {
+        std::string result;
+        result.reserve(str.size());
+        std::ranges::transform(str, std::back_inserter(result), [](const char c) {
+            return static_cast<char>(std::toupper(static_cast<unsigned char>(c)));
+        });
+        return result;
+    }
+
+    /**
+     * @brief Check if a string starts with a given prefix.
+     *
+     * @param str The string to check.
+     * @param prefix The prefix to search for.
+     * @return true if str starts with prefix, false otherwise.
+     */
+    [[nodiscard]] constexpr bool startsWith(const std::string_view& str, const std::string_view& prefix) {
+        return str.size() >= prefix.size() && str.substr(0, prefix.size()) == prefix;
+    }
+
+    /**
+     * @brief Check if a string starts with a given prefix (case-insensitive).
+     *
+     * @param str The string to check.
+     * @param prefix The prefix to search for.
+     * @return true if str starts with prefix (case-insensitive), false otherwise.
+     */
+    [[nodiscard]] constexpr bool istartsWith(const std::string_view& str, const std::string_view& prefix) {
+        if (str.size() < prefix.size()) return false;
+        return iequals(str.substr(0, prefix.size()), prefix);
+    }
+
+    /**
+     * @brief Check if a string ends with a given suffix.
+     *
+     * @param str The string to check.
+     * @param suffix The suffix to search for.
+     * @return true if str ends with suffix, false otherwise.
+     */
+    [[nodiscard]] constexpr bool endsWith(const std::string_view& str, const std::string_view& suffix) {
+        return str.size() >= suffix.size() && str.substr(str.size() - suffix.size()) == suffix;
+    }
+
+    /**
+     * @brief Check if a string ends with a given suffix (case-insensitive).
+     *
+     * @param str The string to check.
+     * @param suffix The suffix to search for.
+     * @return true if str ends with suffix (case-insensitive), false otherwise.
+     */
+    [[nodiscard]] constexpr bool iendsWith(const std::string_view& str, const std::string_view& suffix) {
+        if (str.size() < suffix.size()) return false;
+        return iequals(str.substr(str.size() - suffix.size()), suffix);
+    }
+
+    /**
+     * @brief Trim whitespace from the left side of a string.
+     *
+     * @param str The string to trim.
+     * @return A new string with leading whitespace removed.
+     */
+    [[nodiscard]] inline std::string ltrim(std::string_view str) {
+        const auto start = std::ranges::find_if(str, [](const char c) {
+            return !std::isspace(static_cast<unsigned char>(c));
+        });
+        return std::string(start, str.end());
+    }
+
+    /**
+     * @brief Trim whitespace from the right side of a string.
+     *
+     * @param str The string to trim.
+     * @return A new string with trailing whitespace removed.
+     */
+    [[nodiscard]] inline std::string rtrim(std::string_view str) {
+        const auto end = std::ranges::find_if(str | std::views::reverse, [](const char c) {
+            return !std::isspace(static_cast<unsigned char>(c));
+        }).base();
+        return std::string(str.begin(), end);
+    }
+
+    /**
+     * @brief Trim whitespace from both sides of a string.
+     *
+     * @param str The string to trim.
+     * @return A new string with leading and trailing whitespace removed.
+     */
+    [[nodiscard]] inline std::string trim(std::string_view str) {
+        return ltrim(rtrim(str));
+    }
+
+    /**
+     * @brief Check if a string contains a substring.
+     *
+     * @param str The string to search in.
+     * @param substr The substring to search for.
+     * @return true if str contains substr, false otherwise.
+     */
+    [[nodiscard]] constexpr bool contains(const std::string_view& str, const std::string_view& substr) {
+        return str.find(substr) != std::string_view::npos;
+    }
+
+    /**
+     * @brief Check if a string contains a substring (case-insensitive).
+     *
+     * @param str The string to search in.
+     * @param substr The substring to search for.
+     * @return true if str contains substr (case-insensitive), false otherwise.
+     */
+    [[nodiscard]] inline bool icontains(const std::string_view& str, const std::string_view& substr) {
+        if (substr.empty()) return true;
+        if (str.size() < substr.size()) return false;
+
+        for (size_t i = 0; i <= str.size() - substr.size(); ++i) {
+            if (iequals(str.substr(i, substr.size()), substr)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * @brief Replace all occurrences of a substring with another string.
+     *
+     * @param str The original string.
+     * @param from The substring to replace.
+     * @param to The replacement string.
+     * @return A new string with all occurrences replaced.
+     */
+    [[nodiscard]] inline std::string replaceAll(std::string_view str, std::string_view from, std::string_view to) {
+        if (from.empty()) return std::string(str);
+
+        std::string result;
+        result.reserve(str.size());
+        size_t start_pos = 0;
+        size_t pos;
+
+        while ((pos = str.find(from, start_pos)) != std::string_view::npos) {
+            result.append(str.substr(start_pos, pos - start_pos));
+            result.append(to);
+            start_pos = pos + from.size();
+        }
+        result.append(str.substr(start_pos));
+        return result;
+    }
+
+    /**
+     * @brief Split a string by a delimiter.
+     *
+     * @param str The string to split.
+     * @param delimiter The delimiter to split by.
+     * @return A vector of substrings.
+     */
+    [[nodiscard]] inline std::vector<std::string> split(std::string_view str, std::string_view delimiter) {
+        std::vector<std::string> result;
+        if (delimiter.empty()) {
+            result.emplace_back(str);
+            return result;
+        }
+
+        size_t start = 0;
+        size_t end;
+
+        while ((end = str.find(delimiter, start)) != std::string_view::npos) {
+            result.emplace_back(str.substr(start, end - start));
+            start = end + delimiter.size();
+        }
+        result.emplace_back(str.substr(start));
+        return result;
+    }
+
+    /**
+     * @brief Join a collection of strings with a delimiter.
+     *
+     * @param strings The strings to join.
+     * @param delimiter The delimiter to use.
+     * @return A single string with all elements joined.
+     */
+    template<typename Container>
+    [[nodiscard]] inline std::string join(const Container& strings, std::string_view delimiter) {
+        if (strings.empty()) return "";
+
+        std::string result;
+        auto it = strings.begin();
+        result.append(*it);
+        ++it;
+
+        for (; it != strings.end(); ++it) {
+            result.append(delimiter);
+            result.append(*it);
+        }
+        return result;
+    }
 
 } // namespace nexo