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: ")

				_ = bucketStats.load(bucketName)
			}
		}(i)
	}
	wg.Wait()

	stats := bucketStats.load("test-bucket")
	if stats.totalS3Requests == nil {
		t.Error("Expected bucket stats to be initialized")
	}
	t.Logf("Bucket HTTP stats race test passed")

        assertEquals(12, parsedStats.length); // 12 bytes total for stats
        // The stats array in NodeStatusResponse contains everything after names
        // MAC is at index 0-5, actual stats at 6-11
        byte[] expectedStats = new byte[12];
        System.arraycopy(testMac, 0, expectedStats, 0, 6); // MAC at beginning
        System.arraycopy(stats, 0, expectedStats, 6, 6); // Stats after MAC
        assertArrayEquals(expectedStats, parsedStats);

    CacheStats stats = counter.snapshot();
    assertThat(stats.requestCount()).isEqualTo(0);
    assertThat(stats.hitCount()).isEqualTo(0);
    assertThat(stats.hitRate()).isEqualTo(1.0);
    assertThat(stats.missCount()).isEqualTo(0);
    assertThat(stats.missRate()).isEqualTo(0.0);
    assertThat(stats.loadSuccessCount()).isEqualTo(0);
    assertThat(stats.loadExceptionCount()).isEqualTo(0);

import static com.google.common.util.concurrent.Service.State.FAILED;
import static com.google.common.util.concurrent.Service.State.NEW;
import static com.google.common.util.concurrent.Service.State.RUNNING;
import static com.google.common.util.concurrent.Service.State.STARTING;
import static com.google.common.util.concurrent.Service.State.STOPPING;
import static com.google.common.util.concurrent.Service.State.TERMINATED;

		NumBuckets:      int64(rs.TotBuckets),
	}
	for b, st := range rs.BucketStatuses {
		if st == ResyncFailed {
			m.FailedBuckets = append(m.FailedBuckets, b)
		}
	}
	return &m
}

// save in-memory stats to disk
func (sm *siteResyncMetrics) save(ctx context.Context) {
	sTimer := time.NewTimer(siteResyncSaveInterval)
	defer sTimer.Stop()
	for {
		select {
		case <-sTimer.C:

        State currentState = state.get();

        if (currentState == State.OPEN && shouldAttemptReset()) {
            transitionTo(State.HALF_OPEN);
            currentState = State.HALF_OPEN;
        }

        if (currentState == State.OPEN) {
            throw new CircuitOpenException("Circuit breaker '" + name + "' is open");
        }

    void testFailoverStateCreation() {
        ChannelFailover.FailoverState state = new ChannelFailover.FailoverState("test-channel");

        assertEquals("test-channel", state.getChannelId());
        assertEquals(0, state.getRetryCount());
        assertTrue(state.shouldRetry());
        assertTrue(state.getFailureTime() > 0);
        assertTrue(state.getNextRetryTime() > state.getFailureTime());
    }

    @Test

        if (state.eventSource) {
            state.eventSource.close();
            state.eventSource = null;
        }

        // Reset processing state
        state.isProcessing = false;

        if (state.sessionId) {
            // Clear session on server
            $.post(config.apiUrl, {
                sessionId: state.sessionId,
                clear: 'true'

    assertThat(manager.servicesByState().keySet()).containsExactly(Service.State.FAILED);
  }

  private static void assertState(
      ServiceManager manager, Service.State state, Service... services) {
    Collection<Service> managerServices = manager.servicesByState().get(state);
    for (Service service : services) {
      assertEquals(service.toString(), state, service.state());