func loadClusterReplicationMetrics(ctx context.Context, m MetricValues, c *metricsCache) error {
	st := globalReplicationStats.Load()
	if st == nil {
		return nil
	}

	qs := st.getNodeQueueStatsSummary()

	qt := qs.QStats
	m.Set(replicationAverageQueuedBytes, float64(qt.Avg.Bytes))
	m.Set(replicationAverageQueuedCount, float64(qt.Avg.Count))
	m.Set(replicationMaxQueuedBytes, float64(qt.Max.Bytes))

	if globalEventNotifier == nil {
		return nil
	}

	nstats := globalEventNotifier.targetList.Stats()
	m.Set(notificationCurrentSendInProgress, float64(nstats.CurrentSendCalls))
	m.Set(notificationEventsErrorsTotal, float64(nstats.EventsErrorsTotal))
	m.Set(notificationEventsSentTotal, float64(nstats.TotalEvents))
	m.Set(notificationEventsSkippedTotal, float64(nstats.EventsSkipped))

	return nil

		merged.UpdatedAt = cm.UpdatedAt
	}

	for i := range cl.Bins {
		merged.Bins[i] = cl.Bins[i].add(cm.Bins[i])
	}

	return merged
}

// DailyAllTierStats is used to aggregate last day tier stats across MinIO servers
type DailyAllTierStats map[string]lastDayTierStats

func (l DailyAllTierStats) merge(m DailyAllTierStats) {
	for tier, st := range m {
		l[tier] = l[tier].merge(st)
	}
}

        Map<EventType, Long> stats = logger.getStatistics();
        assertEquals(Long.valueOf(1), stats.get(EventType.AUTHENTICATION_SUCCESS), "Should have 1 authentication success event");
        assertEquals(Long.valueOf(1), stats.get(EventType.AUTHENTICATION_FAILURE), "Should have 1 authentication failure event");
        assertEquals(Long.valueOf(1), stats.get(EventType.FILE_ACCESS), "Should have 1 file access event");

    if 'Records' in event:
        records = event['Records']['Payload'].decode('utf-8')
        print(records)
    elif 'Stats' in event:
        statsDetails = event['Stats']['Details']
        print("Stats details bytesScanned: ")
        print(statsDetails['BytesScanned'])
        print("Stats details bytesProcessed: ")

    StatsCounter counter = new SimpleStatsCounter();
    CacheStats stats = counter.snapshot();
    assertEquals(0, stats.requestCount());
    assertEquals(0, stats.hitCount());
    assertThat(stats.hitRate()).isEqualTo(1.0);
    assertEquals(0, stats.missCount());
    assertThat(stats.missRate()).isEqualTo(0.0);
    assertEquals(0, stats.loadSuccessCount());
    assertEquals(0, stats.loadExceptionCount());
    assertEquals(0, stats.loadCount());

        resourceManager.markClosed(id1);

        Map<String, Object> stats = resourceManager.getStatistics();

        assertNotNull(stats);
        assertTrue((long) stats.get("totalAllocated") >= 2);
        assertTrue((long) stats.get("totalReleased") >= 1);
        assertNotNull(stats.get("activeResources"));
        assertNotNull(stats.get("closedResources"));
    }

    @Test

		<Property name="log.file.basedir" value="${sys:fess.log.path:-target/logs}" />
		<Property name="backup.date.suffix" value="_%d{yyyyMMdd}" />
		<Property name="backup.max.history" value="10" />
		<Property name="stats.log.pattern" value="%msg%n" />
	</Properties>

	<Appenders>
		<RollingFile name="AppRollingFile" fileName="${log.file.basedir}/${domain.name}.log"

        System.arraycopy(src, srcIndex + namesLength, this.macAddress, 0, 6);
        srcIndex += readNodeNameArray(src, srcIndex);
        this.stats = new byte[statsLength];
        System.arraycopy(src, srcIndex, this.stats, 0, statsLength);
        srcIndex += statsLength;
        return srcIndex - start;
    }

    private int readNodeNameArray(final byte[] src, int srcIndex) {

	"github.com/minio/madmin-go/v3"
	"github.com/minio/minio-go/v7"
)

//go:generate msgp -file $GOFILE

// RStat has replication error stats
type RStat struct {
	Count int64 `json:"count"`
	Bytes int64 `json:"bytes"`
}

// RTimedMetrics has replication error stats for various time windows
type RTimedMetrics struct {
	LastHour    ReplicationLastHour `json:"lastHour"`
	SinceUptime RStat               `json:"sinceUptime"`