Tagged articles
heartbeat
71 articles · Page 1 of 1
The author details a week-long investigation into random microservice disconnections in a Spring Cloud Alibaba cluster, systematically ruling out memory, CPU, disk, network, Nacos server, and client versions before discovering a Linux kernel bug causing JVM hangs that silently dropped heartbeats, resolved by upgrading the kernel.
ArthasJVM hangJava microservices
0 likes · 8 min read

This article deep-dives into Nacos' dual role as service registry and config center, explaining its AP-based Distro protocol, heartbeat mechanisms, gRPC long-polling config push, @RefreshScope internals, deployment essentials, and eight common pitfalls with troubleshooting steps.
@RefreshScopeConfiguration CenterDistro Protocol
0 likes · 24 min read


liandkSep 30, 2026 · Cloud Native
This article provides a comprehensive troubleshooting guide for microservice registration discovery and gateway routing failures, covering 10 high-frequency Nacos faults, Eureka-specific issues, gateway routing problems, a step-by-step SOP, and production high-availability specifications to eliminate cascading outages.
CacheEurekaGateway
0 likes · 17 min read

This article details integrating Netty with Spring Boot to build a scalable TCP long-connection gateway, covering binary protocol design with length-field framing, heartbeat detection using IdleStateHandler, session management with Redis and local maps, single-node and Redis Pub/Sub cluster push mechanisms, and performance tuning tips including Epoll transport and thread pool isolation.
ClusterEpollGateway
0 likes · 25 min read

The article explains Multica's counter‑intuitive design where tasks assigned to Claude Code actually run on a local MacBook, detailing the runtime concept, daemon registration, heartbeat‑based liveness, and the poisoned mechanism that together let the server reliably discover and manage agents across machines.
AI toolingMulticaRuntime
0 likes · 9 min read

Even when a consumer process runs and logs normally, Kafka may deem it dead and trigger a rebalance because the poll interval exceeds max.poll.interval.ms, a situation known as ‘false dead’; this article explains the root cause and practical ways to prevent it.
ConsumerKafkaMultithreading
0 likes · 8 min read

This article dissects OpenClaw's agent architecture, detailing how the System Prompt, Skill modules, and Agent Loop interact, explaining PromptMode variations, safety rules, tool definitions, skill loading pipelines, heartbeat handling, sub‑agent spawning, silent replies, and the context engine that assembles messages for LLMs.
Context EngineLLMOpenClaw
0 likes · 17 min read

NanoBot demonstrates that a full‑featured, controllable AI agent can be built with roughly 4,000 lines of code by using a minimal runtime consisting of a MessageBus, an AgentLoop, a file‑based ContextBuilder, a registered ToolRegistry with JSON‑Schema validation, and lightweight Cron/Heartbeat mechanisms, offering a clear contrast to heavier frameworks like OpenClaw.
AI agentAgentLoopContextBuilder
0 likes · 22 min read

The article explains how distributed systems detect silently dead nodes using heartbeat mechanisms—both push and pull models—covers trade‑offs between interval and timeout, introduces advanced detectors like Cassandra's Φ, gossip protocols, and quorum rules, and shows real‑world implementations in Kubernetes and etcd.
CassandraKubernetesdistributed systems
0 likes · 12 min read

This guide explains the three core Markdown files—SOUL.md, USER.md, and MEMORY.md—plus Heartbeat and Cron systems, showing how to configure them together so OpenClaw behaves as a truly collaborative AI assistant rather than a generic chatbot.
AI agentMEMORY.mdMarkdown Configuration
0 likes · 12 min read

Moltbook is a pioneering AI‑only social platform that lets agents post, comment and like, built with a Next.js front‑end, RESTful API back‑end, semantic vector search, heartbeat checks, dual human/agent modes and strict rate‑limiting to encourage quality over quantity while addressing scalability and security challenges.
MoltbookNext.jsRESTful API
0 likes · 18 min read

This article explains smart‑socket’s extensible plugin architecture, detailing the Plugin and AbstractPlugin interfaces, and demonstrates how to integrate built‑in plugins such as SSL/TLS encryption, heartbeat detection, blacklist filtering, memory‑pool monitoring, traffic logging, socket option configuration, and idle‑state handling, while covering plugin ordering, custom development, performance considerations, and best‑practice recommendations.
BlacklistJavaSSL
0 likes · 13 min read

This article explains how periodic heartbeat messages enable distributed systems to detect node failures, choose appropriate intervals and timeouts, compare push and pull models, employ advanced detection algorithms like phi and gossip, and apply these concepts in real-world platforms such as Kubernetes, Cassandra, and etcd.
Failure DetectionSystem Monitoringdistributed systems
0 likes · 22 min read

This article explains how to design server‑side read/write idle detection and heartbeat mechanisms in a Mini‑Netty framework, covering the theory of heartbeats, idle event handling, a priority‑queue scheduler, and complete starter code with Java NIO examples.
Idle DetectionJavaNIO
0 likes · 14 min read

This article explains why tracking user online duration matters across IM, e‑learning, gaming, and SaaS platforms, and provides a detailed backend design using a heartbeat‑Redis cache, login/logout logging, and a hybrid approach, complete with data models and Java implementation examples.
RedisSession Managementheartbeat
0 likes · 7 min read

This article explains the principles and workflow of Nacos service registration, covering why dynamic service discovery is needed, how instances register, send heartbeats, and are deregistered, and includes code examples and diagrams to illustrate the process.
NacosService DiscoveryService Registration
0 likes · 4 min read

This article explains how WebSocket enables low‑latency, bidirectional communication for AI‑driven real‑time applications, covering its protocol basics, advantages, heartbeat mechanism, connection management challenges, security enhancements, and emerging trends such as WebTransport and integration with modern frameworks.
Frontend DevelopmentWebSocketheartbeat
0 likes · 6 min read

This article explores multiple in‑memory strategies—using a simple map with timers, per‑driver goroutine management, and especially a Go‑implemented timing wheel—to identify Uber drivers who haven’t reported for ten minutes, comparing their complexities, memory usage, and suitability for large‑scale systems.
GoIn-Memoryheartbeat
0 likes · 12 min read

This article explains how to wrap WebSocket in a reusable JavaScript/TypeScript class that provides automatic reconnection, heartbeat monitoring, event callbacks, connection state management, and graceful destruction, while also comparing WebSocket advantages over traditional HTTP polling for real‑time H5 applications.
JavaScriptRealtimeTypeScript
0 likes · 14 min read

This article explains the WebSocket protocol, its advantages over traditional Ajax polling, typical use cases, the standard WebSocket API, and provides complete JavaScript implementations of a heartbeat base class and an extensible Socket wrapper with reconnection logic.
JavaScriptNode.jsRealtime Communication
0 likes · 11 min read

This article analyzes the challenges of real-time, reliability, and message ordering in a customer service instant messaging system and presents solutions such as WebSocket adoption, ACK-based reliability, heartbeat mechanisms, and a structured message protocol to ensure efficient and stable communication.
ACK mechanismIM SystemReal-time Messaging
0 likes · 11 min read

This article explores Polaris‑Mesh’s server‑side health‑check mechanism, detailing how client heartbeat requests are received via gRPC, processed through Apiserver, Resource Auth Filter, Service, Healthcheck, and Checker Plugin, and how the system’s configuration, plugins, and time‑wheel ensure reliable instance health monitoring.
GoPolarisMeshhealth check
0 likes · 11 min read

This article explains how to build a WebSocket client that supports automatic reconnection after network loss and periodic heartbeat messages, provides a drop‑in API compatible with the native WebSocket interface, and includes complete TypeScript and JavaScript implementations with detailed code examples.
TypeScriptWebSocketfrontend
0 likes · 19 min read

This article explains Zookeeper's session management mechanism, detailing why TCP alone is insufficient for client liveness detection, how Zookeeper implements its own heartbeat protocol, and the internal data structures and algorithms—including expiryMap and SessionTracker—that efficiently track and expire sessions.
ConcurrencyJavaSession Management
0 likes · 12 min read

This article deep‑dives into Nacos as a service registry, explaining the differences between temporary and permanent instances, registration mechanisms across 1.x and 2.x versions, heartbeat and health‑check strategies, service discovery methods, data‑consistency models, and the underlying data model that powers Nacos clusters.
ConsistencyNacosgRPC
0 likes · 28 min read

This article explains why heartbeat detection is crucial for WebSocket connections, describes the underlying Ping/Pong mechanism, details server and client configuration parameters, and provides complete code examples for implementing reliable heartbeat and reconnection logic.
BackendPHPWebSocket
0 likes · 9 min read

This article walks through implementing three load‑balancing algorithms (random, round‑robin, weighted round‑robin) in Go, explains the weighted selection math with step‑by‑step examples, and presents two service‑liveness solutions—heartbeat via Docker/Kafka and HTTP health checks—complete with code snippets and deployment commands.
DockerGoKafka
0 likes · 9 min read

This article explains the Nacos architecture, the principles of service registration, how Spring Cloud integrates with Nacos for automatic registration, the implementation details of NacosServiceRegistry, heartbeat mechanisms, service address queries, and dynamic service discovery, providing a comprehensive guide for backend developers working with microservices.
NacosService Discoveryheartbeat
0 likes · 10 min read

This article explains Nacos's architecture, the principles of service registration and discovery, how Spring Cloud integrates Nacos through auto‑configuration and event listeners, and details the registration, heartbeat, and dynamic address update mechanisms used by Nacos servers and clients.
Consistent ProtocolNacosService Discovery
0 likes · 7 min read

This article explains how unstable network conditions cause TCP disconnections in video conferencing, and provides detailed guidance on TCP/IP heartbeat mechanisms, packet loss retransmission, socket keep‑alive configuration, libwebsockets integration, and non‑blocking connect timeout control with code examples.
SocketTCPWindows
0 likes · 21 min read

The article walks through the Kafka consumer heartbeat lifecycle, detailing how the HeartbeatThread is started, paused, and used to send heartbeat and LeaveGroup requests, how the GroupCoordinator validates and processes these requests, the client’s response handling, and the resulting state transitions illustrated with diagrams.
ConsumerGroupCoordinatorKafka
0 likes · 14 min read

This article explains Nacos's core components, the principles of service registration and health checking, how Spring Cloud integrates Nacos via ServiceRegistry and AutoServiceRegistration, the implementation details of NacosServiceRegistry, heartbeat mechanisms, and dynamic service address discovery using HostReactor.
Dynamic UpdatesNacosService Discovery
0 likes · 9 min read

This article explains the Nacos architecture, its components, and how Spring Cloud integrates with Nacos for service registration, health checking, and dynamic service discovery, detailing the underlying mechanisms, code implementations, and the role of heartbeats in maintaining service health.
NacosService Discoverycloud-native
0 likes · 8 min read

This article explains the problems caused by naive timer implementations in high‑concurrency RPC frameworks and introduces the timing‑wheel mechanism, illustrating its principles, multi‑level design, and practical applications such as request timeout, startup timeout, and heartbeat handling.
RPCheartbeattiming wheel
0 likes · 12 min read

This article explores how Eureka’s heartbeat mechanism works in microservice architectures, comparing it to the Tang dynasty tribute system, and details who sends the heartbeat, its interval, the sending process, server handling, and the actions performed after receipt, with code examples and thread‑pool configuration.
EurekaService Discoveryheartbeat
0 likes · 7 min read


ITPUBJun 21, 2022 · Backend Development
This article explains the Eureka heartbeat mechanism in microservice architectures, covering who sends the heartbeat, its scheduling interval, the request construction, server-side handling, and how the lease information is updated to determine service liveness.
EurekaJavaService Discovery
0 likes · 6 min read

This article explains how Eureka’s heartbeat mechanism works in microservice architectures, covering who sends the heartbeat, the scheduling interval, the request implementation, server-side handling, and the effect on service registration, using code examples and analogies to historical tribute systems.
EurekaJavadistributed systems
0 likes · 6 min read

This article explains the WebSocket handshake protocol, compares short‑polling, long‑polling, and WebSocket connections, and shares practical implementations in WeChat mini‑programs—including authentication, heartbeat, RTT simulation, compression, reconnection strategies, caching, and TCP_NODELAY tuning, complete with code examples.
WeChat Mini-ProgramWebSocketheartbeat
0 likes · 9 min read

This article explores various service health‑checking techniques in microservice environments, detailing how consumers, providers, and registration centers can identify unhealthy nodes through passive and active checks, heartbeat mechanisms, TCP connection monitoring, and registration‑center probing, while weighing trade‑offs in reliability, timeliness, and resource consumption.
Service Discoveryheartbeatnode monitoring
0 likes · 11 min read

This article explains the principles of time wheels, how Dubbo implements them for retry mechanisms and heartbeat scheduling, walks through the relevant source code, discusses performance considerations, and references related issues and improvements in both Dubbo and Netty.
DubboHashedWheelTimerJava
0 likes · 22 min read

This article explains the architecture of Nacos, its core components such as Provider/Consumer apps, Name Server, Nacos Server and Console, and details how Spring Cloud integrates with Nacos for service registration, heartbeat monitoring, dynamic address discovery, and the underlying Open API/SDK mechanisms.
NacosSpring Cloudcloud-native
0 likes · 7 min read

This guide explains why heartbeat detection is essential for long‑living TCP connections, describes the GatewayWorker architecture, and provides step‑by‑step server and client configurations—including PHP and JavaScript code—to reliably detect client disconnections in WebSocket applications.
BackendGatewayWorkerPHP
0 likes · 9 min read

This article explains Nacos's health‑check and heartbeat mechanism in detail, covering the client‑side heartbeat scheduling, metadata configuration, server‑side beat reception, instance health evaluation, and the periodic health‑check tasks that mark or remove unhealthy instances.
BackendNacosService Discovery
0 likes · 13 min read


JavaEdgeMay 6, 2021 · Backend Development
The article explains how network jitter can cause service registries to mistakenly drop providers, and presents heartbeat‑switch protection, node‑removal thresholds, and a static‑registry approach to keep consumer requests stable while minimizing latency and avalanche effects.
Service Discoveryheartbeatmicroservices
0 likes · 7 min read

This article explains the concept of TCP heartbeat, demonstrates how to use Netty's IdleStateHandler to implement client‑server heartbeat detection, and provides a complete Java example with reconnection logic, retry policies, and detailed code snippets for building a robust long‑connection service.
JavaNettyTCP
0 likes · 18 min read

This article explains how to implement a TCP heartbeat mechanism using Netty's IdleStateHandler, details client and server handler implementations, and demonstrates a robust reconnection strategy with customizable retry policies, providing complete Java code examples for each component.
NetworkingTCPheartbeat
0 likes · 19 min read

This guide explains how to use WebSocket in a WeChat Mini‑Program to implement real‑time features such as live‑room comments, user join/leave events, likes, follows, and product shelf updates, covering protocol basics, handshake details, API usage, example code, heartbeat monitoring, and automatic reconnection strategies.
JavaScriptWeChat Mini-ProgramWebSocket
0 likes · 14 min read


ITPUBJan 10, 2021 · Databases
This article explains Redis's replication mechanism in detail, covering the step-by-step copy process, data synchronization via PSYNC, full and partial synchronization workflows, heartbeat management, and asynchronous replication, while highlighting key commands, offsets, run IDs, and performance considerations.
Partial SyncReplicationasynchronous
0 likes · 13 min read

The article investigates why MySQL replication reports the error “heartbeat is not compatible with local info” when large transactions exceed the 4 GB limit of the binlog's next_position field, reproduces the issue with a controlled experiment, analyzes packet structures, and proposes practical mitigation strategies.
Large TransactionsMySQLReplication
0 likes · 7 min read

This article explains why a custom TCP protocol can be more efficient than HTTP, defines the protocol header and body format, and demonstrates a complete Netty implementation—including message classes, encoders/decoders, resolver factories, server‑client bootstraps, and a Ping/Pong heartbeat mechanism—complete with runnable Java code and sample output.
JavaMessage EncodingNetty
0 likes · 15 min read

This article explains why a custom protocol can be more efficient than HTTP for service-to-service communication, defines a simple binary protocol with header and body, and demonstrates a complete Netty implementation—including message classes, encoders/decoders, resolvers, heartbeat handling, and client/server examples.
BackendJavaMessage Encoding
0 likes · 18 min read


58 TechJun 17, 2020 · Backend Development
The article presents Hermes, a lightweight and highly reliable mobile push system built with MQTT and Protocol Buffers, detailing its background, technology selection, architecture, heartbeat and reconnection strategies, future optimizations, and practical results that achieve over 99% message delivery rate.
Long ConnectionMQTTProtocol Buffers
0 likes · 16 min read

This article explains the purpose of DBLE's heartbeat detection, including high‑availability switching, read load balancing, and idle connection management, and provides a detailed walkthrough of the module's source code—from the Scheduler initialization to the MySQLHeartbeat implementation—illustrating how the system monitors MySQL instance status.
DBLEMySQLSource Code Analysis
0 likes · 8 min read

The article analyzes a MySQL replication issue where a low slave_net_timeout combined with a larger MASTER_HEARTBEAT_PERIOD causes frequent zombie dump threads, leading to massive small relay‑log files, and provides detailed explanations, code references, and step‑by‑step remediation procedures.
MySQLdatabasesheartbeat
0 likes · 14 min read

This article explains common TCP pitfalls such as sticky packets, how to handle them with proper framing, the importance of heartbeat mechanisms for detecting broken connections, and reliable data validation techniques like length prefixes and MD5 checksums to build robust network applications.
SocketSticky PacketsTCP
0 likes · 16 min read

This article provides a comprehensive overview of the Ceph distributed storage system, covering its architecture, storage types, internal IO processes, heartbeat mechanisms, communication framework, CRUSH data placement algorithm, and customizable RBD QoS using token‑bucket scheduling.
CRUSHCephIO Flow
0 likes · 26 min read


21CTOMay 30, 2019 · Databases
This article provides a comprehensive walkthrough of Redis replication, detailing the step‑by‑step sync process, data synchronization mechanisms, full and partial copy workflows, heartbeat design, and asynchronous replication, while highlighting key commands like PSYNC and their practical implications.
PSYNCPartial SyncReplication
0 likes · 13 min read

The article comprehensively explains Ceph’s distributed storage architecture—including monitors, OSDs, MDS, and RADOS—its block, file, and object services, its detailed I/O and heartbeat processes, the publish/subscribe communication framework, the deterministic CRUSH placement algorithm, and a token‑bucket based custom QoS for RBD.
CRUSH algorithmCephIO Flow
0 likes · 22 min read

This article explains the principles and components of high‑availability (HA) clusters, covering active/standby nodes, resource stickiness and constraints, heartbeat and quorum mechanisms, split‑brain avoidance, failure detection methods, and the minimal setup required for a reliable web‑service HA deployment.
FailoverHigh AvailabilityOperations
0 likes · 14 min read

The article explains how to achieve precise, real‑time detection of physical server outages, reduce false alarms through heartbeat monitoring, network and special‑case interference filtering, and detailed analysis, ultimately improving detection accuracy and coverage for reliable operations.
Operationsdowntime detectionfalse positive reduction
0 likes · 7 min read

This article explains how to implement a one‑master‑multiple‑backup high‑availability scheme using a database table for instance registration, automatic leader selection, heartbeat monitoring, and failover handling, with concrete examples and SQL snippets.
BackendHigh AvailabilityLeader Election
0 likes · 4 min read

This article provides a comprehensive technical overview of Ceph, covering its architecture, key components, storage interfaces, IO processes, heartbeat mechanisms, communication framework, CRUSH data placement algorithm, and customizable QoS strategies for distributed storage systems.
CRUSHCephIO Process
0 likes · 24 min read

This article presents a detailed failure analysis of a memcached service outage, explaining how the XMemcached client uses consistent hashing and heartbeat mechanisms to manage sessions, the impact of server loss on request latency, and the verification steps and solution to reduce session timeout and improve recovery.
BackendConsistent HashingMemcached
0 likes · 13 min read

This guide walks through installing and configuring a Linux high‑availability (HA) solution using Heartbeat and Nginx, detailing environment setup, host preparation, configuration files, service startup, testing failover, and troubleshooting common errors to achieve reliable, seamless server redundancy.
Linux HAheartbeat
0 likes · 5 min read

This article demonstrates how to build a Netty‑based server and client that support long‑living WebSocket connections, high concurrency, heartbeat monitoring, and automatic reconnection, providing complete code examples and detailed explanations of each component.
ClientJavaNetty
0 likes · 11 min read

This article explains Ceph's fault detection mechanism, detailing how OSD peers exchange heartbeats, report failures to the Monitor, and how the Monitor aggregates reports and applies configurable thresholds to reliably identify and handle downed OSD nodes in a distributed storage cluster.
CephOSDdistributed systems
0 likes · 8 min read

This article examines common MySQL high‑availability designs—including single master‑slave, dual‑master with multiple slaves, Heartbeat + DRBD, MySQL Cluster, semi‑synchronous replication, and GTID—explaining their benefits, drawbacks, and practical considerations for reliable failover and scalability.
DRBDDatabase ArchitectureGTID
0 likes · 9 min read


21CTOMar 25, 2016 · Backend Development
This article explains how Swoole's heartbeat feature works, why it is needed to detect dead TCP connections, and provides configuration tips for reliable asynchronous PHP server management.
BackendPHPSwoole
0 likes · 6 min read

This guide explains the fundamental concepts and layered architecture of high‑availability clusters, details the software components for each layer, compares RHEL/CentOS solutions, and provides step‑by‑step instructions for configuring heartbeat2 with haresource, including node preparation, authentication, resource definitions, and service failover.
LinuxRHELheartbeat
0 likes · 15 min read

This article details the analysis and redesign of Line, WhatsApp, and WeChat heartbeat mechanisms, presenting a simplified adaptive heartbeat algorithm, its testing methodology, comparative push strategies, GCM characteristics, and practical improvement suggestions to reduce power consumption, network load, and latency.
AndroidGCMTCP
0 likes · 22 min read

The article outlines a Linux server architecture that mounts a read‑only root filesystem over the network from a centrally managed, DRBD‑replicated control node with Heartbeat failover, providing real‑time updates, high security (even root cannot modify), and automatic migration via virtual IP.
DRBDNFSNetwork Boot
0 likes · 4 min read
