diff --git a/include/pika_server.h b/include/pika_server.h
index df7522918..2a602061d 100644
--- a/include/pika_server.h
+++ b/include/pika_server.h
@@ -310,6 +310,8 @@ class PikaServer : public pstd::noncopyable {
   // info debug use
   void ServerStatus(std::string* info);
 
+  std::unordered_map<std::string, int> GetBigKeyStatistics();
+
   /*
    * Async migrate used
    */
diff --git a/src/pika_admin.cc b/src/pika_admin.cc
index 30d8a0c94..93c1da2cc 100644
--- a/src/pika_admin.cc
+++ b/src/pika_admin.cc
@@ -1091,6 +1091,11 @@ void InfoCmd::InfoStats(std::string& info) {
   tmp_stream << "is_compact:" << (g_pika_server->IsCompacting() ? "Yes" : "No") << "\r\n";
   tmp_stream << "compact_cron:" << g_pika_conf->compact_cron() << "\r\n";
   tmp_stream << "compact_interval:" << g_pika_conf->compact_interval() << "\r\n";
+  tmp_stream << "# Big Key Statistics\r\n";
+  auto big_key_stats = g_pika_server->GetBigKeyStatistics();
+  for (const auto& entry : big_key_stats) {
+    tmp_stream << "key:" << entry.first << ", access_count:" << entry.second << "\r\n";
+  }
   time_t current_time_s = time(nullptr);
   PikaServer::BGSlotsReload bgslotsreload_info = g_pika_server->bgslots_reload();
   bool is_reloading = g_pika_server->GetSlotsreloading();
diff --git a/src/pika_server.cc b/src/pika_server.cc
index b205f3e34..2e836b53a 100644
--- a/src/pika_server.cc
+++ b/src/pika_server.cc
@@ -803,6 +803,24 @@ void PikaServer::PurgeDir(const std::string& path) {
   PurgeDirTaskSchedule(&DoPurgeDir, static_cast<void*>(dir_path));
 }
 
+std::unordered_map<std::string, int> PikaServer::GetBigKeyStatistics() {
+  std::unordered_map<std::string, int> aggregated_stats;
+
+  for (const auto& db_entry : dbs_) {
+    auto db_name = db_entry.first;
+    auto db_instance = db_entry.second;
+
+    if (db_instance) {
+        auto stats = g_pika_server->GetBigKeyStatistics();
+        for (const auto& entry : stats) {
+          aggregated_stats[entry.first] += entry.second;
+        }
+      }
+    }
+
+  return aggregated_stats;
+}
+
 
 void PikaServer::PurgeDirTaskSchedule(void (*function)(void*), void* arg) {
   purge_thread_.StartThread();
diff --git a/src/storage/src/redis.h b/src/storage/src/redis.h
index 54c6e10d4..e005bd723 100644
--- a/src/storage/src/redis.h
+++ b/src/storage/src/redis.h
@@ -359,6 +359,22 @@ class Redis {
   void ScanZsets();
   void ScanSets();
 
+  void CheckBigKeyAndLog(const std::string& key, uint64_t size) {
+    static const uint64_t kBigKeyThreshold = 10000;
+    if (size > kBigKeyThreshold) {
+      std::lock_guard<std::mutex> lock(big_key_access_mutex_);
+      big_key_access_count_[key]++;
+      std::cerr << "[BIGKEY DETECTED] Key: " << key
+                << ", Size: " << size
+                << ", Access Count: " << big_key_access_count_[key] << std::endl;
+    }
+  }
+
+  std::unordered_map<std::string, int> GetBigKeyStatistics() {
+    std::lock_guard<std::mutex> lock(big_key_access_mutex_); // 确保线程安全
+    return big_key_access_count_;
+  }
+
   TypeIterator* CreateIterator(const DataType& type, const std::string& pattern, const Slice* lower_bound, const Slice* upper_bound) {
     return CreateIterator(DataTypeTag[static_cast<int>(type)], pattern, lower_bound, upper_bound);
   }
@@ -538,6 +554,9 @@ class Redis {
   Status UpdateSpecificKeyStatistics(const DataType& dtype, const std::string& key, uint64_t count);
   Status UpdateSpecificKeyDuration(const DataType& dtype, const std::string& key, uint64_t duration);
   Status AddCompactKeyTaskIfNeeded(const DataType& dtype, const std::string& key, uint64_t count, uint64_t duration);
+
+  std::unordered_map<std::string, int> big_key_access_count_;
+  std::mutex big_key_access_mutex_;
 };
 
 }  //  namespace storage
diff --git a/src/storage/src/redis_hashes.cc b/src/storage/src/redis_hashes.cc
index 1a947c07e..5bc9558ae 100644
--- a/src/storage/src/redis_hashes.cc
+++ b/src/storage/src/redis_hashes.cc
@@ -95,6 +95,7 @@ Status Redis::HDel(const Slice& key, const std::vector<std::string>& fields, int
   }
   if (s.ok()) {
     ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
     if (parsed_hashes_meta_value.IsStale() || parsed_hashes_meta_value.Count() == 0) {
       *ret = 0;
       return Status::OK();
@@ -159,6 +160,7 @@ Status Redis::HGet(const Slice& key, const Slice& field, std::string* value) {
   }
   if (s.ok()) {
     ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
     if (parsed_hashes_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_hashes_meta_value.Count() == 0) {
@@ -199,6 +201,7 @@ Status Redis::HGetall(const Slice& key, std::vector<FieldValue>* fvs) {
   }
   if (s.ok()) {
     ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
     if (parsed_hashes_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_hashes_meta_value.Count() == 0) {
@@ -242,6 +245,7 @@ Status Redis::HGetallWithTTL(const Slice& key, std::vector<FieldValue>* fvs, int
   }
   if (s.ok()) {
     ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
     if (parsed_hashes_meta_value.Count() == 0) {
       return Status::NotFound();
     } else if (parsed_hashes_meta_value.IsStale()) {
@@ -299,6 +303,7 @@ Status Redis::HIncrby(const Slice& key, const Slice& field, int64_t value, int64
   }
   if (s.ok()) {
     ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
     if (parsed_hashes_meta_value.IsStale() || parsed_hashes_meta_value.Count() == 0) {
       version = parsed_hashes_meta_value.UpdateVersion();
       parsed_hashes_meta_value.SetCount(1);
@@ -392,6 +397,7 @@ Status Redis::HIncrbyfloat(const Slice& key, const Slice& field, const Slice& by
   }
   if (s.ok()) {
     ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
     if (parsed_hashes_meta_value.IsStale() || parsed_hashes_meta_value.Count() == 0) {
       version = parsed_hashes_meta_value.UpdateVersion();
       parsed_hashes_meta_value.SetCount(1);
@@ -476,6 +482,7 @@ Status Redis::HKeys(const Slice& key, std::vector<std::string>* fields) {
   }
   if (s.ok()) {
     ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
     if (parsed_hashes_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_hashes_meta_value.Count() == 0) {
@@ -519,6 +526,7 @@ Status Redis::HLen(const Slice& key, int32_t* ret, std::string&& prefetch_meta)
   }
   if (s.ok()) {
     ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
     if (parsed_hashes_meta_value.IsStale()) {
       *ret = 0;
       return Status::NotFound("Stale");
@@ -558,6 +566,7 @@ Status Redis::HMGet(const Slice& key, const std::vector<std::string>& fields, st
   }
   if (s.ok()) {
     ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
     if ((is_stale = parsed_hashes_meta_value.IsStale()) || parsed_hashes_meta_value.Count() == 0) {
       for (size_t idx = 0; idx < fields.size(); ++idx) {
         vss->push_back({std::string(), Status::NotFound()});
@@ -622,6 +631,7 @@ Status Redis::HMSet(const Slice& key, const std::vector<FieldValue>& fvs) {
   }
   if (s.ok()) {
     ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
     if (parsed_hashes_meta_value.IsStale() || parsed_hashes_meta_value.Count() == 0) {
       version = parsed_hashes_meta_value.InitialMetaValue();
       if (!parsed_hashes_meta_value.check_set_count(static_cast<int32_t>(filtered_fvs.size()))) {
@@ -697,6 +707,7 @@ Status Redis::HSet(const Slice& key, const Slice& field, const Slice& value, int
   }
   if (s.ok()) {
     ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
     if (parsed_hashes_meta_value.IsStale() || parsed_hashes_meta_value.Count() == 0) {
       version = parsed_hashes_meta_value.InitialMetaValue();
       parsed_hashes_meta_value.SetCount(1);
@@ -772,6 +783,7 @@ Status Redis::HSetnx(const Slice& key, const Slice& field, const Slice& value, i
   }
   if (s.ok()) {
     ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
     if (parsed_hashes_meta_value.IsStale() || parsed_hashes_meta_value.Count() == 0) {
       version = parsed_hashes_meta_value.InitialMetaValue();
       parsed_hashes_meta_value.SetCount(1);
@@ -835,6 +847,7 @@ Status Redis::HVals(const Slice& key, std::vector<std::string>* values) {
   }
   if (s.ok()) {
     ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
     if (parsed_hashes_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_hashes_meta_value.Count() == 0) {
@@ -898,6 +911,7 @@ Status Redis::HScan(const Slice& key, int64_t cursor, const std::string& pattern
   }
   if (s.ok()) {
     ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
     if (parsed_hashes_meta_value.IsStale() || parsed_hashes_meta_value.Count() == 0) {
       *next_cursor = 0;
       return Status::NotFound();
@@ -975,6 +989,7 @@ Status Redis::HScanx(const Slice& key, const std::string& start_field, const std
   }
   if (s.ok()) {
     ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
     if (parsed_hashes_meta_value.IsStale() || parsed_hashes_meta_value.Count() == 0) {
       *next_field = "";
       return Status::NotFound();
@@ -1045,6 +1060,7 @@ Status Redis::PKHScanRange(const Slice& key, const Slice& field_start, const std
   }
   if (s.ok()) {
     ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
     if (parsed_hashes_meta_value.IsStale() || parsed_hashes_meta_value.Count() == 0) {
       return Status::NotFound();
     } else {
@@ -1116,6 +1132,7 @@ Status Redis::PKHRScanRange(const Slice& key, const Slice& field_start, const st
   }
   if (s.ok()) {
     ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
     if (parsed_hashes_meta_value.IsStale() || parsed_hashes_meta_value.Count() == 0) {
       return Status::NotFound();
     } else {
@@ -1178,6 +1195,7 @@ Status Redis::HashesExpire(const Slice& key, int64_t ttl_millsec, std::string&&
   }
   if (s.ok()) {
     ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
     if (parsed_hashes_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_hashes_meta_value.Count() == 0) {
@@ -1218,6 +1236,7 @@ Status Redis::HashesDel(const Slice& key, std::string&& prefetch_meta) {
   }
   if (s.ok()) {
     ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
     if (parsed_hashes_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_hashes_meta_value.Count() == 0) {
@@ -1255,6 +1274,7 @@ Status Redis::HashesExpireat(const Slice& key, int64_t timestamp_millsec, std::s
   }
   if (s.ok()) {
     ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
     if (parsed_hashes_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_hashes_meta_value.Count() == 0) {
@@ -1294,6 +1314,7 @@ Status Redis::HashesPersist(const Slice& key, std::string&& prefetch_meta) {
   }
   if (s.ok()) {
     ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
     if (parsed_hashes_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_hashes_meta_value.Count() == 0) {
@@ -1333,6 +1354,7 @@ Status Redis::HashesTTL(const Slice& key, int64_t* ttl_millsec, std::string&& pr
   }
   if (s.ok()) {
     ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
     if (parsed_hashes_meta_value.IsStale()) {
       *ttl_millsec = -2;
       return Status::NotFound("Stale");
diff --git a/src/storage/src/redis_lists.cc b/src/storage/src/redis_lists.cc
index cdf4ff122..e1b6260e1 100644
--- a/src/storage/src/redis_lists.cc
+++ b/src/storage/src/redis_lists.cc
@@ -79,6 +79,7 @@ Status Redis::LIndex(const Slice& key, int64_t index, std::string* element) {
   }
   if (s.ok()) {
     ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
     uint64_t version = parsed_lists_meta_value.Version();
     if (parsed_lists_meta_value.IsStale()) {
       return Status::NotFound("Stale");
@@ -123,6 +124,7 @@ Status Redis::LInsert(const Slice& key, const BeforeOrAfter& before_or_after, co
   }
   if (s.ok()) {
     ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
     if (parsed_lists_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_lists_meta_value.Count() == 0) {
@@ -239,6 +241,7 @@ Status Redis::LLen(const Slice& key, uint64_t* len, std::string&& prefetch_meta)
   }
   if (s.ok()) {
     ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
     if (parsed_lists_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_lists_meta_value.Count() == 0) {
@@ -274,6 +277,7 @@ Status Redis::LPop(const Slice& key, int64_t count, std::vector<std::string>* el
   }
   if (s.ok()) {
     ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
     if (parsed_lists_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_lists_meta_value.Count() == 0) {
@@ -332,6 +336,7 @@ Status Redis::LPush(const Slice& key, const std::vector<std::string>& values, ui
   }
   if (s.ok()) {
     ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
     if (parsed_lists_meta_value.IsStale() || parsed_lists_meta_value.Count() == 0) {
       version = parsed_lists_meta_value.InitialMetaValue();
     } else {
@@ -388,6 +393,7 @@ Status Redis::LPushx(const Slice& key, const std::vector<std::string>& values, u
   }
   if (s.ok()) {
     ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
     if (parsed_lists_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_lists_meta_value.Count() == 0) {
@@ -432,6 +438,7 @@ Status Redis::LRange(const Slice& key, int64_t start, int64_t stop, std::vector<
   }
   if (s.ok()) {
     ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
     if (parsed_lists_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_lists_meta_value.Count() == 0) {
@@ -492,6 +499,7 @@ Status Redis::LRangeWithTTL(const Slice& key, int64_t start, int64_t stop, std::
   }
   if (s.ok()) {
     ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
     if (parsed_lists_meta_value.Count() == 0) {
       return Status::NotFound();
     } else if (parsed_lists_meta_value.IsStale()) {
@@ -561,6 +569,7 @@ Status Redis::LRem(const Slice& key, int64_t count, const Slice& value, uint64_t
   }
   if (s.ok()) {
     ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
     if (parsed_lists_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_lists_meta_value.Count() == 0) {
@@ -693,6 +702,7 @@ Status Redis::LSet(const Slice& key, int64_t index, const Slice& value) {
   }
   if (s.ok()) {
     ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
     if (parsed_lists_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_lists_meta_value.Count() == 0) {
@@ -737,6 +747,7 @@ Status Redis::LTrim(const Slice& key, int64_t start, int64_t stop) {
   }
   if (s.ok()) {
     ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
     uint64_t version = parsed_lists_meta_value.Version();
     if (parsed_lists_meta_value.IsStale()) {
       return Status::NotFound("Stale");
@@ -810,6 +821,7 @@ Status Redis::RPop(const Slice& key, int64_t count, std::vector<std::string>* el
   }
   if (s.ok()) {
     ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
     if (parsed_lists_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_lists_meta_value.Count() == 0) {
@@ -1118,6 +1130,7 @@ Status Redis::ListsExpire(const Slice& key, int64_t ttl_millsec, std::string&& p
   }
   if (s.ok()) {
     ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
+
     if (parsed_lists_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_lists_meta_value.Count() == 0) {
@@ -1158,6 +1171,7 @@ Status Redis::ListsDel(const Slice& key, std::string&& prefetch_meta) {
   }
   if (s.ok()) {
     ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
     if (parsed_lists_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_lists_meta_value.Count() == 0) {
@@ -1195,6 +1209,7 @@ Status Redis::ListsExpireat(const Slice& key, int64_t timestamp_millsec, std::st
   }
   if (s.ok()) {
     ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
     if (parsed_lists_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_lists_meta_value.Count() == 0) {
@@ -1234,6 +1249,7 @@ Status Redis::ListsPersist(const Slice& key, std::string&& prefetch_meta) {
   }
   if (s.ok()) {
     ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
     if (parsed_lists_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_lists_meta_value.Count() == 0) {
@@ -1273,6 +1289,7 @@ Status Redis::ListsTTL(const Slice& key, int64_t* ttl_millsec, std::string&& pre
   }
   if (s.ok()) {
     ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
     if (parsed_lists_meta_value.IsStale()) {
       *ttl_millsec = -2;
       return Status::NotFound("Stale");
diff --git a/src/storage/src/redis_sets.cc b/src/storage/src/redis_sets.cc
index 5f33d9574..a3e38c636 100644
--- a/src/storage/src/redis_sets.cc
+++ b/src/storage/src/redis_sets.cc
@@ -90,6 +90,7 @@ rocksdb::Status Redis::SAdd(const Slice& key, const std::vector<std::string>& me
   }
   if (s.ok()) {
     ParsedSetsMetaValue parsed_sets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_sets_meta_value.Count());
     if (parsed_sets_meta_value.IsStale() || parsed_sets_meta_value.Count() == 0) {
       version = parsed_sets_meta_value.InitialMetaValue();
       if (!parsed_sets_meta_value.check_set_count(static_cast<int32_t>(filtered_members.size()))) {
@@ -169,6 +170,7 @@ rocksdb::Status Redis::SCard(const Slice& key, int32_t* ret, std::string&& meta)
 
   if (s.ok()) {
     ParsedSetsMetaValue parsed_sets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_sets_meta_value.Count());
     if (parsed_sets_meta_value.IsStale()) {
       return rocksdb::Status::NotFound("Stale");
     } else {
@@ -211,6 +213,7 @@ rocksdb::Status Redis::SDiff(const std::vector<std::string>& keys, std::vector<s
     }
     if (s.ok()) {
       ParsedSetsMetaValue parsed_sets_meta_value(&meta_value);
+
       if (!parsed_sets_meta_value.IsStale() && parsed_sets_meta_value.Count() != 0) {
         vaild_sets.push_back({keys[idx], parsed_sets_meta_value.Version()});
       }
@@ -933,6 +936,7 @@ rocksdb::Status Redis::SPop(const Slice& key, std::vector<std::string>* members,
   }
   if (s.ok()) {
     ParsedSetsMetaValue parsed_sets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_sets_meta_value.Count());
     if (parsed_sets_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_sets_meta_value.Count() == 0) {
@@ -1050,6 +1054,7 @@ rocksdb::Status Redis::SRandmember(const Slice& key, int32_t count, std::vector<
   }
   if (s.ok()) {
     ParsedSetsMetaValue parsed_sets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_sets_meta_value.Count());
     if (parsed_sets_meta_value.IsStale()) {
       return rocksdb::Status::NotFound("Stale");
     } else if (parsed_sets_meta_value.Count() == 0) {
@@ -1124,6 +1129,7 @@ rocksdb::Status Redis::SRem(const Slice& key, const std::vector<std::string>& me
   }
   if (s.ok()) {
     ParsedSetsMetaValue parsed_sets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_sets_meta_value.Count());
     if (parsed_sets_meta_value.IsStale()) {
       return rocksdb::Status::NotFound("stale");
     } else if (parsed_sets_meta_value.Count() == 0) {
@@ -1353,6 +1359,7 @@ rocksdb::Status Redis::SScan(const Slice& key, int64_t cursor, const std::string
   }
   if (s.ok()) {
     ParsedSetsMetaValue parsed_sets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_sets_meta_value.Count());
     if (parsed_sets_meta_value.IsStale() || parsed_sets_meta_value.Count() == 0) {
       *next_cursor = 0;
       return rocksdb::Status::NotFound();
@@ -1503,6 +1510,7 @@ rocksdb::Status Redis::SetsExpireat(const Slice& key, int64_t timestamp_millsec,
   }
   if (s.ok()) {
     ParsedSetsMetaValue parsed_sets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_sets_meta_value.Count());
     if (parsed_sets_meta_value.IsStale()) {
       return rocksdb::Status::NotFound("Stale");
     } else if (parsed_sets_meta_value.Count() == 0) {
@@ -1542,6 +1550,7 @@ rocksdb::Status Redis::SetsPersist(const Slice& key, std::string&& prefetch_meta
   }
   if (s.ok()) {
     ParsedSetsMetaValue parsed_sets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_sets_meta_value.Count());
     if (parsed_sets_meta_value.IsStale()) {
       return rocksdb::Status::NotFound("Stale");
     } else if (parsed_sets_meta_value.Count() == 0) {
@@ -1581,6 +1590,7 @@ rocksdb::Status Redis::SetsTTL(const Slice& key, int64_t* ttl_millsec, std::stri
   }
   if (s.ok()) {
     ParsedSetsMetaValue parsed_setes_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_setes_meta_value.Count());
     if (parsed_setes_meta_value.IsStale()) {
       *ttl_millsec = -2;
       return rocksdb::Status::NotFound("Stale");
diff --git a/src/storage/src/redis_zsets.cc b/src/storage/src/redis_zsets.cc
index fa6c78f91..30e0db74c 100644
--- a/src/storage/src/redis_zsets.cc
+++ b/src/storage/src/redis_zsets.cc
@@ -84,6 +84,7 @@ Status Redis::ZPopMax(const Slice& key, const int64_t count, std::vector<ScoreMe
   }
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_zsets_meta_value.Count());
     if (parsed_zsets_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_zsets_meta_value.Count() == 0) {
@@ -142,6 +143,7 @@ Status Redis::ZPopMin(const Slice& key, const int64_t count, std::vector<ScoreMe
   }
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_zsets_meta_value.Count());
     if (parsed_zsets_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_zsets_meta_value.Count() == 0) {
@@ -212,6 +214,7 @@ Status Redis::ZAdd(const Slice& key, const std::vector<ScoreMember>& score_membe
   if (s.ok()) {
     bool vaild = true;
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_zsets_meta_value.Count());
     if (parsed_zsets_meta_value.IsStale() || parsed_zsets_meta_value.Count() == 0) {
       vaild = false;
       version = parsed_zsets_meta_value.InitialMetaValue();
@@ -316,6 +319,7 @@ Status Redis::ZCard(const Slice& key, int32_t* card, std::string&& prefetch_meta
 
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_zsets_meta_value.Count());
     if (parsed_zsets_meta_value.IsStale()) {
       *card = 0;
       return Status::NotFound("Stale");
@@ -353,6 +357,7 @@ Status Redis::ZCount(const Slice& key, double min, double max, bool left_close,
   }
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_zsets_meta_value.Count());
     if (parsed_zsets_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_zsets_meta_value.Count() == 0) {
@@ -421,6 +426,7 @@ Status Redis::ZIncrby(const Slice& key, const Slice& member, double increment, d
   }
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_zsets_meta_value.Count());
     if (parsed_zsets_meta_value.IsStale() || parsed_zsets_meta_value.Count() == 0) {
       version = parsed_zsets_meta_value.InitialMetaValue();
     } else {
@@ -500,6 +506,7 @@ Status Redis::ZRange(const Slice& key, int32_t start, int32_t stop, std::vector<
   }
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_zsets_meta_value.Count());
     if (parsed_zsets_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_zsets_meta_value.Count() == 0) {
@@ -557,6 +564,7 @@ Status Redis::ZRangeWithTTL(const Slice& key, int32_t start, int32_t stop, std::
   }
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_zsets_meta_value.Count());
     if (parsed_zsets_meta_value.Count() == 0) {
       return Status::NotFound();
     } else if (parsed_zsets_meta_value.IsStale()) {
@@ -628,6 +636,7 @@ Status Redis::ZRangebyscore(const Slice& key, double min, double max, bool left_
   }
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_zsets_meta_value.Count());
     if (parsed_zsets_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_zsets_meta_value.Count() == 0) {
@@ -705,6 +714,7 @@ Status Redis::ZRank(const Slice& key, const Slice& member, int32_t* rank) {
   }
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_zsets_meta_value.Count());
     if (parsed_zsets_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_zsets_meta_value.Count() == 0) {
@@ -767,6 +777,7 @@ Status Redis::ZRem(const Slice& key, const std::vector<std::string>& members, in
   }
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_zsets_meta_value.Count());
     if (parsed_zsets_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_zsets_meta_value.Count() == 0) {
@@ -830,6 +841,7 @@ Status Redis::ZRemrangebyrank(const Slice& key, int32_t start, int32_t stop, int
   }
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_zsets_meta_value.Count());
     if (parsed_zsets_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_zsets_meta_value.Count() == 0) {
@@ -898,6 +910,7 @@ Status Redis::ZRemrangebyscore(const Slice& key, double min, double max, bool le
   }
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_zsets_meta_value.Count());
     if (parsed_zsets_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_zsets_meta_value.Count() == 0) {
@@ -980,6 +993,7 @@ Status Redis::ZRevrange(const Slice& key, int32_t start, int32_t stop, std::vect
   }
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_zsets_meta_value.Count());
     if (parsed_zsets_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_zsets_meta_value.Count() == 0) {
@@ -1038,6 +1052,7 @@ Status Redis::ZRevrangebyscore(const Slice& key, double min, double max, bool le
   }
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_zsets_meta_value.Count());
     if (parsed_zsets_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_zsets_meta_value.Count() == 0) {
@@ -1115,6 +1130,7 @@ Status Redis::ZRevrank(const Slice& key, const Slice& member, int32_t* rank) {
   }
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_zsets_meta_value.Count());
     if (parsed_zsets_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_zsets_meta_value.Count() == 0) {
@@ -1169,6 +1185,7 @@ Status Redis::ZScore(const Slice& key, const Slice& member, double* score) {
   }
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_zsets_meta_value.Count());
     uint64_t version = parsed_zsets_meta_value.Version();
     if (parsed_zsets_meta_value.IsStale()) {
       return Status::NotFound("Stale");
@@ -1218,6 +1235,7 @@ Status Redis::ZGetAll(const Slice& key, double weight, std::map<std::string, dou
   }
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_zsets_meta_value.Count());
     if (!parsed_zsets_meta_value.IsStale() && parsed_zsets_meta_value.Count() != 0) {
       int32_t cur_index = 0;
       int32_t stop_index = parsed_zsets_meta_value.Count() - 1;
@@ -1542,6 +1560,7 @@ Status Redis::ZRangebylex(const Slice& key, const Slice& min, const Slice& max,
   }
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_zsets_meta_value.Count());
     if (parsed_zsets_meta_value.IsStale() || parsed_zsets_meta_value.Count() == 0) {
       return Status::NotFound();
     } else {
@@ -1615,6 +1634,7 @@ Status Redis::ZRemrangebylex(const Slice& key, const Slice& min, const Slice& ma
   }
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
+
     if (parsed_zsets_meta_value.IsStale() || parsed_zsets_meta_value.Count() == 0) {
       return Status::NotFound();
     } else {
@@ -1731,6 +1751,7 @@ Status Redis::ZsetsDel(const Slice& key, std::string&& prefetch_meta) {
   }
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_zsets_meta_value.Count());
     if (parsed_zsets_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_zsets_meta_value.Count() == 0) {
@@ -1768,6 +1789,7 @@ Status Redis::ZsetsExpireat(const Slice& key, int64_t timestamp_millsec, std::st
   }
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_zsets_meta_value.Count());
     if (parsed_zsets_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_zsets_meta_value.Count() == 0) {
@@ -1816,6 +1838,7 @@ Status Redis::ZScan(const Slice& key, int64_t cursor, const std::string& pattern
   }
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_zsets_meta_value.Count());
     if (parsed_zsets_meta_value.IsStale() || parsed_zsets_meta_value.Count() == 0) {
       *next_cursor = 0;
       return Status::NotFound();
@@ -1893,6 +1916,7 @@ Status Redis::ZsetsPersist(const Slice& key, std::string&& prefetch_meta) {
   }
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_zsets_meta_value.Count());
     if (parsed_zsets_meta_value.IsStale()) {
       return Status::NotFound("Stale");
     } else if (parsed_zsets_meta_value.Count() == 0) {
@@ -1932,6 +1956,7 @@ Status Redis::ZsetsTTL(const Slice& key, int64_t* ttl_millsec, std::string&& pre
   }
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
+    CheckBigKeyAndLog(key.ToString(), parsed_zsets_meta_value.Count());
     if (parsed_zsets_meta_value.IsStale()) {
       *ttl_millsec = -2;
       return Status::NotFound("Stale");