}

    /**
     * Set the health check interval
     * @param millis the health check interval in milliseconds
     */
    public void setHealthCheckInterval(int millis) {
        if (millis <= 0) {
            throw new IllegalArgumentException("Health check interval must be positive");
        }
        this.healthCheckInterval = millis;
        log.info("Set health check interval to {} ms", millis);
    }

          MYSQL_RANDOM_ROOT_PASSWORD: "yes"
        ports:
          - 9910:3306
        options: >-
          --health-cmd "mysqladmin ping -ugorm -pgorm"
          --health-interval 10s
          --health-start-period 10s
          --health-timeout 5s
          --health-retries 10

    steps:
    - name: Set up Go 1.x
      uses: actions/setup-go@v4
      with:
        go-version: ${{ matrix.go }}

	enc := json.NewEncoder(gzWriter)
	if e := enc.Encode(header); e != nil {
		internalLogIf(ctx, fmt.Errorf("Could not encode health info header: %w", e))
		return nil
	}

	if e := enc.Encode(healthInfo); e != nil {
		internalLogIf(ctx, fmt.Errorf("Could not encode health info: %w", e))
		return nil
	}

	gzWriter.Flush()
	gzWriter.Close()

	return b.Bytes()

import org.codelibs.fess.util.ComponentUtil;
import org.codelibs.fess.util.SearchEngineUtil;
import org.lastaflute.di.exception.IORuntimeException;
import org.opensearch.action.admin.cluster.health.ClusterHealthResponse;
import org.opensearch.cluster.health.ClusterHealthStatus;
import org.opensearch.common.xcontent.XContentType;

/**
 * Response entity for ping operations.
 */
public class PingResponse {

```sh
mc admin trace --verbose myminio
```

To trace entire HTTP request and also internode communication

```sh
mc admin trace --all --verbose myminio
```

## Subnet Health

    }

    private void performHealthCheck() {
        log.debug("Performing multi-channel health check");

        for (ChannelGroup channelGroup : sessionChannels.values()) {
            for (ChannelInfo channel : channelGroup.getChannels()) {
                try {
                    // Simplified health check - in real implementation would ping the channel
                    boolean isHealthy = checkChannelHealth(channel);

| `minio_cluster_erasure_set_read_health`          | Health of the erasure set in a pool for read operations (1=healthy, 0=unhealthy). <br><br>Type: gauge   | `pool_id`, `set_id` |
| `minio_cluster_erasure_set_write_health`         | Health of the erasure set in a pool for write operations (1=healthy, 0=unhealthy). <br><br>Type: gauge  | `pool_id`, `set_id` |

#### `/cluster/health`

		Online:   true,
	}
	sys.hMutex.Unlock()
}

// newHCClient initializes an anonymous client for performing health check on the remote endpoints
func newHCClient() *madmin.AnonymousClient {
	clnt, e := madmin.NewAnonymousClientNoEndpoint()
	if e != nil {
		bugLogIf(GlobalContext, errors.New("Unable to initialize health check client"))
		return nil
	}
	clnt.SetCustomTransport(globalRemoteTargetTransport)
	return clnt
}

		opts := HealthOptions{}
		result := objLayer.Health(ctx, opts)

		metrics = make([]MetricV2, 0, 2+4*len(result.ESHealth))

		metrics = append(metrics, MetricV2{
			Description: getClusterWriteQuorumMD(),
			Value:       float64(result.WriteQuorum),
		})

		health := 1
		if !result.Healthy {
			health = 0
		}

		metrics = append(metrics, MetricV2{

    //
    private static final Logger logger = LogManager.getLogger(AdminMaintenanceAction.class);

    private static final String[] CAT_NAMES =
            { "aliases", "allocation", "count", "fielddata", "health", "indices", "master", "nodeattrs", "nodes", "pending_tasks",
                    "plugins", "recovery", "repositories", "thread_pool", "shards", "segments", "snapshots", "templates" };