optimize(api): add warning logs for load-based request rejection

hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/filter/LoadDetectFilter.java

@@ -25,6 +25,8 @@
 import org.apache.hugegraph.define.WorkLoad;
 import org.apache.hugegraph.util.Bytes;
 import org.apache.hugegraph.util.E;
+import org.apache.hugegraph.util.Log;
+import org.slf4j.Logger;
 
 import com.google.common.collect.ImmutableSet;
 import com.google.common.util.concurrent.RateLimiter;
@@ -43,6 +45,8 @@
 @PreMatching
 public class LoadDetectFilter implements ContainerRequestFilter {
 
+    private static final Logger LOG = Log.logger(LoadDetectFilter.class);
+
     private static final Set<String> WHITE_API_LIST = ImmutableSet.of(
             "",
             "apis",
@@ -54,11 +58,40 @@ public class LoadDetectFilter implements ContainerRequestFilter {
     private static final RateLimiter GC_RATE_LIMITER =
             RateLimiter.create(1.0 / 30);
 
+    // Log at most 1 request per second to avoid too many logs when server is under heavy load
+    private static final RateLimiter REJECT_LOG_RATE_LIMITER = RateLimiter.create(1.0);
+
     @Context
     private jakarta.inject.Provider<HugeConfig> configProvider;
     @Context
     private jakarta.inject.Provider<WorkLoad> loadProvider;
 
+    public static boolean isWhiteAPI(ContainerRequestContext context) {
+        List<PathSegment> segments = context.getUriInfo().getPathSegments();
+        E.checkArgument(!segments.isEmpty(), "Invalid request uri '%s'",
+                        context.getUriInfo().getPath());
+        String rootPath = segments.get(0).getPath();
+        return WHITE_API_LIST.contains(rootPath);
+    }
+
+    protected boolean gcIfNeeded() {
+        if (GC_RATE_LIMITER.tryAcquire(1)) {
+            System.gc();
+            return true;
+        }
+        return false;
+    }
+
+    protected boolean allowRejectLog() {
+        return REJECT_LOG_RATE_LIMITER.tryAcquire();
+    }
+
+    protected void logRejectWarning(String message, Object... args) {
+        if (this.allowRejectLog()) {
+            LOG.warn(message, args);
+        }
+    }
+
     @Override
     public void filter(ContainerRequestContext context) {
         if (LoadDetectFilter.isWhiteAPI(context)) {
@@ -70,7 +103,12 @@ public void filter(ContainerRequestContext context) {
         int maxWorkerThreads = config.get(ServerOptions.MAX_WORKER_THREADS);
         WorkLoad load = this.loadProvider.get();
         // There will be a thread doesn't work, dedicated to statistics
-        if (load.incrementAndGet() >= maxWorkerThreads) {
+        int currentLoad = load.incrementAndGet();
+        if (currentLoad >= maxWorkerThreads) {
+            this.logRejectWarning("Rejected request due to high worker load, method={}, path={}, " +
+                                  "currentLoad={}, maxWorkerThreads={}",
+                                  context.getMethod(), context.getUriInfo().getPath(),
+                                  currentLoad, maxWorkerThreads);
             throw new ServiceUnavailableException(String.format(
                     "The server is too busy to process the request, " +
                     "you can config %s to adjust it or try again later",
@@ -83,7 +121,20 @@ public void filter(ContainerRequestContext context) {
         long presumableFreeMem = (Runtime.getRuntime().maxMemory() -
                                   allocatedMem) / Bytes.MB;
         if (presumableFreeMem < minFreeMemory) {
-            gcIfNeeded();
+            boolean shouldLog = this.allowRejectLog();
+            boolean gcTriggered = this.gcIfNeeded();
+            if (shouldLog) {
+                long allocatedMemAfterCheck = Runtime.getRuntime().totalMemory() -
+                                              Runtime.getRuntime().freeMemory();
+                long recheckedFreeMem = (Runtime.getRuntime().maxMemory() -
+                                         allocatedMemAfterCheck) / Bytes.MB;
+                LOG.warn("Rejected request due to low free memory, method={}, path={}, " +
+                         "presumableFreeMemMB={}, recheckedFreeMemMB={}, gcTriggered={}, " +
+                         "minFreeMemoryMB={}",
+                         context.getMethod(), context.getUriInfo().getPath(),
+                         presumableFreeMem, recheckedFreeMem, gcTriggered,
+                         minFreeMemory);
+            }
             throw new ServiceUnavailableException(String.format(
                     "The server available memory %s(MB) is below than " +
                     "threshold %s(MB) and can't process the request, " +
@@ -92,18 +143,4 @@ public void filter(ContainerRequestContext context) {
                     ServerOptions.MIN_FREE_MEMORY.name()));
         }
     }
-
-    public static boolean isWhiteAPI(ContainerRequestContext context) {
-        List<PathSegment> segments = context.getUriInfo().getPathSegments();
-        E.checkArgument(!segments.isEmpty(), "Invalid request uri '%s'",
-                        context.getUriInfo().getPath());
-        String rootPath = segments.get(0).getPath();
-        return WHITE_API_LIST.contains(rootPath);
-    }
-
-    private static void gcIfNeeded() {
-        if (GC_RATE_LIMITER.tryAcquire(1)) {
-            System.gc();
-        }
-    }
 }

hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/UnitTestSuite.java

@@ -18,6 +18,7 @@
 package org.apache.hugegraph.unit;
 
 import org.apache.hugegraph.core.RoleElectionStateMachineTest;
+import org.apache.hugegraph.unit.api.filter.LoadDetectFilterTest;
 import org.apache.hugegraph.unit.api.filter.PathFilterTest;
 import org.apache.hugegraph.unit.cache.CacheManagerTest;
 import org.apache.hugegraph.unit.cache.CacheTest;
@@ -78,6 +79,7 @@
 @RunWith(Suite.class)
 @Suite.SuiteClasses({
         /* api filter */
+        LoadDetectFilterTest.class,
         PathFilterTest.class,
 
         /* cache */