Heartbeat System

/**
 * The heartbeat sender provides basic API for sending heartbeat request to provided target.
 * This implementation is based on a trivial HTTP client.
 */
public class SimpleHttpHeartbeatSender implements HeartbeatSender {
    
    /**
     * Constructor that initializes with default dashboard addresses.
     * Retrieves dashboard server list from TransportConfig.
     */
    public SimpleHttpHeartbeatSender();
    
    /**
     * Send heartbeat to Sentinel Dashboard. Each invocation of this method will send
     * heartbeat once. Sentinel core is responsible for invoking this method
     * at every intervalMs() interval.
     * @return whether heartbeat is successfully sent
     */
    public boolean sendHeartbeat() throws Exception;
    
    /**
     * Default interval in milliseconds of the sender. It would take effect only when
     * the heartbeat interval is not configured in Sentinel config property.
     * @return default interval of the sender in milliseconds (10000ms)
     */
    public long intervalMs();
}

import com.alibaba.csp.sentinel.transport.heartbeat.SimpleHttpHeartbeatSender;
import com.alibaba.csp.sentinel.transport.HeartbeatSender;

// Create heartbeat sender
HeartbeatSender heartbeatSender = new SimpleHttpHeartbeatSender();

// Send single heartbeat
try {
    boolean success = heartbeatSender.sendHeartbeat();
    if (success) {
        System.out.println("Heartbeat sent successfully");
    } else {
        System.out.println("Failed to send heartbeat");
    }
} catch (Exception e) {
    System.err.println("Error sending heartbeat: " + e.getMessage());
}

// Get heartbeat interval
long interval = heartbeatSender.intervalMs(); // Returns 10000ms (10 seconds)

// Note: Sentinel core automatically manages periodic heartbeat sending
// Manual invocation is typically not needed in production

/**
 * Heart beat message entity.
 * The message consists of key-value pair parameters.
 */
public class HeartbeatMessage {
    
    /**
     * Constructor that auto-populates basic system information:
     * - hostname: system hostname
     * - ip: configured heartbeat client IP
     * - app: application name
     * - app_type: application type
     * - port: transport port
     */
    public HeartbeatMessage();
    
    /**
     * Register additional custom information in the heartbeat
     * @param key information key
     * @param value information value
     * @return this HeartbeatMessage for method chaining
     */
    public HeartbeatMessage registerInformation(String key, String value);
    
    /**
     * Generate the current message map with timestamp and version info.
     * Adds dynamic fields:
     * - v: Sentinel version
     * - version: current timestamp (via TimeUtil.currentTimeMillis())
     * - port: current transport port (updated from TransportConfig.getPort())
     * @return Map of all heartbeat parameters including static and dynamic fields
     */
    public Map<String, String> generateCurrentMessage();
}

import com.alibaba.csp.sentinel.transport.heartbeat.HeartbeatMessage;

// Create heartbeat message with default system info
HeartbeatMessage heartbeat = new HeartbeatMessage();

// Add custom application information
heartbeat.registerInformation("environment", "production")
         .registerInformation("version", "1.0.0")
         .registerInformation("instance_id", "app-001");

// Generate complete message for sending
Map<String, String> messageData = heartbeat.generateCurrentMessage();

// The message will include:
// - hostname, ip, app, app_type, port (from constructor)
// - environment, version, instance_id (custom additions)
// - v, version (timestamp), port (from generateCurrentMessage)

System.out.println("Heartbeat data: " + messageData);