ReplicaCount int64 `json:"replicaCount"`
	// Queued operations
	Queued InQueueMetric `json:"queued"`
	// Proxy stats
	Proxied ProxyMetric `json:"proxied"`
	// replication metrics summary for each site replication peer
	Metrics map[string]SRMetric `json:"replMetrics"`
	// uptime of node being queried for site replication metrics
	Uptime int64 `json:"uptime"`

	istioHTTPPlaintext = []string{"istio", "istio-http/1.0", "istio-http/1.1", "istio-h2"}
	httpTLS            = []string{"http/1.0", "http/1.1", "h2c", "istio-http/1.0", "istio-http/1.1", "istio-h2"}
	tcpTLS             = []string{"istio-peer-exchange", "istio"}

	protDescrs = map[string][]string{
		"App: HTTP TLS":         httpTLS,
		"App: Istio HTTP Plain": istioHTTPPlaintext,
		"App: TCP TLS":          tcpTLS,

class WebSocketReaderTest {
  private val data = Buffer()
  private val callback = WebSocketRecorder("client")
  private val random = Random(0)

  // Mutually exclusive. Use the one corresponding to the peer whose behavior you wish to test.
  private val serverReader =
    WebSocketReader(
      isClient = false,
      source = data,
      frameCallback = callback.asFrameCallback(),
      perMessageDeflate = false,

| `minio_inter_node_traffic_received_bytes` | Total number of bytes received from other peer nodes.   |
| `minio_inter_node_traffic_sent_bytes`     | Total number of bytes sent to the other peer nodes.     |

## Bucket Notification Metrics

// executes at least one write operation if it is closed.
//
// This can be useful within the context of HTTP. At least
// one write operation must happen to send the HTTP headers
// to the peer.
type WriteOnCloser struct {
	io.Writer
	hasWritten bool
}

func (w *WriteOnCloser) Write(p []byte) (int, error) {
	w.hasWritten = true
	return w.Writer.Write(p)
}

                                maxConcurrentStreams:
                                  description: The maximum number of concurrent streams
                                    allowed for a peer on one HTTP/2 connection.
                                  format: int32
                                  type: integer
                                maxRequestsPerConnection:

                        "type_url": "type.googleapis.com/envoy.tcp.metadataexchange.config.MetadataExchange",
                        "value": {
                          "protocol": "istio-peer-exchange",
                          "enable_discovery": true
                        }
                      }
                    },
                    {
                      "name": "istio.stats",

     * followed by those lines.
     *
     * HTTPS responses also contain SSL session information. This begins with a blank line, and then
     * a line containing the cipher suite. Next is the length of the peer certificate chain. These
     * certificates are base64-encoded and appear each on their own line. The next line contains the
     * length of the local certificate chain. These certificates are also base64-encoded and appear

	// Network Sent/Received Bytes (internode)
	ch <- prometheus.MustNewConstMetric(
		prometheus.NewDesc(
			prometheus.BuildFQName(interNodeNamespace, "tx", "bytes_total"),
			"Total number of bytes sent to the other peer nodes by current MinIO server instance",
			nil, nil),
		prometheus.CounterValue,
		float64(connStats.internodeOutputBytes),
	)

	ch <- prometheus.MustNewConstMetric(
		prometheus.NewDesc(

		}
		if errors.Is(nerr.Err, rest.ErrClientClosed) {
			return true
		}
	}
	if errors.Is(err, grid.ErrDisconnected) {
		return true
	}
	// More corner cases suitable for storage REST API
	switch {
	// A peer node can be in shut down phase and proactively
	// return 503 server closed error, consider it as an offline node
	case strings.Contains(err.Error(), http.ErrServerClosed.Error()):
		return true