@alteriom/painlessmesh 1.9.19 → 1.10.0

package/src/painlessmesh/mesh.hpp

@@ -344,7 +344,7 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
       (*conn)->close();
       this->eraseClosedConnections();
     }
-    plugin::PackageHandler<T>::stop();
+    plugin::PackageHandler<T>::stop(mScheduler);
 
     newConnectionCallbacks.clear();
     droppedConnectionCallbacks.clear();
@@ -352,6 +352,7 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
 
     if (!isExternalScheduler) {
       delete mScheduler;
+      mScheduler = nullptr;
     }
   }
 
@@ -876,7 +877,11 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
    * @return Number of available gateways
    */
   size_t getGatewayCount() {
-    return getNodesWithInternet().size();
+    size_t count = 0;
+    for (const auto& bridge : knownBridges) {
+      if (bridge.isHealthy(bridgeTimeoutMs) && bridge.internetConnected) count++;
+    }
+    return count;
   }
 
   /**
@@ -1005,6 +1010,8 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
     using namespace logger;
     if (bridgeCleanupTask != nullptr) {
       bridgeCleanupTask->disable();
+      // Task remains in scheduler (disabled) — negligible overhead.
+      // The scheduler will skip it on each cycle.
       bridgeCleanupTask = nullptr;
       Log(GENERAL, "disableBridgeCleanup(): Cleanup task disabled\n");
     }
@@ -1387,6 +1394,32 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
     internetRetryDelay = delayMs;
   }
 
+  /**
+   * Configure TCP connection retry behaviour
+   *
+   * Lets latency-sensitive, high-reliability or battery-powered deployments
+   * pick their own retry envelope. Values outside safe operating bounds are
+   * clamped - see painlessmesh::tcp::clampTcpRetryConfig(). Read the applied
+   * (post-clamp) values back with getTcpRetryConfig().
+   *
+   * The defaults reproduce the previous hardcoded behaviour exactly, so
+   * existing sketches that never call this see no change.
+   *
+   * @param config Retry parameters to apply
+   */
+  void setTcpRetryConfig(const painlessmesh::tcp::TcpRetryConfig &config) {
+    tcpRetryConfig = painlessmesh::tcp::clampTcpRetryConfig(config);
+  }
+
+  /**
+   * Get the active TCP retry configuration
+   *
+   * @return The configuration currently in effect, after clamping
+   */
+  painlessmesh::tcp::TcpRetryConfig getTcpRetryConfig() const {
+    return tcpRetryConfig;
+  }
+
   /**
    * Get number of pending Internet requests
    *
@@ -1405,10 +1438,13 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
   bool cancelInternetRequest(uint32_t messageId) {
     auto it = pendingInternetRequests.find(messageId);
     if (it != pendingInternetRequests.end()) {
-      if (it->second.callback) {
-        it->second.callback(false, 0, "Request cancelled");
-      }
+      auto callback = it->second.callback;
       pendingInternetRequests.erase(it);
+      if (callback) {
+        this->addTask([callback]() {
+          callback(false, 0, "Request cancelled");
+        });
+      }
       Log(logger::GENERAL, "cancelInternetRequest(): Cancelled msgId=%u\n", messageId);
       return true;
     }
@@ -1541,19 +1577,22 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
       // These errors indicate infrastructure issues that won't be fixed by retrying:
       // - "Router has no internet access" - WAN connection down
       // - "Gateway WiFi not connected" - ESP not associated with WiFi
+      // - "Captive portal detected" - Router requires web authentication
       // Use find() for std::string (test env) or indexOf() for Arduino String
-      bool routerError = false, wifiError = false;
+      bool routerError = false, wifiError = false, captivePortalError = false;
       #if defined(PAINLESSMESH_BOOST)
         // Test environment: TSTRING is std::string, use find()
         routerError = (ack.error.find("Router has no internet") != std::string::npos);
         wifiError = (ack.error.find("Gateway WiFi not connected") != std::string::npos);
+        captivePortalError = (ack.error.find("Captive portal detected") != std::string::npos);
       #else
         // Arduino environment: TSTRING is String, use indexOf()
         routerError = (ack.error.indexOf("Router has no internet") >= 0);
         wifiError = (ack.error.indexOf("Gateway WiFi not connected") >= 0);
+        captivePortalError = (ack.error.indexOf("Captive portal detected") >= 0);
       #endif
       
-      if (routerError || wifiError) {
+      if (routerError || wifiError || captivePortalError) {
         isGatewayConnectivityError = true;
         Log(COMMUNICATION, "handleGatewayAck(): Gateway connectivity error detected (non-retryable): %s\n", 
             ack.error.c_str());
@@ -1951,8 +1990,8 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
         return rtcTime;
       }
     }
-    // Fallback to mesh time (microseconds)
-    return this->getNodeTime();
+    // Fallback to mesh time (microseconds), converted to seconds for consistency
+    return getNodeTime() / 1000000;
   }
 
   /**
@@ -2047,16 +2086,34 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
   //
   
   /**
-   * Enable or disable message queueing for offline mode
-   * 
-   * When enabled, messages can be queued when Internet is unavailable
-   * and automatically flushed when connection is restored.
-   * 
+   * Enable or disable the manual message queue for offline mode
+   *
+   * When enabled, allocates a `MessageQueue` that your application can
+   * push into while an upstream (MQTT/HTTP/etc.) is unreachable. The
+   * mesh does NOT flush the queue automatically and does NOT observe
+   * connectivity changes — the app is responsible for detecting when
+   * to drain it via `flushMessageQueue()` + `removeQueuedMessage()`.
+   *
+   * Wire it to your own connectivity signal, for example
+   * `onLocalInternetChanged` on the bridge node or
+   * `onBridgeStatusChanged` on downstream nodes.
+   *
    * @param enabled True to enable queueing, false to disable
    * @param maxSize Maximum number of messages in queue (default 1000)
-   * 
+   *
    * \code
    * mesh.enableMessageQueue(true, 500);  // Enable with 500 message capacity
+   *
+   * mesh.onLocalInternetChanged([&mesh](bool available) {
+   *   if (available) {
+   *     auto messages = mesh.flushMessageQueue();
+   *     for (auto& msg : messages) {
+   *       if (sendToCloud(msg.payload, msg.destination)) {
+   *         mesh.removeQueuedMessage(msg.id);
+   *       }
+   *     }
+   *   }
+   * });
    * \endcode
    */
   void enableMessageQueue(bool enabled, uint32_t maxSize = 1000) {
@@ -2071,11 +2128,13 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
   }
   
   /**
-   * Queue a message with priority for later delivery
-   * 
-   * Use this to queue critical messages when Internet is unavailable.
-   * Messages are automatically delivered when connection is restored.
-   * 
+   * Queue a message with priority for later manual delivery
+   *
+   * Use this to buffer critical messages when your upstream
+   * (MQTT/HTTP/etc.) is unavailable. The library does NOT deliver these
+   * on its own — your app must call `flushMessageQueue()` and
+   * `removeQueuedMessage()` once its own connectivity check clears.
+   *
    * @param payload Message content to queue
    * @param destination Optional destination metadata (e.g., MQTT topic, HTTP endpoint)
    * @param priority Message priority (default: PRIORITY_NORMAL)
@@ -2102,16 +2161,14 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
   }
   
   /**
-   * Flush all queued messages
-   * 
-   * Attempts to send all queued messages. This is typically called
-   * automatically when Internet connection is restored, but can be
-   * called manually.
-   * 
-   * Note: This returns the messages for the application to send.
-   * The application is responsible for actually transmitting them
-   * and calling removeQueuedMessage() when successful.
-   * 
+   * Return a snapshot of all queued messages for manual delivery
+   *
+   * This does NOT transmit anything and does NOT clear the queue. The
+   * application is responsible for actually sending each message and
+   * calling `removeQueuedMessage(id)` for each one that succeeded.
+   * Messages left in the queue remain available for retry on the next
+   * flush.
+   *
    * @return Vector of queued messages to send
    * 
    * \code
@@ -2323,7 +2380,7 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
     auto tree = this->asNodeTree();
     
     // BFS to find hop count
-    std::queue<std::pair<uint32_t, uint8_t>> queue;  // (nodeId, hops)
+    std::queue<std::pair<uint32_t, uint16_t>> queue;  // (nodeId, hops)
     std::set<uint32_t> visited;
     
     // Start from this node
@@ -2335,7 +2392,7 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
       queue.pop();
       
       uint32_t currentNode = current.first;
-      uint8_t hops = current.second;
+      uint16_t hops = current.second;
       
       // Found the target
       if (currentNode == nodeId) {
@@ -2349,7 +2406,7 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
         for (auto neighbor : neighbors) {
           if (visited.find(neighbor) == visited.end()) {
             visited.insert(neighbor);
-            queue.push({neighbor, static_cast<uint8_t>(hops + 1)});
+            queue.push({neighbor, static_cast<uint16_t>(hops + 1)});
           }
         }
       }
@@ -2478,7 +2535,8 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
     // Reconstruct path from parent map
     if (found) {
       uint32_t current = nodeId;
-      while (current != 0) {
+      size_t maxIter = parent.size() + 1;
+      while (current != 0 && maxIter-- > 0) {
         path.insert(path.begin(), current);
         current = parent[current];
       }
@@ -2523,7 +2581,7 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
     uint32_t totalMessagesDropped = 0;
     uint32_t totalLatency = 0;
     uint32_t latencySampleCount = 0;
-    int8_t sumRSSI = 0;
+    int32_t sumRSSI = 0;
     int8_t minRSSI = 0;
     int8_t maxRSSI = -127;
     uint32_t rssiCount = 0;
@@ -2820,76 +2878,6 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
     return lastBridgeChange;
   }
 
-  /**
-   * Get Internet path to specific node
-   * 
-   * Returns the routing path from the specified node to the Internet bridge.
-   * Path includes all intermediate nodes from source to bridge.
-   * 
-   * \code
-   * auto path = mesh.getInternetPath(targetNodeId);
-   * Serial.print("Path to Internet: ");
-   * for (auto nodeId : path) {
-   *   Serial.printf("%u -> ", nodeId);
-   * }
-   * Serial.println("Internet");
-   * \endcode
-   * 
-   * @param nodeId Node to find path from
-   * @return Vector of node IDs representing the path (empty if no path)
-   */
-  std::vector<uint32_t> getInternetPath(uint32_t nodeId) {
-    std::vector<uint32_t> path;
-    
-    // Get primary bridge
-    auto primaryBridge = this->getPrimaryBridge();
-    if (primaryBridge == nullptr) {
-      Log(logger::GENERAL, "getInternetPath(): No bridge available\n");
-      return path;
-    }
-    
-    // If requesting path for the bridge itself
-    if (nodeId == primaryBridge->nodeId) {
-      path.push_back(nodeId);
-      return path;
-    }
-    
-    // Start with the target node
-    path.push_back(nodeId);
-    
-    // For now, simplified routing: if direct connection, add bridge
-    // TODO: Implement proper multi-hop path discovery
-    if (this->isConnected(primaryBridge->nodeId)) {
-      path.push_back(primaryBridge->nodeId);
-    }
-    
-    return path;
-  }
-
-  /**
-   * Get bridge node ID for specific node
-   * 
-   * Returns the bridge node ID that the specified node should use to reach Internet.
-   * For most cases, this is the primary bridge.
-   * 
-   * \code
-   * uint32_t bridgeId = mesh.getBridgeForNodeId(targetNodeId);
-   * if (bridgeId != 0) {
-   *   Serial.printf("Node %u uses bridge %u\n", targetNodeId, bridgeId);
-   * }
-   * \endcode
-   * 
-   * @param nodeId Node to find bridge for
-   * @return Bridge node ID, or 0 if no bridge available
-   */
-  uint32_t getBridgeForNodeId(uint32_t nodeId) {
-    auto primaryBridge = this->getPrimaryBridge();
-    if (primaryBridge != nullptr) {
-      return primaryBridge->nodeId;
-    }
-    return 0;
-  }
-
   /**
    * Export topology as DOT format (Graphviz)
    * 
@@ -3250,7 +3238,7 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
   bool isExternalScheduler = false;
 
   /// Is the node a root node
-  bool shouldContainRoot;
+  bool shouldContainRoot = false;
 
   Scheduler *mScheduler;
 
@@ -3265,7 +3253,7 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
    */
   bool semaphoreTake() {
 #ifdef ESP32
-    return xSemaphoreTake(xSemaphore, (TickType_t)100) == pdTRUE;  // Was 10
+    return xSemaphoreTake(xSemaphore, (TickType_t)1000) == pdTRUE;
 #else
     return true;
 #endif
@@ -3318,6 +3306,13 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
   uint32_t internetRetryDelay = 1000;        // Default 1 second base delay
   bool sendToInternetEnabled = false;
 
+  // TCP connect retry parameters, see setTcpRetryConfig().
+  // Public because tcp::connect<Connection, wifi::Mesh> reads it but is NOT a
+  // friend: the friend declaration below names connect<T, Mesh<T>>, whereas
+  // wifi::Mesh::tcpConnect() instantiates connect<Connection, wifi::Mesh> - a
+  // different specialisation. Same reason as the public: sections above.
+  painlessmesh::tcp::TcpRetryConfig tcpRetryConfig;
+
   friend T;
   friend void onDataCb(void *, AsyncClient *, void *, size_t);
   friend void tcpSentCb(void *, AsyncClient *, size_t, uint32_t);

package/src/painlessmesh/message_queue.hpp

@@ -73,29 +73,40 @@ struct QueueStats {
 typedef std::function<void(QueueState state, uint32_t messageCount)> queueStateChangedCallback_t;
 
 /**
- * Message Queue for offline/Internet-unavailable mode
- * 
+ * Manual priority buffer for offline / Internet-unavailable mode
+ *
+ * This is a *storage* container only. It does NOT transmit anything on
+ * its own: painlessMesh will not enqueue, flush, or deliver messages
+ * automatically, and there is no connectivity-restored trigger inside
+ * the library. The application owns the send loop — enqueue when your
+ * upstream (MQTT/HTTP/etc.) is down, drain via `getMessages()` /
+ * `mesh.flushMessageQueue()` and `remove()` / `mesh.removeQueuedMessage()`
+ * when your own connectivity check tells you it is safe to resend.
+ *
  * Provides priority-based message queueing with support for:
- * - Priority levels (CRITICAL messages never dropped)
+ * - Priority levels (CRITICAL messages evicted last, but may still be dropped
+ *   if the queue is full and all entries are CRITICAL)
  * - Queue size limits with intelligent eviction
  * - Statistics tracking
  * - State change callbacks
- * 
+ *
  * Example usage:
  * \code
  * MessageQueue queue(1000);  // Max 1000 messages
- * 
- * // Queue a critical message
+ *
+ * // Queue a critical message while upstream is offline
  * uint32_t msgId = queue.enqueue(PRIORITY_CRITICAL, "alarm_data", "mqtt://...");
- * 
+ *
  * // Get queue size
  * uint32_t size = queue.size();
- * 
- * // Get all messages (for sending)
- * std::vector<QueuedMessage> messages = queue.getMessages();
- * 
- * // Remove sent message
- * queue.remove(msgId);
+ *
+ * // When your app detects the upstream is back, drain manually:
+ * auto messages = queue.getMessages();
+ * for (auto& msg : messages) {
+ *   if (sendToCloud(msg.payload, msg.destination)) {
+ *     queue.remove(msg.id);
+ *   }
+ * }
  * \endcode
  */
 class MessageQueue {
@@ -104,9 +115,8 @@ public:
    * Constructor
    * @param maxSize Maximum number of messages in queue
    */
-  explicit MessageQueue(uint32_t maxSize = 1000) 
+  explicit MessageQueue(uint32_t maxSize = 1000)
     : maxQueueSize(maxSize), nextMessageId(1) {
-    messages.reserve(maxSize);
   }
   
   /**

package/src/painlessmesh/metrics.hpp

@@ -33,8 +33,7 @@ class Timer {
 
   uint32_t elapsed_us() const {
 #ifdef ESP32
-    return static_cast<uint32_t>((esp_timer_get_time() - start_time_us_) /
-                                 1000);
+    return static_cast<uint32_t>(esp_timer_get_time() - start_time_us_);
 #else
     return elapsed_ms() * 1000;  // Fallback to millisecond precision
 #endif
@@ -58,266 +57,7 @@ class Timer {
 #endif
 };
 
-/**
- * Message statistics tracking
- */
-struct MessageStats {
-  uint32_t messages_sent = 0;
-  uint32_t messages_received = 0;
-  uint32_t messages_dropped = 0;
-  uint32_t messages_retransmitted = 0;
-  uint32_t bytes_sent = 0;
-  uint32_t bytes_received = 0;
-  uint32_t parse_errors = 0;
-  uint32_t validation_errors = 0;
-
-  // Latency tracking
-  uint32_t min_latency_ms = UINT32_MAX;
-  uint32_t max_latency_ms = 0;
-  uint32_t total_latency_ms = 0;
-  uint32_t latency_samples = 0;
-
-  void record_sent_message(size_t bytes) {
-    messages_sent++;
-    bytes_sent += bytes;
-  }
-
-  void record_received_message(size_t bytes) {
-    messages_received++;
-    bytes_received += bytes;
-  }
-
-  void record_dropped_message() { messages_dropped++; }
-
-  void record_retransmission() { messages_retransmitted++; }
-
-  void record_parse_error() { parse_errors++; }
-
-  void record_validation_error() { validation_errors++; }
-
-  void record_latency(uint32_t latency_ms) {
-    min_latency_ms = std::min(min_latency_ms, latency_ms);
-    max_latency_ms = std::max(max_latency_ms, latency_ms);
-    total_latency_ms += latency_ms;
-    latency_samples++;
-  }
-
-  uint32_t average_latency_ms() const {
-    return latency_samples > 0 ? total_latency_ms / latency_samples : 0;
-  }
-
-  double throughput_bps() const {
-#ifdef ARDUINO
-    uint32_t uptime_s = millis() / 1000;
-#else
-    // For non-Arduino builds, use a simpler approach or disable this feature
-    uint32_t uptime_s = 1;  // Avoid division by zero
-#endif
-    return uptime_s > 0 ? (bytes_sent + bytes_received) * 8.0 / uptime_s : 0.0;
-  }
-
-  double packet_loss_rate() const {
-    uint32_t total_attempted = messages_sent + messages_dropped;
-    return total_attempted > 0
-               ? static_cast<double>(messages_dropped) / total_attempted
-               : 0.0;
-  }
-
-  void reset() { *this = MessageStats{}; }
-};
-
-/**
- * Memory usage tracking
- */
-struct MemoryStats {
-  uint32_t heap_free = 0;
-  uint32_t heap_max_alloc = 0;
-  uint32_t heap_min_free = UINT32_MAX;
-  uint32_t psram_free = 0;
-  uint32_t stack_high_water = 0;
-
-  void update() {
-#ifdef ESP32
-    heap_free = ESP.getFreeHeap();
-    heap_max_alloc = ESP.getMaxAllocHeap();
-    heap_min_free = std::min(heap_min_free, heap_free);
-
-#ifdef BOARD_HAS_PSRAM
-    psram_free = ESP.getFreePsram();
-#endif
-
-    stack_high_water = uxTaskGetStackHighWaterMark(NULL);
-#elif defined(ESP8266)
-    heap_free = ESP.getFreeHeap();
-    heap_max_alloc = ESP.getMaxFreeBlockSize();
-    heap_min_free = std::min(heap_min_free, heap_free);
-#endif
-  }
-
-  bool is_memory_critical() const {
-    return heap_free < 10000;  // Less than 10KB free is critical
-  }
-
-  bool is_memory_low() const {
-    return heap_free < 20000;  // Less than 20KB free is low
-  }
-};
-
-/**
- * Network topology metrics
- */
-struct TopologyStats {
-  uint32_t node_count = 0;
-  uint32_t connection_count = 0;
-  uint32_t max_hops = 0;
-  uint32_t connection_changes = 0;
-  uint32_t failed_connections = 0;
-
-  void record_topology_change(uint32_t nodes, uint32_t connections,
-                              uint32_t hops) {
-    node_count = nodes;
-    connection_count = connections;
-    max_hops = hops;
-    connection_changes++;
-  }
-
-  void record_failed_connection() { failed_connections++; }
-
-  double connection_stability() const {
-    return connection_changes > 0
-               ? 1.0 - static_cast<double>(failed_connections) /
-                           connection_changes
-               : 1.0;
-  }
-};
-
-/**
- * Comprehensive metrics collector
- */
-class MetricsCollector {
- public:
-  MetricsCollector() : start_time_(get_current_time()) {}
-
-  MessageStats& message_stats() { return message_stats_; }
-  MemoryStats& memory_stats() { return memory_stats_; }
-  TopologyStats& topology_stats() { return topology_stats_; }
-
-  const MessageStats& message_stats() const { return message_stats_; }
-  const MemoryStats& memory_stats() const { return memory_stats_; }
-  const TopologyStats& topology_stats() const { return topology_stats_; }
-
-  /**
-   * Update all metrics (call periodically)
-   */
-  void update() {
-    memory_stats_.update();
-    last_update_ = get_current_time();
-  }
-
-  /**
-   * Get uptime in seconds
-   */
-  uint32_t uptime_seconds() const {
-    return (get_current_time() - start_time_) / 1000;
-  }
-
-  /**
-   * Generate JSON status report
-   */
-  TSTRING generate_status_json() const {
-    TSTRING json = "{";
-    json += "\"uptime\":";
-    json += std::to_string(uptime_seconds());
-    json += ",";
-    json += "\"messages\":{";
-    json += "\"sent\":";
-    json += std::to_string(message_stats_.messages_sent);
-    json += ",";
-    json += "\"received\":";
-    json += std::to_string(message_stats_.messages_received);
-    json += ",";
-    json += "\"dropped\":";
-    json += std::to_string(message_stats_.messages_dropped);
-    json += ",";
-    json += "\"avg_latency\":";
-    json += std::to_string(message_stats_.average_latency_ms());
-    json += ",";
-    json += "\"throughput\":";
-    json += std::to_string(message_stats_.throughput_bps());
-    json += ",";
-    json += "\"packet_loss\":";
-    json += std::to_string(message_stats_.packet_loss_rate());
-    json += "},";
-    json += "\"memory\":{";
-    json += "\"heap_free\":";
-    json += std::to_string(memory_stats_.heap_free);
-    json += ",";
-    json += "\"heap_min\":";
-    json += std::to_string(memory_stats_.heap_min_free);
-    json += ",";
-    json += "\"critical\":";
-    json += (memory_stats_.is_memory_critical() ? "true" : "false");
-    json += "},";
-    json += "\"topology\":{";
-    json += "\"nodes\":";
-    json += std::to_string(topology_stats_.node_count);
-    json += ",";
-    json += "\"connections\":";
-    json += std::to_string(topology_stats_.connection_count);
-    json += ",";
-    json += "\"max_hops\":";
-    json += std::to_string(topology_stats_.max_hops);
-    json += ",";
-    json += "\"stability\":";
-    json += std::to_string(topology_stats_.connection_stability());
-    json += "}";
-    json += "}";
-    return json;
-  }
-
-  /**
-   * Reset all metrics
-   */
-  void reset() {
-    message_stats_.reset();
-    topology_stats_ = TopologyStats{};
-    start_time_ = get_current_time();
-  }
-
-  /**
-   * Check if metrics indicate performance issues
-   */
-  bool has_performance_issues() const {
-    return memory_stats_.is_memory_critical() ||
-           message_stats_.packet_loss_rate() > 0.1 ||     // > 10% packet loss
-           topology_stats_.connection_stability() < 0.8;  // < 80% stability
-  }
-
- private:
-  uint32_t get_current_time() const {
-#ifdef ARDUINO
-    return millis();
-#else
-    auto now = std::chrono::steady_clock::now();
-    auto duration = now.time_since_epoch();
-    return std::chrono::duration_cast<std::chrono::milliseconds>(duration)
-        .count();
-#endif
-  }
-
-  MessageStats message_stats_;
-  MemoryStats memory_stats_;
-  TopologyStats topology_stats_;
-  uint32_t start_time_;
-  uint32_t last_update_ = 0;
-};
-
-// Global metrics instance (optional, can be disabled)
-#ifdef PAINLESS_MESH_ENABLE_METRICS
-extern MetricsCollector global_metrics;
-#endif
-
 }  // namespace metrics
 }  // namespace painlessmesh
 
-#endif  // _PAINLESS_MESH_METRICS_HPP_
+#endif  // _PAINLESS_MESH_METRICS_HPP_