error_handler.hpp

Go to the documentation of this file.

/*
 * Copyright 2025 Jinwoo Sung
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
 
#include <atomic>
#include <functional>
#include <memory>
#include <mutex>
#include <string_view>
#include <unordered_map>
#include <vector>
 
#include "error_types.hpp"
#include "unilink/base/visibility.hpp"
 
namespace unilink {
namespace diagnostics {
 
class UNILINK_API ErrorHandler {
 public:
  using ErrorCallback = std::function<void(const ErrorInfo&)>;
 
  static ErrorHandler& instance();
  static ErrorHandler& default_handler();
 
  ErrorHandler();
  ~ErrorHandler();
 
  void report_error(const ErrorInfo& error);
 
  void register_callback(ErrorCallback callback);
 
  void clear_callbacks();
 
  void set_min_error_level(ErrorLevel level);
 
  ErrorLevel get_min_error_level() const;
 
  void set_enabled(bool enabled);
 
  bool is_enabled() const;
 
  ErrorStats get_error_stats() const;
 
  void reset_stats();
 
  std::vector<ErrorInfo> get_errors_by_component(std::string_view component) const;
 
  std::vector<ErrorInfo> get_recent_errors(size_t count = 10) const;
 
  bool has_errors(std::string_view component) const;
 
  size_t get_error_count(std::string_view component, ErrorLevel level) const;
 
 private:
  // Non-copyable, non-movable
  ErrorHandler(const ErrorHandler&) = delete;
  ErrorHandler& operator=(const ErrorHandler&) = delete;
  ErrorHandler(ErrorHandler&&) = delete;
  ErrorHandler& operator=(ErrorHandler&&) = delete;
 
  mutable std::mutex mutex_;
  std::vector<ErrorCallback> callbacks_;
  std::atomic<ErrorLevel> min_level_{ErrorLevel::INFO};
  std::atomic<bool> enabled_{true};
 
  // Statistics
  mutable std::mutex stats_mutex_;
  ErrorStats stats_;
  std::vector<ErrorInfo> recent_errors_;
  std::unordered_map<std::string, std::vector<ErrorInfo>> errors_by_component_;
 
  static constexpr size_t MAX_RECENT_ERRORS = 1000;
 
  void update_stats(const ErrorInfo& error);
  void notify_callbacks(const std::vector<ErrorCallback>& callbacks, const ErrorInfo& error);
  void add_to_recent_errors(const ErrorInfo& error);
  void add_to_component_errors(const ErrorInfo& error);
};
 
namespace error_reporting {
 
UNILINK_API void report_connection_error(std::string_view component, std::string_view operation,
                                         const boost::system::error_code& ec, bool retryable = true);
 
UNILINK_API void report_communication_error(std::string_view component, std::string_view operation,
                                            std::string_view message, bool retryable = false);
 
UNILINK_API void report_configuration_error(std::string_view component, std::string_view operation,
                                            std::string_view message);
 
UNILINK_API void report_memory_error(std::string_view component, std::string_view operation, std::string_view message);
 
UNILINK_API void report_system_error(std::string_view component, std::string_view operation, std::string_view message,
                                     const boost::system::error_code& ec = boost::system::error_code{});
 
UNILINK_API void report_warning(std::string_view component, std::string_view operation, std::string_view message);
 
UNILINK_API void report_info(std::string_view component, std::string_view operation, std::string_view message);
 
}  // namespace error_reporting
 
}  // namespace diagnostics
}  // namespace unilink