scannerVersionsScannedMD = NewCounterMD(scannerVersionsScanned,
		"Total number of object versions scanned since server start")
	scannerLastActivitySecondsMD = NewGaugeMD(scannerLastActivitySeconds,
		"Time elapsed (in seconds) since last scan activity.")
)

// loadClusterScannerMetrics - `MetricsLoaderFn` for cluster webhook
// such as failed objects and directories scanned.

});
```

## Troubleshooting

### Common Issues

#### Connection Timeouts
```java
// Increase timeout values
client.setConnectionTimeout(60000);  // 60 seconds
client.setSocketTimeout(120000);     // 120 seconds
```

#### Memory Issues
```java
// Reduce concurrent threads and batch sizes
crawler.crawlerContext.setNumOfThread(5);
crawler.crawlerContext.setMaxAccessCount(1000);
```

    // stop it.
    blockingCallable.waitForStart();

    // Give the second task a chance to (incorrectly) start up while the first task is running.
    assertThat(future2.isDone()).isFalse();

    // Stop the first task. The second task should then run.
    blockingCallable.stop();
    executor.shutdown();
    assertThat(executor.awaitTermination(10, SECONDS)).isTrue();
    assertThat(getDone(future2)).isFalse();
  }

    }

    @Test
    void testUTimeReadWrite() {
        byte[] buffer = new byte[4];
        long time = System.currentTimeMillis();
        // UTime is seconds since epoch, so divide by 1000
        long unixTime = time / 1000L;

        // Mocking date for timezone consistency
        TimeZone original = TimeZone.getDefault();
        try {

* `expose_headers` - Indicate any response headers that should be made accessible to the browser. Defaults to `[]`.
* `max_age` - Sets a maximum time in seconds for browsers to cache CORS responses. Defaults to `600`.

The middleware responds to two particular types of HTTP request...

### CORS preflight requests { #cors-preflight-requests }

    assertFailsWith<SocketTimeoutException> {
      call.execute()
    }
    val elapsedNanos = System.nanoTime() - startNanos
    org.junit.jupiter.api.Assertions.assertTrue(
      elapsedNanos < TimeUnit.SECONDS.toNanos(5),
      "Timeout should have taken ~100ms but was " + elapsedNanos / 1e6 + " ms",
    )
  }

  @Test
  fun chainWithReadTimeout() {
    val interceptor1 =

//	sub-second times  |     no |       yes |        no
//	sparse files      |     no |       yes |       yes
//
// The table's upper portion shows the [Header] fields, where each format reports
// the maximum number of bytes allowed for each string field and
// the integer type used to store each numeric field
// (where timestamps are stored as the number of seconds since the Unix epoch).
//

import static com.google.common.util.concurrent.Runnables.doNothing;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.SECONDS;

import com.google.common.base.Predicate;
import com.google.common.base.Predicates;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
import java.util.ArrayList;

    /** The maximum cached content size in bytes. Default is 1MB. */
    protected long maxCachedContentSize = 1024L * 1024L; // 1MB

    /** The access timeout in seconds. Default is null (no timeout). */
    protected Integer accessTimeout = null; // seconds

    /** The maximum content length in bytes. Default is null (no limit). */
    protected Long maxContentLength = null;

    /**

            ImmutableSet.of(
                // DurationSpec.of(500, MILLISECONDS),
                DurationSpec.of(1, SECONDS), DurationSpec.of(1, DAYS)))
        .withExpireAfterAccesses(
            ImmutableSet.of(
                // DurationSpec.of(500, MILLISECONDS),
                DurationSpec.of(1, SECONDS), DurationSpec.of(1, DAYS)))
        .withRefreshes(
            ImmutableSet.of(