refactor event system

repertory/librepertory/include/drives/remote/remote_server_base.hpp

@@ -58,7 +58,10 @@ public:
         drive_(drv),
         mount_location_(std::move(mount_location)),
         client_pool_(config.get_remote_mount().client_pool_size) {
-    event_system::instance().raise<service_start_begin>("remote_server_base");
+    REPERTORY_USES_FUNCTION_NAME();
+
+    event_system::instance().raise<service_start_begin>(function_name,
+                                                        "remote_server_base");
     handler_lookup_.insert(
         {"::winfsp_can_delete",
          [this](std::uint32_t, const std::string &, std::uint64_t,
@@ -1375,14 +1378,19 @@ public:
                                        method, request, response,
                                        message_complete);
         });
-    event_system::instance().raise<service_start_end>("remote_server_base");
+    event_system::instance().raise<service_start_end>(function_name,
+                                                      "remote_server_base");
   }
 
   ~remote_server_base() override {
-    event_system::instance().raise<service_stop_begin>("remote_server_base");
+    REPERTORY_USES_FUNCTION_NAME();
+
+    event_system::instance().raise<service_stop_begin>(function_name,
+                                                       "remote_server_base");
     client_pool_.shutdown();
     packet_server_.reset();
-    event_system::instance().raise<service_stop_end>("remote_server_base");
+    event_system::instance().raise<service_stop_end>(function_name,
+                                                     "remote_server_base");
   }
 
 public:

repertory/librepertory/src/comm/packet/client_pool.cpp

@@ -46,7 +46,8 @@ void client_pool::pool::execute(
 client_pool::pool::pool(std::uint8_t pool_size) {
   REPERTORY_USES_FUNCTION_NAME();
 
-  event_system::instance().raise<service_start_begin>("client_pool");
+  event_system::instance().raise<service_start_begin>(function_name,
+                                                      "client_pool");
 
   for (std::uint8_t i = 0U; i < pool_size; i++) {
     pool_queues_.emplace_back(std::make_unique<work_queue>());
@@ -109,7 +110,8 @@ client_pool::pool::pool(std::uint8_t pool_size) {
     });
   }
 
-  event_system::instance().raise<service_start_end>("client_pool");
+  event_system::instance().raise<service_start_end>(function_name,
+                                                    "client_pool");
 }
 
 void client_pool::pool::shutdown() {
@@ -151,11 +153,14 @@ void client_pool::remove_client(const std::string &client_id) {
 }
 
 void client_pool::shutdown() {
+  REPERTORY_USES_FUNCTION_NAME();
+
   if (shutdown_) {
     return;
   }
 
-  event_system::instance().raise<service_stop_begin>("client_pool");
+  event_system::instance().raise<service_stop_begin>(function_name,
+                                                     "client_pool");
   unique_mutex_lock pool_lock(pool_mutex_);
   if (not shutdown_) {
     shutdown_ = true;
@@ -165,6 +170,7 @@ void client_pool::shutdown() {
     pool_lookup_.clear();
   }
   pool_lock.unlock();
-  event_system::instance().raise<service_stop_end>("client_pool");
+  event_system::instance().raise<service_stop_end>(function_name,
+                                                   "client_pool");
 }
 } // namespace repertory

repertory/librepertory/src/comm/packet/packet_server.cpp

@@ -40,13 +40,20 @@ packet_server::packet_server(std::uint16_t port, std::string token,
     : encryption_token_(std::move(token)),
       closed_(std::move(closed)),
       message_handler_(std::move(message_handler)) {
-  event_system::instance().raise<service_start_begin>("packet_server");
+  REPERTORY_USES_FUNCTION_NAME();
+
+  event_system::instance().raise<service_start_begin>(function_name,
+                                                      "packet_server");
   initialize(port, pool_size);
-  event_system::instance().raise<service_start_end>("packet_server");
+  event_system::instance().raise<service_start_end>(function_name,
+                                                    "packet_server");
 }
 
 packet_server::~packet_server() {
-  event_system::instance().raise<service_stop_begin>("packet_server");
+  REPERTORY_USES_FUNCTION_NAME();
+
+  event_system::instance().raise<service_stop_begin>(function_name,
+                                                     "packet_server");
   std::thread([this]() {
     for (std::size_t i = 0U; i < service_threads_.size(); i++) {
       io_context_.stop();
@@ -55,7 +62,8 @@ packet_server::~packet_server() {
 
   server_thread_->join();
   server_thread_.reset();
-  event_system::instance().raise<service_stop_end>("packet_server");
+  event_system::instance().raise<service_stop_end>(function_name,
+                                                   "packet_server");
 }
 
 void packet_server::add_client(connection &conn, const std::string &client_id) {

repertory/librepertory/src/file_manager/file_manager.cpp

@@ -394,11 +394,10 @@ auto file_manager::open(const std::string &api_path, bool directory,
   return open(api_path, directory, ofd, handle, file, nullptr);
 }
 
-auto file_manager::open(const std::string &api_path, bool directory,
-                        const open_file_data &ofd, std::uint64_t &handle,
-                        std::shared_ptr<i_open_file> &file,
-                        std::shared_ptr<i_closeable_open_file> closeable_file)
-    -> api_error {
+auto file_manager::open(
+    const std::string &api_path, bool directory, const open_file_data &ofd,
+    std::uint64_t &handle, std::shared_ptr<i_open_file> &file,
+    std::shared_ptr<i_closeable_open_file> closeable_file) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   const auto create_and_add_handle =
@@ -770,8 +769,8 @@ auto file_manager::rename_directory(const std::string &from_api_path,
 }
 
 auto file_manager::rename_file(const std::string &from_api_path,
-                               const std::string &to_api_path, bool overwrite)
-    -> api_error {
+                               const std::string &to_api_path,
+                               bool overwrite) -> api_error {
   if (not provider_.is_rename_supported()) {
     return api_error::not_implemented;
   }
@@ -849,7 +848,8 @@ void file_manager::start() {
     return;
   }
 
-  event_system::instance().raise<service_start_begin>("file_manager");
+  event_system::instance().raise<service_start_begin>(function_name,
+                                                      "file_manager");
   stop_requested_ = false;
 
   polling::instance().set_callback({
@@ -860,7 +860,8 @@ void file_manager::start() {
 
   if (provider_.is_read_only()) {
     stop_requested_ = false;
-    event_system::instance().raise<service_start_end>("file_manager");
+    event_system::instance().raise<service_start_end>(function_name,
+                                                      "file_manager");
     return;
   }
 
@@ -920,15 +921,19 @@ void file_manager::start() {
   }
 
   upload_thread_ = std::make_unique<std::thread>([this] { upload_handler(); });
-  event_system::instance().raise<service_start_end>("file_manager");
+  event_system::instance().raise<service_start_end>(function_name,
+                                                    "file_manager");
 }
 
 void file_manager::stop() {
+  REPERTORY_USES_FUNCTION_NAME();
+
   if (stop_requested_) {
     return;
   }
 
-  event_system::instance().raise<service_stop_begin>("file_manager");
+  event_system::instance().raise<service_stop_begin>(function_name,
+                                                     "file_manager");
 
   stop_requested_ = true;
 
@@ -962,7 +967,8 @@ void file_manager::stop() {
 
   upload_thread_.reset();
 
-  event_system::instance().raise<service_stop_end>("file_manager");
+  event_system::instance().raise<service_stop_end>(function_name,
+                                                   "file_manager");
 }
 
 void file_manager::store_resume(const i_open_file &file) {

repertory/librepertory/src/providers/encrypt/encrypt_provider.cpp

@@ -45,10 +45,9 @@ namespace repertory {
 encrypt_provider::encrypt_provider(app_config &config)
     : config_(config), encrypt_config_(config.get_encrypt_config()) {}
 
-auto encrypt_provider::create_api_file(const std::string &api_path,
-                                       bool directory,
-                                       const std::string &source_path)
-    -> api_file {
+auto encrypt_provider::create_api_file(
+    const std::string &api_path, bool directory,
+    const std::string &source_path) -> api_file {
   auto times{utils::file::get_times(source_path)};
   if (not times.has_value()) {
     throw std::runtime_error("failed to get file times");
@@ -157,9 +156,8 @@ auto encrypt_provider::do_fs_operation(
   return callback(cfg, source_path);
 }
 
-auto encrypt_provider::get_api_path_from_source(const std::string &source_path,
-                                                std::string &api_path) const
-    -> api_error {
+auto encrypt_provider::get_api_path_from_source(
+    const std::string &source_path, std::string &api_path) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   try {
@@ -199,9 +197,8 @@ auto encrypt_provider::get_directory_item_count(
   return count;
 }
 
-auto encrypt_provider::get_directory_items(const std::string &api_path,
-                                           directory_item_list &list) const
-    -> api_error {
+auto encrypt_provider::get_directory_items(
+    const std::string &api_path, directory_item_list &list) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   return do_fs_operation(
@@ -334,9 +331,8 @@ auto encrypt_provider::get_file(const std::string &api_path,
   return api_error::error;
 }
 
-auto encrypt_provider::get_file_list(api_file_list &list,
-                                     std::string & /* marker */) const
-    -> api_error {
+auto encrypt_provider::get_file_list(
+    api_file_list &list, std::string & /* marker */) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   const auto &cfg{get_encrypt_config()};
@@ -359,9 +355,8 @@ auto encrypt_provider::get_file_list(api_file_list &list,
   return api_error::error;
 }
 
-auto encrypt_provider::get_file_size(const std::string &api_path,
-                                     std::uint64_t &file_size) const
-    -> api_error {
+auto encrypt_provider::get_file_size(
+    const std::string &api_path, std::uint64_t &file_size) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   try {
@@ -382,10 +377,9 @@ auto encrypt_provider::get_file_size(const std::string &api_path,
   return api_error::error;
 }
 
-auto encrypt_provider::get_filesystem_item(const std::string &api_path,
-                                           bool directory,
-                                           filesystem_item &fsi) const
-    -> api_error {
+auto encrypt_provider::get_filesystem_item(
+    const std::string &api_path, bool directory,
+    filesystem_item &fsi) const -> api_error {
   std::string source_path;
   if (directory) {
     auto result{db_->get_directory_source_path(api_path, source_path)};
@@ -436,10 +430,9 @@ auto encrypt_provider::get_filesystem_item_from_source_path(
   return get_filesystem_item(api_path, false, fsi);
 }
 
-auto encrypt_provider::get_filesystem_item_and_file(const std::string &api_path,
-                                                    api_file &file,
-                                                    filesystem_item &fsi) const
-    -> api_error {
+auto encrypt_provider::get_filesystem_item_and_file(
+    const std::string &api_path, api_file &file,
+    filesystem_item &fsi) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   try {
@@ -565,8 +558,8 @@ auto encrypt_provider::is_directory(const std::string &api_path,
   return api_error::error;
 }
 
-auto encrypt_provider::is_file(const std::string &api_path, bool &exists) const
-    -> api_error {
+auto encrypt_provider::is_file(const std::string &api_path,
+                               bool &exists) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   try {
@@ -875,7 +868,8 @@ auto encrypt_provider::start(api_item_added_callback /*api_item_added*/,
     return false;
   }
 
-  event_system::instance().raise<service_start_begin>("encrypt_provider");
+  event_system::instance().raise<service_start_begin>(function_name,
+                                                      "encrypt_provider");
   db_ = create_file_db(config_);
 
   std::string source_path;
@@ -912,14 +906,19 @@ auto encrypt_provider::start(api_item_added_callback /*api_item_added*/,
       [this](auto &&stop_requested) { remove_deleted_files(stop_requested); },
   });
 
-  event_system::instance().raise<service_start_end>("encrypt_provider");
+  event_system::instance().raise<service_start_end>(function_name,
+                                                    "encrypt_provider");
   return true;
 }
 
 void encrypt_provider::stop() {
-  event_system::instance().raise<service_stop_begin>("encrypt_provider");
+  REPERTORY_USES_FUNCTION_NAME();
+
+  event_system::instance().raise<service_stop_begin>(function_name,
+                                                     "encrypt_provider");
   polling::instance().remove_callback("check_deleted");
   db_.reset();
-  event_system::instance().raise<service_stop_end>("encrypt_provider");
+  event_system::instance().raise<service_stop_end>(function_name,
+                                                   "encrypt_provider");
 }
 } // namespace repertory

repertory/librepertory/src/providers/s3/s3_provider.cpp

@@ -43,9 +43,9 @@
 #include "utils/time.hpp"
 
 namespace {
-[[nodiscard]] auto set_request_path(auto &request,
-                                    const std::string &object_name)
-    -> repertory::api_error {
+[[nodiscard]] auto
+set_request_path(auto &request,
+                 const std::string &object_name) -> repertory::api_error {
   request.path = object_name;
   if (request.path.substr(1U).size() > repertory::max_s3_object_name_length) {
     return repertory::api_error::name_too_long;
@@ -59,9 +59,8 @@ namespace repertory {
 s3_provider::s3_provider(app_config &config, i_http_comm &comm)
     : base_provider(config, comm) {}
 
-auto s3_provider::add_if_not_found(api_file &file,
-                                   const std::string &object_name) const
-    -> api_error {
+auto s3_provider::add_if_not_found(
+    api_file &file, const std::string &object_name) const -> api_error {
   api_meta_map meta{};
   auto res{get_item_meta(file.api_path, meta)};
   if (res == api_error::item_not_found) {
@@ -158,9 +157,8 @@ auto s3_provider::create_directory_impl(const std::string &api_path,
       utils::path::create_api_path(is_encrypted ? meta[META_KEY] : api_path));
 }
 
-auto s3_provider::create_directory_paths(const std::string &api_path,
-                                         const std::string &key) const
-    -> api_error {
+auto s3_provider::create_directory_paths(
+    const std::string &api_path, const std::string &key) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   if (api_path == "/") {
@@ -323,9 +321,8 @@ auto s3_provider::get_directory_item_count(const std::string &api_path) const
   return 0U;
 }
 
-auto s3_provider::get_directory_items_impl(const std::string &api_path,
-                                           directory_item_list &list) const
-    -> api_error {
+auto s3_provider::get_directory_items_impl(
+    const std::string &api_path, directory_item_list &list) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   const auto &cfg{get_s3_config()};
@@ -483,8 +480,8 @@ auto s3_provider::get_directory_items_impl(const std::string &api_path,
   return api_error::success;
 }
 
-auto s3_provider::get_file(const std::string &api_path, api_file &file) const
-    -> api_error {
+auto s3_provider::get_file(const std::string &api_path,
+                           api_file &file) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   try {
@@ -524,8 +521,8 @@ auto s3_provider::get_file(const std::string &api_path, api_file &file) const
   return api_error::error;
 }
 
-auto s3_provider::get_file_list(api_file_list &list, std::string &marker) const
-    -> api_error {
+auto s3_provider::get_file_list(api_file_list &list,
+                                std::string &marker) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   try {
@@ -615,9 +612,8 @@ auto s3_provider::get_file_list(api_file_list &list, std::string &marker) const
   return api_error::error;
 }
 
-auto s3_provider::get_last_modified(bool directory,
-                                    const std::string &api_path) const
-    -> std::uint64_t {
+auto s3_provider::get_last_modified(
+    bool directory, const std::string &api_path) const -> std::uint64_t {
   bool is_encrypted{};
   std::string object_name;
   head_object_result result{};
@@ -627,10 +623,9 @@ auto s3_provider::get_last_modified(bool directory,
              : utils::time::get_time_now();
 }
 
-auto s3_provider::get_object_info(bool directory, const std::string &api_path,
-                                  bool &is_encrypted, std::string &object_name,
-                                  head_object_result &result) const
-    -> api_error {
+auto s3_provider::get_object_info(
+    bool directory, const std::string &api_path, bool &is_encrypted,
+    std::string &object_name, head_object_result &result) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   try {
@@ -690,12 +685,10 @@ auto s3_provider::get_object_info(bool directory, const std::string &api_path,
   return api_error::error;
 }
 
-auto s3_provider::get_object_list(std::string &response_data,
-                                  long &response_code,
-                                  std::optional<std::string> delimiter,
-                                  std::optional<std::string> prefix,
-                                  std::optional<std::string> token) const
-    -> bool {
+auto s3_provider::get_object_list(
+    std::string &response_data, long &response_code,
+    std::optional<std::string> delimiter, std::optional<std::string> prefix,
+    std::optional<std::string> token) const -> bool {
   curl::requests::http_get get{};
   get.allow_timeout = true;
   get.aws_service = "aws:amz:" + get_s3_config().region + ":s3";
@@ -723,8 +716,8 @@ auto s3_provider::get_total_drive_space() const -> std::uint64_t {
   return std::numeric_limits<std::int64_t>::max() / std::int64_t(2);
 }
 
-auto s3_provider::is_directory(const std::string &api_path, bool &exists) const
-    -> api_error {
+auto s3_provider::is_directory(const std::string &api_path,
+                               bool &exists) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   try {
@@ -752,8 +745,8 @@ auto s3_provider::is_directory(const std::string &api_path, bool &exists) const
   return api_error::error;
 }
 
-auto s3_provider::is_file(const std::string &api_path, bool &exists) const
-    -> api_error {
+auto s3_provider::is_file(const std::string &api_path,
+                          bool &exists) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   try {
@@ -1011,8 +1004,8 @@ auto s3_provider::rename_file(const std::string & /* from_api_path */,
   return api_error::not_implemented;
 }
 
-auto s3_provider::set_meta_key(const std::string &api_path, api_meta_map &meta)
-    -> api_error {
+auto s3_provider::set_meta_key(const std::string &api_path,
+                               api_meta_map &meta) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   const auto &cfg{get_s3_config()};
@@ -1047,18 +1040,26 @@ auto s3_provider::set_meta_key(const std::string &api_path, api_meta_map &meta)
 
 auto s3_provider::start(api_item_added_callback api_item_added,
                         i_file_manager *mgr) -> bool {
-  event_system::instance().raise<service_start_begin>("s3_provider");
+  REPERTORY_USES_FUNCTION_NAME();
+
+  event_system::instance().raise<service_start_begin>(function_name,
+                                                      "s3_provider");
   s3_config_ = get_config().get_s3_config();
   get_comm().enable_s3_path_style(s3_config_.use_path_style);
   auto ret = base_provider::start(api_item_added, mgr);
-  event_system::instance().raise<service_start_end>("s3_provider");
-  return ret
+  event_system::instance().raise<service_start_end>(function_name,
+                                                    "s3_provider");
+  return ret;
 }
 
 void s3_provider::stop() {
-  event_system::instance().raise<service_stop_begin>("s3_provider");
+  REPERTORY_USES_FUNCTION_NAME();
+
+  event_system::instance().raise<service_stop_begin>(function_name,
+                                                     "s3_provider");
   base_provider::stop();
-  event_system::instance().raise<service_stop_end>("s3_provider");
+  event_system::instance().raise<service_stop_end>(function_name,
+                                                   "s3_provider");
 }
 
 auto s3_provider::upload_file_impl(const std::string &api_path,

repertory/librepertory/src/providers/sia/sia_provider.cpp

@@ -48,8 +48,8 @@ namespace {
   return cfg.bucket;
 }
 
-[[nodiscard]] auto get_last_modified(const nlohmann::json &obj)
-    -> std::uint64_t {
+[[nodiscard]] auto
+get_last_modified(const nlohmann::json &obj) -> std::uint64_t {
   try {
     return repertory::s3_provider::convert_api_date(
         obj["modTime"].get<std::string>());
@@ -63,9 +63,8 @@ namespace repertory {
 sia_provider::sia_provider(app_config &config, i_http_comm &comm)
     : base_provider(config, comm) {}
 
-auto sia_provider::create_directory_impl(const std::string &api_path,
-                                         api_meta_map & /* meta */)
-    -> api_error {
+auto sia_provider::create_directory_impl(
+    const std::string &api_path, api_meta_map & /* meta */) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   curl::requests::http_put_file put_file{};
@@ -139,9 +138,8 @@ auto sia_provider::get_directory_item_count(const std::string &api_path) const
   return 0U;
 }
 
-auto sia_provider::get_directory_items_impl(const std::string &api_path,
-                                            directory_item_list &list) const
-    -> api_error {
+auto sia_provider::get_directory_items_impl(
+    const std::string &api_path, directory_item_list &list) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   json object_list{};
@@ -199,8 +197,8 @@ auto sia_provider::get_directory_items_impl(const std::string &api_path,
   return api_error::success;
 }
 
-auto sia_provider::get_file(const std::string &api_path, api_file &file) const
-    -> api_error {
+auto sia_provider::get_file(const std::string &api_path,
+                            api_file &file) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   try {
@@ -237,9 +235,8 @@ auto sia_provider::get_file(const std::string &api_path, api_file &file) const
   return api_error::error;
 }
 
-auto sia_provider::get_file_list(api_file_list &list,
-                                 std::string & /* marker */) const
-    -> api_error {
+auto sia_provider::get_file_list(
+    api_file_list &list, std::string & /* marker */) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   using dir_func = std::function<api_error(std::string api_path)>;
@@ -443,8 +440,8 @@ auto sia_provider::get_total_drive_space() const -> std::uint64_t {
   return 0U;
 }
 
-auto sia_provider::is_directory(const std::string &api_path, bool &exists) const
-    -> api_error {
+auto sia_provider::is_directory(const std::string &api_path,
+                                bool &exists) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   try {
@@ -476,8 +473,8 @@ auto sia_provider::is_directory(const std::string &api_path, bool &exists) const
   return api_error::error;
 }
 
-auto sia_provider::is_file(const std::string &api_path, bool &exists) const
-    -> api_error {
+auto sia_provider::is_file(const std::string &api_path,
+                           bool &exists) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   try {
@@ -744,17 +741,25 @@ auto sia_provider::rename_file(const std::string &from_api_path,
 
 auto sia_provider::start(api_item_added_callback api_item_added,
                          i_file_manager *mgr) -> bool {
-  event_system::instance().raise<service_start_begin>("sia_provider");
+  REPERTORY_USES_FUNCTION_NAME();
+
+  event_system::instance().raise<service_start_begin>(function_name,
+                                                      "sia_provider");
   sia_config_ = get_config().get_sia_config();
   auto ret = base_provider::start(api_item_added, mgr);
-  event_system::instance().raise<service_start_end>("sia_provider");
+  event_system::instance().raise<service_start_end>(function_name,
+                                                    "sia_provider");
   return ret;
 }
 
 void sia_provider::stop() {
-  event_system::instance().raise<service_stop_begin>("sia_provider");
+  REPERTORY_USES_FUNCTION_NAME();
+
+  event_system::instance().raise<service_stop_begin>(function_name,
+                                                     "sia_provider");
   base_provider::stop();
-  event_system::instance().raise<service_stop_end>("sia_provider");
+  event_system::instance().raise<service_stop_end>(function_name,
+                                                   "sia_provider");
 }
 
 auto sia_provider::upload_file_impl(const std::string &api_path,

repertory/librepertory/src/rpc/server/server.cpp

@@ -146,7 +146,7 @@ void server::start() {
     return;
   }
 
-  event_system::instance().raise<service_start_begin>("server");
+  event_system::instance().raise<service_start_begin>(function_name, "server");
 
   server_ = std::make_unique<httplib::Server>();
 
@@ -185,16 +185,18 @@ void server::start() {
 
   server_thread_ = std::make_unique<std::thread>(
       [this]() { server_->listen("127.0.0.1", config_.get_api_port()); });
-  event_system::instance().raise<service_start_end>("server");
+  event_system::instance().raise<service_start_end>(function_name, "server");
 }
 
 void server::stop() {
+  REPERTORY_USES_FUNCTION_NAME();
+
   unique_mutex_lock lock(start_stop_mutex_);
   if (not server_thread_) {
     return;
   }
 
-  event_system::instance().raise<service_stop_begin>("server");
+  event_system::instance().raise<service_stop_begin>(function_name, "server");
 
   server_->stop();
 
@@ -209,6 +211,6 @@ void server::stop() {
   server_.reset();
   lock.unlock();
 
-  event_system::instance().raise<service_stop_end>("server");
+  event_system::instance().raise<service_stop_end>(function_name, "server");
 }
 } // namespace repertory

repertory/librepertory/src/utils/polling.cpp

@@ -97,12 +97,14 @@ void polling::set_callback(const polling_item &item) {
 }
 
 void polling::start(app_config *config) {
+  REPERTORY_USES_FUNCTION_NAME();
+
   mutex_lock lock(start_stop_mutex_);
   if (frequency_threads_.at(0U)) {
     return;
   }
 
-  event_system::instance().raise<service_start_begin>("polling");
+  event_system::instance().raise<service_start_begin>(function_name, "polling");
   config_ = config;
   stop_requested_ = false;
 
@@ -141,16 +143,18 @@ void polling::start(app_config *config) {
         this->frequency_thread([]() -> std::uint32_t { return 1U; },
                                frequency::second);
       });
-  event_system::instance().raise<service_start_end>("polling");
+  event_system::instance().raise<service_start_end>(function_name, "polling");
 }
 
 void polling::stop() {
+  REPERTORY_USES_FUNCTION_NAME();
+
   mutex_lock lock(start_stop_mutex_);
   if (not frequency_threads_.at(0U)) {
     return;
   }
 
-  event_system::instance().raise<service_stop_begin>("polling");
+  event_system::instance().raise<service_stop_begin>(function_name, "polling");
 
   stop_requested_ = true;
 
@@ -169,6 +173,6 @@ void polling::stop() {
     thread.reset();
   }
 
-  event_system::instance().raise<service_stop_end>("polling");
+  event_system::instance().raise<service_stop_end>(function_name, "polling");
 }
 } // namespace repertory

repertory/librepertory/src/utils/single_thread_service_base.cpp

@@ -40,6 +40,8 @@ void single_thread_service_base::notify_all() const {
 }
 
 void single_thread_service_base::start() {
+  REPERTORY_USES_FUNCTION_NAME();
+
   mutex_lock lock(mtx_);
   if (thread_) {
     return;
@@ -48,8 +50,10 @@ void single_thread_service_base::start() {
   stop_requested_ = false;
   on_start();
   thread_ = std::make_unique<std::thread>([this]() {
-    event_system::instance().raise<service_start_begin>(service_name_);
-    event_system::instance().raise<service_start_end>(service_name_);
+    event_system::instance().raise<service_start_begin>(function_name,
+                                                        service_name_);
+    event_system::instance().raise<service_start_end>(function_name,
+                                                      service_name_);
     while (not get_stop_requested()) {
       service_function();
     }
@@ -57,12 +61,15 @@ void single_thread_service_base::start() {
 }
 
 void single_thread_service_base::stop() {
+  REPERTORY_USES_FUNCTION_NAME();
+
   unique_mutex_lock lock(mtx_);
   if (not thread_) {
     return;
   }
 
-  event_system::instance().raise<service_stop_begin>(service_name_);
+  event_system::instance().raise<service_stop_begin>(function_name,
+                                                     service_name_);
 
   stop_requested_ = true;
 
@@ -77,6 +84,7 @@ void single_thread_service_base::stop() {
 
   on_stop();
 
-  event_system::instance().raise<service_stop_end>(service_name_);
+  event_system::instance().raise<service_stop_end>(function_name,
+                                                   service_name_);
 }
 } // namespace repertory