return authTypeAnonymous
	}
	return authTypeUnknown
}

func validateAdminSignature(ctx context.Context, r *http.Request, region string) (auth.Credentials, bool, APIErrorCode) {
	var cred auth.Credentials
	var owner bool
	s3Err := ErrAccessDenied
	if _, ok := r.Header[xhttp.AmzContentSha256]; ok &&
		getRequestAuthType(r) == authTypeSigned {

- Liveness probe available at `/minio/health/live`
- Cluster probe available at `/minio/health/cluster`

Read more on how to use these endpoints in [MinIO healthcheck guide](https://github.com/minio/minio/blob/master/docs/metrics/healthcheck/README.md).

## Prometheus Probe

	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()

	"bytes"
	"context"
	"io"
	"net/http"
	"net/url"
	"os"
	"testing"
	"time"

	"github.com/minio/minio/internal/auth"
	"github.com/minio/pkg/v3/policy"
)

type nullReader struct{}

func (r *nullReader) Read(b []byte) (int, error) {
	return len(b), nil
}

// Test get request auth type.
func TestGetRequestAuthType(t *testing.T) {
	type testCase struct {
		req   *http.Request
		authT authType
	}

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

To trace entire HTTP request and also internode communication

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

## Subnet Health

	defer cancel()

	opts := HealthOptions{
		Maintenance:    r.Form.Get("maintenance") == "true",
		DeploymentType: r.Form.Get("deployment-type"),
	}
	result := objLayer.Health(ctx, opts)
	w.Header().Set(xhttp.MinIOWriteQuorum, strconv.Itoa(result.WriteQuorum))
	w.Header().Set(xhttp.MinIOStorageClassDefaults, strconv.FormatBool(result.UsingDefaults))
	// return how many drives are being healed if any

    }

    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);

quarkus/extensions/smallrye-health/deployment/pom.xml
	quarkus/core/deployment/pom.xml
	quarkus/extensions/arc/deployment/pom.xml
	quarkus/extensions/vertx-http/deployment/pom.xml
	quarkus/extensions/jsonp/deployment/pom.xml
	quarkus/extensions/smallrye-health/spi/pom.xml
	quarkus/extensions/smallrye-openapi/spi/pom.xml
	quarkus/extensions/smallrye-health/runtime/pom.xml
	quarkus/test-framework/junit5-internal/pom.xml

import org.gradle.work.DisableCachingByDefault
import java.io.File

@DisableCachingByDefault
abstract class FixProjectHealthTask : DefaultTask() {

    private val errorLogFile = File("gradle-project-health.log")

    @TaskAction
    fun fixProjectHealth() {
        if (!errorLogFile.exists()) {
            println("Error log not found! Run the projectHealth check first and redirect output.")
            return
        }

	return MetricDescription{
		Namespace: clusterMetricNamespace,
		Subsystem: "health",
		Name:      "status",
		Help:      "Get current cluster health status",
		Type:      gaugeMetric,
	}
}

func getClusterErasureSetHealthStatusMD() MetricDescription {
	return MetricDescription{
		Namespace: clusterMetricNamespace,
		Subsystem: "health",
		Name:      "erasure_set_status",