"Average number of active replication workers")
	replicationAverageQueuedBytesMD = NewGaugeMD(replicationAverageQueuedBytes,
		"Average number of bytes queued for replication since server start")
	replicationAverageQueuedCountMD = NewGaugeMD(replicationAverageQueuedCount,
		"Average number of objects queued for replication since server start")
	replicationAverageDataTransferRateMD = NewGaugeMD(replicationAverageDataTransferRate,

				return
			}
		case "PoolIndex":
			z.PoolIndex, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "PoolIndex")
				return
			}
		case "Queued":
			z.Queued, err = dc.ReadTime()
			if err != nil {
				err = msgp.WrapError(err, "Queued")
				return
			}
		case "BitrotScan":
			z.BitrotScan, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "BitrotScan")
				return
			}

const (
	_ TargetType = iota
	TargetConsole
	TargetHTTP
	TargetKafka
)

// TargetStats contains statistics for a target.
type TargetStats struct {
	// QueueLength is the queue length if any messages are queued.
	QueueLength int

	// TotalMessages is the total number of messages sent in the lifetime of the target
	TotalMessages int64

	// FailedMessages should log message count that failed to send.

// but not written in all disks (having quorum)
type PartialOperation struct {
	Bucket              string
	Object              string
	VersionID           string
	Versions            []byte
	SetIndex, PoolIndex int
	Queued              time.Time
	BitrotScan          bool
}

// mrfState sncapsulates all the information
// related to the global background MRF.
type mrfState struct {
	opCh chan PartialOperation

	closed  int32

	// Total number of replica received
	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"`

 * on single thread, keeping the listener logic simple. This listener also blocks on last transfer event to allow
 * output to perform possible cleanup. It spawns a daemon thread to consume queued events that may fall in even
 * concurrently.
 *
 * @since 4.0.0
 */
@Deprecated
public final class SimplexTransferListener extends AbstractTransferListener {

	}

	enc := json.NewEncoder(w)
	for {
		select {
		case ev := <-mergeCh:
			_, err := w.Write(ev)
			if err != nil {
				return
			}
			if len(mergeCh) == 0 {
				// Flush if nothing is queued
				xhttp.Flush(w)
			}
			grid.PutByteBuffer(ev)
		case <-emptyEventTicker:
			if err := enc.Encode(struct{ Records []event.Event }{}); err != nil {
				return
			}
			xhttp.Flush(w)

 * on single thread, keeping the listener logic simple. This listener also blocks on last transfer event to allow
 * output to perform possible cleanup. It spawns a daemon thread to consume queued events that may fall in even
 * concurrently.
 *
 * @since 4.0.0
 */
public final class SimplexTransferListener extends AbstractTransferListener implements AutoCloseable {

		if ok {
			for i, queue := range config.QueueList {
				// Remove ARN not found queues, because we previously allowed
				// adding unexpected entries into the config.
				//
				// With newer config disallowing changing / turning off
				// notification targets without removing ARN in notification
				// configuration we won't see this problem anymore.
				if reflect.DeepEqual(queue.ARN, arnErr.ARN) && i < len(config.QueueList) {

	var queueStore store.Store[event.Event]
	if args.QueueDir != "" {
		queueDir := filepath.Join(args.QueueDir, storePrefix+"-nsq-"+id)
		queueStore = store.NewQueueStore[event.Event](queueDir, args.QueueLimit, event.StoreExtension)
		if err := queueStore.Open(); err != nil {
			return nil, fmt.Errorf("unable to initialize the queue store of NSQ `%s`: %w", id, err)
		}
	}

	target := &NSQTarget{