librats 0.7.1 → 0.8.0

package/native-src/src/librats_statistic.cpp

@@ -0,0 +1,97 @@
+#include "librats.h"
+#include "librats_log_macros.h"
+#include "os.h"
+
+namespace librats {
+
+    
+// =========================================================================
+// Statistics and Information
+// =========================================================================
+
+nlohmann::json RatsClient::get_connection_statistics() const {
+    nlohmann::json stats;
+    
+    {
+        std::lock_guard<std::mutex> lock(peers_mutex_);
+        stats["total_peers"] = peers_.size();
+        stats["validated_peers"] = get_peer_count_unlocked();
+        stats["max_peers"] = max_peers_;
+    }
+    
+    stats["running"] = is_running();
+    stats["listen_port"] = listen_port_;
+    stats["our_peer_id"] = get_our_peer_id();
+    stats["encryption_enabled"] = is_encryption_enabled();
+    
+    // DHT statistics
+    if (dht_client_ && dht_client_->is_running()) {
+        stats["dht_running"] = true;
+        stats["dht_routing_table_size"] = get_dht_routing_table_size();
+    } else {
+        stats["dht_running"] = false;
+    }
+    
+    // mDNS statistics
+    stats["mdns_running"] = is_mdns_running();
+    
+    // Reconnection statistics
+    {
+        std::lock_guard<std::mutex> lock(reconnect_mutex_);
+        stats["reconnect_enabled"] = reconnect_config_.enabled;
+        stats["reconnect_queue_size"] = reconnect_queue_.size();
+        stats["reconnect_max_attempts"] = reconnect_config_.max_attempts;
+    }
+    
+    return stats;
+}
+
+// Cached formatting helpers - computed once on first use
+static const std::string& get_box_separator() {
+    static const std::string separator = supports_unicode() ? 
+        "════════════════════════════════════════════════════════════════════" :
+        "=====================================================================";
+    return separator;
+}
+
+static const std::string& get_box_vertical() {
+    static const std::string vertical = supports_unicode() ? "│" : "|";
+    return vertical;
+}
+
+static const std::string& get_checkmark() {
+    static const std::string checkmark = supports_unicode() ? "✓" : "[*]";
+    return checkmark;
+}
+
+void RatsClient::log_handshake_completion_unlocked(const RatsPeer& peer) {
+    // Calculate connection duration
+    auto now = std::chrono::steady_clock::now();
+    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(now - peer.connected_at);
+    
+    // Get current peer count (assumes peers_mutex_ is already locked)
+    int current_peer_count = get_peer_count_unlocked();
+    
+    // Create visually appealing log output
+    std::string connection_type = peer.is_outgoing ? "OUTGOING" : "INCOMING";
+    const std::string& separator = get_box_separator();
+    const std::string& vertical = get_box_vertical();
+    const std::string& checkmark = get_checkmark();
+    
+    LOG_CLIENT_INFO("");
+    LOG_CLIENT_INFO(separator);
+    LOG_CLIENT_INFO(checkmark << " HANDSHAKE COMPLETED - NEW PEER CONNECTED");
+    LOG_CLIENT_INFO(separator);
+    LOG_CLIENT_INFO(vertical << " Peer ID       : " << peer.peer_id);
+    LOG_CLIENT_INFO(vertical << " Address       : " << peer.ip << ":" << peer.port);
+    LOG_CLIENT_INFO(vertical << " Connection    : " << connection_type);
+    LOG_CLIENT_INFO(vertical << " Protocol Ver. : " << peer.version);
+    LOG_CLIENT_INFO(vertical << " Socket        : " << peer.socket);
+    LOG_CLIENT_INFO(vertical << " Duration      : " << duration.count() << "ms");
+    LOG_CLIENT_INFO(vertical << " Network Peers : " << current_peer_count << "/" << max_peers_);
+    
+    LOG_CLIENT_INFO(separator);
+    LOG_CLIENT_INFO("");
+}
+
+}

package/native-src/src/logger.h

@@ -100,6 +100,17 @@ public:
         max_log_files_ = count;
     }
     
+    // Rotate on startup configuration
+    void set_rotate_on_startup(bool enabled) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        rotate_on_startup_ = enabled;
+    }
+    
+    bool is_rotate_on_startup_enabled() const {
+        std::lock_guard<std::mutex> lock(mutex_);
+        return rotate_on_startup_;
+    }
+    
     // Get current file logging status
     bool is_file_logging_enabled() const {
         std::lock_guard<std::mutex> lock(mutex_);
@@ -178,7 +189,8 @@ public:
 private:
     Logger() : min_level_(LogLevel::INFO), colors_enabled_(true), timestamps_enabled_(true),
                console_logging_enabled_(true), file_logging_enabled_(false), 
-               max_log_file_size_(10 * 1024 * 1024), max_log_files_(5), current_file_size_(0) {
+               max_log_file_size_(10 * 1024 * 1024), max_log_files_(5), current_file_size_(0),
+               rotate_on_startup_(false), startup_rotation_done_(false) {
         // Check if we're outputting to a terminal
         is_terminal_ = isatty(fileno(stdout));
         
@@ -330,6 +342,19 @@ private:
             }
         }
         
+        // Perform rotation on startup if enabled and not yet done this session
+        if (rotate_on_startup_ && !startup_rotation_done_) {
+            // Check if the log file exists and has content
+            if (file_exists(log_file_path_.c_str())) {
+                std::ifstream check_file(log_file_path_, std::ios::ate);
+                if (check_file.is_open() && check_file.tellg() > 0) {
+                    check_file.close();
+                    rotate_log_files_impl();
+                }
+            }
+            startup_rotation_done_ = true;
+        }
+        
         log_file_.open(log_file_path_, std::ios::app);
         if (log_file_.is_open()) {
             // Get current file size
@@ -350,6 +375,16 @@ private:
         if (log_file_path_.empty() || max_log_files_ <= 0) return;
         
         close_log_file();
+        rotate_log_files_impl();
+        
+        // Reopen the log file (new empty file)
+        open_log_file();
+    }
+    
+    // Internal rotation implementation - does not close/open files
+    // Called directly when we need to rotate before opening (e.g., on startup)
+    void rotate_log_files_impl() {
+        if (log_file_path_.empty() || max_log_files_ <= 0) return;
         
         // Move existing log files
         for (int i = max_log_files_ - 1; i >= 1; i--) {
@@ -368,9 +403,6 @@ private:
         // Move current log file to .1
         std::string backup_name = log_file_path_ + ".1";
         std::rename(log_file_path_.c_str(), backup_name.c_str());
-        
-        // Reopen the log file (new empty file)
-        open_log_file();
     }
     
     mutable std::mutex mutex_;
@@ -389,6 +421,10 @@ private:
     size_t max_log_file_size_;
     int max_log_files_;
     size_t current_file_size_;
+    
+    // Rotate on startup members
+    bool rotate_on_startup_;
+    bool startup_rotation_done_;  // Tracks if we've already done startup rotation for this session
 };
 
 } // namespace librats