add QUILL_DETAILED_FUNCTION_NAME and process_function_name

Author: odygrd

CHANGELOG.md

@@ -134,6 +134,18 @@
   are not needed in the `PatternFormatter`. This removes embedded source path strings from built binaries from the
   security viewpoint.
 
+- Added the `QUILL_DETAILED_FUNCTION_NAME` CMake option. When enabled, this option uses compiler-specific detailed
+  function signatures (such as `__PRETTY_FUNCTION__` on GCC/Clang or `__FUNCSIG__` on MSVC) instead of the standard
+  `__FUNCTION__` in log macros. This provides more complete function information, including return types, namespaces,
+  and parameter types. This option is only relevant when `%(caller_function)` is used in the pattern
+  formatter. ([#785](https://github.com/odygrd/quill/issues/785))
+
+- Added `process_function_name` customisation point in `PatternFormatterOptions`. This function allows custom processing
+  of the function signature before it's displayed in logs. This makes more sense to use when
+  `QUILL_DETAILED_FUNCTION_NAME` is used. This provides flexibility to trim, format, or otherwise modify function
+  signatures to improve readability in log output when using the `%(caller_function)`
+  pattern. ([#785](https://github.com/odygrd/quill/issues/785))
+
 - Added helper macros for easy logging of user-defined types. Two new macros are available in `quill/HelperMacros.h`:
   - `QUILL_LOGGABLE_DIRECT_FORMAT(Type)`: For types that contain pointers or have lifetime dependencies
   - `QUILL_LOGGABLE_DEFERRED_FORMAT(Type)`: For types that only contain value types and are safe to copy

CMakeLists.txt

@@ -15,6 +15,8 @@ option(QUILL_DISABLE_NON_PREFIXED_MACROS "Enable this option to disable non-pref
 
 option(QUILL_DISABLE_FUNCTION_NAME "Disable the use of __FUNCTION__ in `LOG_*` macros when the function name is not needed." OFF)
 
+option(QUILL_DETAILED_FUNCTION_NAME "Use detailed function name (__PRETTY_FUNCTION__ or __FUNCSIG__) instead of __FUNCTION__ in LOG_* macros" OFF)
+
 option(QUILL_DISABLE_FILE_INFO "Disable the use of __FILE__ and __LINE__ in `LOG_*` macros when the file name and the line number are not needed." OFF)
 
 option(QUILL_BUILD_EXAMPLES "Enable this option to build and install the examples. Set this to ON to include example projects in the build process and have them installed after configuring with CMake." OFF)
@@ -121,6 +123,7 @@ message(STATUS "QUILL_NO_THREAD_NAME_SUPPORT: " ${QUILL_NO_THREAD_NAME_SUPPORT})
 message(STATUS "QUILL_X86ARCH: " ${QUILL_X86ARCH})
 message(STATUS "QUILL_DISABLE_NON_PREFIXED_MACROS: " ${QUILL_DISABLE_NON_PREFIXED_MACROS})
 message(STATUS "QUILL_DISABLE_FUNCTION_NAME: " ${QUILL_DISABLE_FUNCTION_NAME})
+message(STATUS "QUILL_DETAILED_FUNCTION_NAME: " ${QUILL_DETAILED_FUNCTION_NAME})
 message(STATUS "QUILL_DISABLE_FILE_INFO: " ${QUILL_DISABLE_FILE_INFO})
 message(STATUS "QUILL_ENABLE_INSTALL: " ${QUILL_ENABLE_INSTALL})
 
@@ -292,6 +295,10 @@ if (QUILL_DISABLE_FUNCTION_NAME)
     target_compile_definitions(${TARGET_NAME} PUBLIC INTERFACE -DQUILL_DISABLE_FUNCTION_NAME)
 endif ()
 
+if (QUILL_DETAILED_FUNCTION_NAME)
+    target_compile_definitions(${TARGET_NAME} PUBLIC INTERFACE -DQUILL_DETAILED_FUNCTION_NAME)
+endif ()
+
 if (QUILL_DISABLE_FILE_INFO)
     target_compile_definitions(${TARGET_NAME} PUBLIC INTERFACE -DQUILL_DISABLE_FILE_INFO)
 endif ()

docs/cheat_sheet.rst

@@ -47,6 +47,12 @@ Disables ``__FUNCTION__`` information in log statements at compile time when the
 
 Disables ``__FILE__`` and ``__LINE__`` information in log statements at compile time when location-related patterns (``%(file_name)``, ``%(line_number)``, ``%(short_source_location)``, ``%(source_location)``) are not needed in the ``PatternFormatter``. This removes embedded source path strings from built binaries from the security viewpoint.
 
+.. code:: cmake
+
+    option(QUILL_DETAILED_FUNCTION_NAME "Use detailed function name (__PRETTY_FUNCTION__ or __FUNCSIG__) instead of __FUNCTION__ in LOG_* macros" OFF)
+
+Enables the use of compiler-specific detailed function signatures (such as ``__PRETTY_FUNCTION__`` on GCC/Clang or ``__FUNCSIG__`` on MSVC) instead of the standard ``__FUNCTION__`` in log macros. This option is only relevant when ``%(caller_function)`` is used in the pattern formatter. When enabled, you can further customize the function name display by providing a processing function via ``PatternFormatterOptions::process_detailed_function_name``.
+
 .. code:: cmake
 
     add_compile_definitions(-DQUILL_IMMEDIATE_FLUSH=0)
@@ -67,6 +73,12 @@ For example, to keep only warning level and above:
 
     add_compile_definitions(-DQUILL_COMPILE_ACTIVE_LOG_LEVEL=QUILL_COMPILE_ACTIVE_LOG_LEVEL_WARNING)
 
+Hiding File Names and Functions From Build Binaries
+--------------------------------------------------
+From a security standpoint, embedded source file paths and function signatures in binaries can leak sensitive information about your codebase structure.
+To protect use both the `-DQUILL_DISABLE_FUNCTION_NAME` and `-DQUILL_DISABLE_FILE_INFO` compile definitions described above.
+When both options are enabled, neither function names nor file paths will be embedded in your binary, significantly reducing the information available to anyone examining the compiled code.
+
 LOGV Macros
 -----------
 In addition to the ``LOG_`` macros, the ``LOGV_`` macros provide a convenient alternative.

include/quill/LogMacros.h

@@ -45,8 +45,20 @@
 #endif
 
 #if !defined(QUILL_FUNCTION_NAME)
+  #if defined(QUILL_DISABLE_FUNCTION_NAME) && defined(QUILL_DETAILED_FUNCTION_NAME)
+    #error "QUILL_DISABLE_FUNCTION_NAME and QUILL_DETAILED_FUNCTION_NAME are mutually exclusive"
+  #endif
+
   #if defined(QUILL_DISABLE_FUNCTION_NAME)
     #define QUILL_FUNCTION_NAME ""
+  #elif defined(QUILL_DETAILED_FUNCTION_NAME)
+    #if defined(_MSC_VER)
+      #define QUILL_FUNCTION_NAME __FUNCSIG__
+    #elif defined(__clang__) || defined(__GNUC__) || defined(__INTEL_COMPILER)
+      #define QUILL_FUNCTION_NAME __PRETTY_FUNCTION__
+    #else
+      #define QUILL_FUNCTION_NAME __FUNCTION__
+    #endif
   #else
     #define QUILL_FUNCTION_NAME __FUNCTION__
   #endif

include/quill/backend/PatternFormatter.h

@@ -124,7 +124,11 @@ class PatternFormatter
 
     if (_is_set_in_pattern[Attribute::CallerFunction])
     {
-      _set_arg_val<Attribute::CallerFunction>(log_statement_metadata.caller_function());
+      std::string_view const function_name = _options.process_function_name
+        ? _options.process_function_name(log_statement_metadata.caller_function())
+        : std::string_view{log_statement_metadata.caller_function()};
+
+      _set_arg_val<Attribute::CallerFunction>(function_name);
     }
 
     if (_is_set_in_pattern[Attribute::LogLevel])
@@ -291,7 +295,7 @@ class PatternFormatter
 
     _set_arg<Attribute::Time>(std::string_view("time"));
     _set_arg<Attribute::FileName>(std::string_view("file_name"));
-    _set_arg<Attribute::CallerFunction>("caller_function");
+    _set_arg<Attribute::CallerFunction>(std::string_view("caller_function"));
     _set_arg<Attribute::LogLevel>(std::string_view("log_level"));
     _set_arg<Attribute::LogLevelShortCode>(std::string_view("log_level_short_code"));
     _set_arg<Attribute::LineNumber>("line_number");

include/quill/core/PatternFormatterOptions.h

@@ -90,6 +90,25 @@ class PatternFormatterOptions
    */
   std::string source_location_path_strip_prefix{};
 
+  /**
+   * @brief Function pointer for custom processing of detailed function names for %(caller_function)
+   *
+   * This is most useful when QUILL_DETAILED_FUNCTION_NAME is enabled, as it allows
+   * custom processing of the detailed function signature provided by the compiler.
+   *
+   * Since the format of __PRETTY_FUNCTION__ or equivalent is compiler-specific,
+   * this function allows users to implement their own parsing/formatting logic.
+   *
+   * The function takes one parameter:
+   * - The raw function signature string from the compiler (e.g., from __PRETTY_FUNCTION__)
+   *
+   * It should return a string_view representing the processed function name.
+   *
+   * If set to nullptr (default), the logger will use the unprocessed function name
+   * as provided by the compiler.
+   */
+  std::string_view (*process_function_name)(char const*){nullptr};
+
   /**
    * @brief The timezone to use for timestamps.
    *
@@ -121,7 +140,7 @@ class PatternFormatterOptions
   {
     return format_pattern == other.format_pattern && timestamp_pattern == other.timestamp_pattern &&
       source_location_path_strip_prefix == other.source_location_path_strip_prefix &&
-      timestamp_timezone == other.timestamp_timezone &&
+      timestamp_timezone == other.timestamp_timezone && process_function_name == other.process_function_name &&
       add_metadata_to_multi_line_logs == other.add_metadata_to_multi_line_logs &&
       source_location_remove_relative_paths == other.source_location_remove_relative_paths;
   }

test/unit_tests/PatternFormatterTest.cpp

@@ -545,6 +545,56 @@ TEST_CASE("pattern_formatter_source_location_prefix")
   }
 }
 
+TEST_CASE("pattern_formatter_process_function_name")
+{
+  std::vector<std::pair<std::string, std::string>> named_args;
+  uint64_t const ts{1579815761000023021};
+  char const* thread_id = "31341";
+  std::string const logger_name = "test_logger";
+  MacroMetadata macro_metadata{
+    __FILE__ ":" QUILL_STRINGIFY(__LINE__), __func__, "{}}", nullptr, LogLevel::Info, MacroMetadata::Event::Log};
+
+  PatternFormatterOptions po;
+  po.format_pattern = "%(caller_function)";
+  po.process_function_name = [](char const* function_name)
+  {
+    std::string_view sv{function_name};
+    // Check if the string ends with a number after an underscore
+    size_t pos = sv.rfind('_');
+    if (pos != std::string_view::npos && pos < sv.length() - 1)
+    {
+      // Check if the characters after the underscore are all digits
+      bool all_digits = true;
+      for (size_t i = pos + 1; i < sv.length(); ++i)
+      {
+        if (!std::isdigit(sv[i]))
+        {
+          all_digits = false;
+          break;
+        }
+      }
+
+      // If they are all digits, remove the underscore and the digits
+      if (all_digits)
+      {
+        return sv.substr(0, pos);
+      }
+    }
+    return sv;
+  };
+
+  PatternFormatter pattern_formatter{po};
+
+  auto const& formatted_buffer =
+    pattern_formatter.format(ts, thread_id, thread_name, process_id, logger_name, "INFO", "I",
+                             macro_metadata, &named_args, std::string_view{});
+
+  // in this test we remove e.g. _31 from the function name with process_function_name
+  std::string const formatted_string = fmtquill::to_string(formatted_buffer);
+  std::string const expected_string = "DOCTEST_ANON_FUNC\n";
+  REQUIRE_EQ(formatted_string, expected_string);
+}
+
 struct PatternFormatterMock : public PatternFormatter
 {
   PatternFormatterMock() : PatternFormatter(PatternFormatterOptions{}) {};