processCPUTotalSeconds          = "cpu_total_seconds"
	processGoRoutineTotal           = "go_routine_total"
	processIORCharBytes             = "io_rchar_bytes"
	processIOReadBytes              = "io_read_bytes"
	processIOWCharBytes             = "io_wchar_bytes"
	processIOWriteBytes             = "io_write_bytes"
	processStartTimeSeconds         = "start_time_seconds"
	processUptimeSeconds            = "uptime_seconds"

| `io_rchar_bytes`              | `counter` | Total bytes read by the process from the underlying storage system including cache, /proc/[pid]/io rchar       | `server` |
| `io_read_bytes`               | `counter` | Total bytes read by the process from the underlying storage system, /proc/[pid]/io read_bytes                  | `server` |

| `minio_node_io_rchar_bytes`                | Total bytes read by the process from the underlying storage system including cache, /proc/[pid]/io rchar.       |
| `minio_node_io_read_bytes`                 | Total bytes read by the process from the underlying storage system, /proc/[pid]/io read_bytes.                  |
| `minio_node_io_wchar_bytes`                | Total bytes written by the process to the underlying storage system including page cache, /proc/[pid]/io wchar. |

	proxiedDeleteTaggingRequestFailures MetricName = "proxied_delete_tagging_requests_failures"

	freeBytes       MetricName = "free_bytes"
	readBytes       MetricName = "read_bytes"
	rcharBytes      MetricName = "rchar_bytes"
	receivedBytes   MetricName = "received_bytes"
	latencyMilliSec MetricName = "latency_ms"
	sentBytes       MetricName = "sent_bytes"

	}

	// after successful read
	if _, err := b.ReadBytes('m'); err != nil {
		t.Fatalf("ReadBytes: %v", err)
	}
	if err := b.UnreadByte(); err != nil {
		t.Fatalf("UnreadByte: %v", err)
	}
	c, err := b.ReadByte()
	if err != nil {
		t.Fatalf("ReadByte: %v", err)
	}
	if c != 'm' {
		t.Errorf("ReadByte = %q; want %q", c, 'm')
	}
}

              readBytesDelivered = readBuffer.read(sink, minOf(byteCount, readBuffer.size))
              readBytes.update(total = readBytesDelivered)

              val unacknowledgedBytesRead = readBytes.unacknowledged
              if (errorExceptionToDeliver == null &&
                unacknowledgedBytesRead >= connection.okHttpSettings.initialWindowSize / 2
              ) {

    this.withLock {
      readBytes.update(total = read)
      val readBytesToAcknowledge = readBytes.unacknowledged
      if (readBytesToAcknowledge >= okHttpSettings.initialWindowSize / 2) {
        writeWindowUpdateLater(0, readBytesToAcknowledge)
        readBytes.update(acknowledged = readBytesToAcknowledge)
      }
      flowControlListener.receivingConnectionWindowChanged(readBytes)
    }
  }

  /**

    assertThat(frame2.type).isEqualTo(Http2.TYPE_RST_STREAM)
    val frame3 = peer.takeFrame()
    assertThat(frame3.type).isEqualTo(Http2.TYPE_RST_STREAM)
    assertThat(connection.readBytes.acknowledged).isEqualTo(0L)
    assertThat(connection.readBytes.total).isEqualTo(2048L)
  }

  @Test fun receiveGoAwayHttp2() {
    // Write the mocking script.
    peer.sendFrame().settings(Settings())
    peer.acceptFrame() // ACK

		return
	}
	if dc.IsNil() {
		err = dc.ReadNil()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		z.Data = nil
	} else {
		z.Data, err = dc.ReadBytes(z.Data)
		if err != nil {
			err = msgp.WrapError(err, "Data")
			return
		}
	}
	z.NumVersions, err = dc.ReadInt()
	if err != nil {
		err = msgp.WrapError(err, "NumVersions")
		return

// has been used.
// The returned reader contains the payload.
func waitForHTTPResponse(respBody io.Reader) (io.Reader, error) {
	reader := bufio.NewReader(respBody)
	for {
		b, err := reader.ReadByte()
		if err != nil {
			return nil, err
		}
		// Check if we have a response ready or a filler byte.
		switch b {
		case 0:
			return reader, nil
		case 1:
			errorText, err := io.ReadAll(reader)