Skip to content

Commit d2fd434

Browse files
brother-jinbrother-jin
committed
feat:big key metricx
1 parent fdcdd8f commit d2fd434

9 files changed

Lines changed: 118 additions & 1 deletion

File tree

‎src/pika_admin.cc‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1091,6 +1091,7 @@ void InfoCmd::InfoStats(std::string& info) {
10911091
tmp_stream << "is_compact:" << (g_pika_server->IsCompacting() ? "Yes" : "No") << "\r\n";
10921092
tmp_stream << "compact_cron:" << g_pika_conf->compact_cron() << "\r\n";
10931093
tmp_stream << "compact_interval:" << g_pika_conf->compact_interval() << "\r\n";
1094+
tmp_stream << "# Big Key Statistics\r\n";
10941095
time_t current_time_s = time(nullptr);
10951096
PikaServer::BGSlotsReload bgslotsreload_info = g_pika_server->bgslots_reload();
10961097
bool is_reloading = g_pika_server->GetSlotsreloading();
@@ -1372,6 +1373,7 @@ void InfoCmd::InfoData(std::string& info) {
13721373
uint64_t memtable_usage = 0;
13731374
uint64_t table_reader_usage = 0;
13741375
std::shared_lock db_rwl(g_pika_server->dbs_rw_);
1376+
uint64_t total_big_key_count = 0;
13751377
for (const auto& db_item : g_pika_server->dbs_) {
13761378
if (!db_item.second) {
13771379
continue;
@@ -1382,6 +1384,11 @@ void InfoCmd::InfoData(std::string& info) {
13821384
db_item.second->storage()->GetUsage(storage::PROPERTY_TYPE_ROCKSDB_CUR_SIZE_ALL_MEM_TABLES, &memtable_usage);
13831385
db_item.second->storage()->GetUsage(storage::PROPERTY_TYPE_ROCKSDB_ESTIMATE_TABLE_READER_MEM, &table_reader_usage);
13841386
db_item.second->storage()->GetUsage(storage::PROPERTY_TYPE_ROCKSDB_BACKGROUND_ERRORS, &background_errors);
1387+
1388+
uint64_t big_key_count = 0;
1389+
db_item.second->storage()->GetBigKeyStatistics("bigkey_property", &big_key_count);
1390+
total_big_key_count += big_key_count;
1391+
13851392
db_item.second->DBUnlockShared();
13861393
total_memtable_usage += memtable_usage;
13871394
total_table_reader_usage += table_reader_usage;
@@ -1401,6 +1408,7 @@ void InfoCmd::InfoData(std::string& info) {
14011408
tmp_stream << "db_tablereader_usage:" << total_table_reader_usage << "\r\n";
14021409
tmp_stream << "db_fatal:" << (total_background_errors != 0 ? "1" : "0") << "\r\n";
14031410
tmp_stream << "db_fatal_msg:" << (total_background_errors != 0 ? db_fatal_msg_stream.str() : "nullptr") << "\r\n";
1411+
tmp_stream << "big_key_count:" << total_big_key_count << "\r\n";
14041412

14051413
info.append(tmp_stream.str());
14061414
}

‎src/pika_server.cc‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -803,7 +803,6 @@ void PikaServer::PurgeDir(const std::string& path) {
803803
PurgeDirTaskSchedule(&DoPurgeDir, static_cast<void*>(dir_path));
804804
}
805805

806-
807806
void PikaServer::PurgeDirTaskSchedule(void (*function)(void*), void* arg) {
808807
purge_thread_.StartThread();
809808
purge_thread_.Schedule(function, arg);

‎src/storage/include/storage/storage.h‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1106,6 +1106,7 @@ class Storage {
11061106
Status GetUsage(const std::string& property, uint64_t* result);
11071107
Status GetUsage(const std::string& property, std::map<int, uint64_t>* type_result);
11081108
uint64_t GetProperty(const std::string& property);
1109+
Status GetBigKeyStatistics(const std::string& property, uint64_t* out);
11091110

11101111
Status GetKeyNum(std::vector<KeyInfo>* key_infos);
11111112
Status StopScanKeyNum();

‎src/storage/src/redis.h‎

Lines changed: 19 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -359,6 +359,22 @@ class Redis {
359359
void ScanZsets();
360360
void ScanSets();
361361

362+
void CheckBigKeyAndLog(const std::string& key, uint64_t size) {
363+
static const uint64_t kBigKeyThreshold = 10000;
364+
if (size > kBigKeyThreshold) {
365+
std::lock_guard<std::mutex> lock(big_key_access_mutex_);
366+
big_key_access_count_[key]++;
367+
std::cerr << "[BIGKEY DETECTED] Key: " << key
368+
<< ", Size: " << size
369+
<< ", Access Count: " << big_key_access_count_[key] << std::endl;
370+
}
371+
}
372+
373+
std::unordered_map<std::string, int> GetBigKeyStatistics() {
374+
std::lock_guard<std::mutex> lock(big_key_access_mutex_);
375+
return big_key_access_count_;
376+
}
377+
362378
TypeIterator* CreateIterator(const DataType& type, const std::string& pattern, const Slice* lower_bound, const Slice* upper_bound) {
363379
return CreateIterator(DataTypeTag[static_cast<int>(type)], pattern, lower_bound, upper_bound);
364380
}
@@ -538,6 +554,9 @@ class Redis {
538554
Status UpdateSpecificKeyStatistics(const DataType& dtype, const std::string& key, uint64_t count);
539555
Status UpdateSpecificKeyDuration(const DataType& dtype, const std::string& key, uint64_t duration);
540556
Status AddCompactKeyTaskIfNeeded(const DataType& dtype, const std::string& key, uint64_t count, uint64_t duration);
557+
558+
std::unordered_map<std::string, int> big_key_access_count_;
559+
std::mutex big_key_access_mutex_;
541560
};
542561

543562
} // namespace storage

‎src/storage/src/redis_hashes.cc‎

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -95,6 +95,7 @@ Status Redis::HDel(const Slice& key, const std::vector<std::string>& fields, int
9595
}
9696
if (s.ok()) {
9797
ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
98+
CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
9899
if (parsed_hashes_meta_value.IsStale() || parsed_hashes_meta_value.Count() == 0) {
99100
*ret = 0;
100101
return Status::OK();
@@ -159,6 +160,7 @@ Status Redis::HGet(const Slice& key, const Slice& field, std::string* value) {
159160
}
160161
if (s.ok()) {
161162
ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
163+
CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
162164
if (parsed_hashes_meta_value.IsStale()) {
163165
return Status::NotFound("Stale");
164166
} else if (parsed_hashes_meta_value.Count() == 0) {
@@ -199,6 +201,7 @@ Status Redis::HGetall(const Slice& key, std::vector<FieldValue>* fvs) {
199201
}
200202
if (s.ok()) {
201203
ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
204+
CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
202205
if (parsed_hashes_meta_value.IsStale()) {
203206
return Status::NotFound("Stale");
204207
} else if (parsed_hashes_meta_value.Count() == 0) {
@@ -242,6 +245,7 @@ Status Redis::HGetallWithTTL(const Slice& key, std::vector<FieldValue>* fvs, int
242245
}
243246
if (s.ok()) {
244247
ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
248+
CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
245249
if (parsed_hashes_meta_value.Count() == 0) {
246250
return Status::NotFound();
247251
} else if (parsed_hashes_meta_value.IsStale()) {
@@ -299,6 +303,7 @@ Status Redis::HIncrby(const Slice& key, const Slice& field, int64_t value, int64
299303
}
300304
if (s.ok()) {
301305
ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
306+
CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
302307
if (parsed_hashes_meta_value.IsStale() || parsed_hashes_meta_value.Count() == 0) {
303308
version = parsed_hashes_meta_value.UpdateVersion();
304309
parsed_hashes_meta_value.SetCount(1);
@@ -392,6 +397,7 @@ Status Redis::HIncrbyfloat(const Slice& key, const Slice& field, const Slice& by
392397
}
393398
if (s.ok()) {
394399
ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
400+
CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
395401
if (parsed_hashes_meta_value.IsStale() || parsed_hashes_meta_value.Count() == 0) {
396402
version = parsed_hashes_meta_value.UpdateVersion();
397403
parsed_hashes_meta_value.SetCount(1);
@@ -476,6 +482,7 @@ Status Redis::HKeys(const Slice& key, std::vector<std::string>* fields) {
476482
}
477483
if (s.ok()) {
478484
ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
485+
CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
479486
if (parsed_hashes_meta_value.IsStale()) {
480487
return Status::NotFound("Stale");
481488
} 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)
519526
}
520527
if (s.ok()) {
521528
ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
529+
CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
522530
if (parsed_hashes_meta_value.IsStale()) {
523531
*ret = 0;
524532
return Status::NotFound("Stale");
@@ -558,6 +566,7 @@ Status Redis::HMGet(const Slice& key, const std::vector<std::string>& fields, st
558566
}
559567
if (s.ok()) {
560568
ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
569+
CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
561570
if ((is_stale = parsed_hashes_meta_value.IsStale()) || parsed_hashes_meta_value.Count() == 0) {
562571
for (size_t idx = 0; idx < fields.size(); ++idx) {
563572
vss->push_back({std::string(), Status::NotFound()});
@@ -622,6 +631,7 @@ Status Redis::HMSet(const Slice& key, const std::vector<FieldValue>& fvs) {
622631
}
623632
if (s.ok()) {
624633
ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
634+
CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
625635
if (parsed_hashes_meta_value.IsStale() || parsed_hashes_meta_value.Count() == 0) {
626636
version = parsed_hashes_meta_value.InitialMetaValue();
627637
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
697707
}
698708
if (s.ok()) {
699709
ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
710+
CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
700711
if (parsed_hashes_meta_value.IsStale() || parsed_hashes_meta_value.Count() == 0) {
701712
version = parsed_hashes_meta_value.InitialMetaValue();
702713
parsed_hashes_meta_value.SetCount(1);
@@ -772,6 +783,7 @@ Status Redis::HSetnx(const Slice& key, const Slice& field, const Slice& value, i
772783
}
773784
if (s.ok()) {
774785
ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
786+
CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
775787
if (parsed_hashes_meta_value.IsStale() || parsed_hashes_meta_value.Count() == 0) {
776788
version = parsed_hashes_meta_value.InitialMetaValue();
777789
parsed_hashes_meta_value.SetCount(1);
@@ -835,6 +847,7 @@ Status Redis::HVals(const Slice& key, std::vector<std::string>* values) {
835847
}
836848
if (s.ok()) {
837849
ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
850+
CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
838851
if (parsed_hashes_meta_value.IsStale()) {
839852
return Status::NotFound("Stale");
840853
} 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
898911
}
899912
if (s.ok()) {
900913
ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
914+
CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
901915
if (parsed_hashes_meta_value.IsStale() || parsed_hashes_meta_value.Count() == 0) {
902916
*next_cursor = 0;
903917
return Status::NotFound();
@@ -975,6 +989,7 @@ Status Redis::HScanx(const Slice& key, const std::string& start_field, const std
975989
}
976990
if (s.ok()) {
977991
ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
992+
CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
978993
if (parsed_hashes_meta_value.IsStale() || parsed_hashes_meta_value.Count() == 0) {
979994
*next_field = "";
980995
return Status::NotFound();
@@ -1045,6 +1060,7 @@ Status Redis::PKHScanRange(const Slice& key, const Slice& field_start, const std
10451060
}
10461061
if (s.ok()) {
10471062
ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
1063+
CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
10481064
if (parsed_hashes_meta_value.IsStale() || parsed_hashes_meta_value.Count() == 0) {
10491065
return Status::NotFound();
10501066
} else {
@@ -1116,6 +1132,7 @@ Status Redis::PKHRScanRange(const Slice& key, const Slice& field_start, const st
11161132
}
11171133
if (s.ok()) {
11181134
ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
1135+
CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
11191136
if (parsed_hashes_meta_value.IsStale() || parsed_hashes_meta_value.Count() == 0) {
11201137
return Status::NotFound();
11211138
} else {
@@ -1178,6 +1195,7 @@ Status Redis::HashesExpire(const Slice& key, int64_t ttl_millsec, std::string&&
11781195
}
11791196
if (s.ok()) {
11801197
ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
1198+
CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
11811199
if (parsed_hashes_meta_value.IsStale()) {
11821200
return Status::NotFound("Stale");
11831201
} else if (parsed_hashes_meta_value.Count() == 0) {
@@ -1218,6 +1236,7 @@ Status Redis::HashesDel(const Slice& key, std::string&& prefetch_meta) {
12181236
}
12191237
if (s.ok()) {
12201238
ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
1239+
CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
12211240
if (parsed_hashes_meta_value.IsStale()) {
12221241
return Status::NotFound("Stale");
12231242
} else if (parsed_hashes_meta_value.Count() == 0) {
@@ -1255,6 +1274,7 @@ Status Redis::HashesExpireat(const Slice& key, int64_t timestamp_millsec, std::s
12551274
}
12561275
if (s.ok()) {
12571276
ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
1277+
CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
12581278
if (parsed_hashes_meta_value.IsStale()) {
12591279
return Status::NotFound("Stale");
12601280
} else if (parsed_hashes_meta_value.Count() == 0) {
@@ -1294,6 +1314,7 @@ Status Redis::HashesPersist(const Slice& key, std::string&& prefetch_meta) {
12941314
}
12951315
if (s.ok()) {
12961316
ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
1317+
CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
12971318
if (parsed_hashes_meta_value.IsStale()) {
12981319
return Status::NotFound("Stale");
12991320
} 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
13331354
}
13341355
if (s.ok()) {
13351356
ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
1357+
CheckBigKeyAndLog(key.ToString(), parsed_hashes_meta_value.Count());
13361358
if (parsed_hashes_meta_value.IsStale()) {
13371359
*ttl_millsec = -2;
13381360
return Status::NotFound("Stale");

‎src/storage/src/redis_lists.cc‎

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -79,6 +79,7 @@ Status Redis::LIndex(const Slice& key, int64_t index, std::string* element) {
7979
}
8080
if (s.ok()) {
8181
ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
82+
CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
8283
uint64_t version = parsed_lists_meta_value.Version();
8384
if (parsed_lists_meta_value.IsStale()) {
8485
return Status::NotFound("Stale");
@@ -123,6 +124,7 @@ Status Redis::LInsert(const Slice& key, const BeforeOrAfter& before_or_after, co
123124
}
124125
if (s.ok()) {
125126
ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
127+
CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
126128
if (parsed_lists_meta_value.IsStale()) {
127129
return Status::NotFound("Stale");
128130
} 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)
239241
}
240242
if (s.ok()) {
241243
ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
244+
CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
242245
if (parsed_lists_meta_value.IsStale()) {
243246
return Status::NotFound("Stale");
244247
} 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
274277
}
275278
if (s.ok()) {
276279
ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
280+
CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
277281
if (parsed_lists_meta_value.IsStale()) {
278282
return Status::NotFound("Stale");
279283
} 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
332336
}
333337
if (s.ok()) {
334338
ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
339+
CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
335340
if (parsed_lists_meta_value.IsStale() || parsed_lists_meta_value.Count() == 0) {
336341
version = parsed_lists_meta_value.InitialMetaValue();
337342
} else {
@@ -388,6 +393,7 @@ Status Redis::LPushx(const Slice& key, const std::vector<std::string>& values, u
388393
}
389394
if (s.ok()) {
390395
ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
396+
CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
391397
if (parsed_lists_meta_value.IsStale()) {
392398
return Status::NotFound("Stale");
393399
} 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<
432438
}
433439
if (s.ok()) {
434440
ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
441+
CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
435442
if (parsed_lists_meta_value.IsStale()) {
436443
return Status::NotFound("Stale");
437444
} 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::
492499
}
493500
if (s.ok()) {
494501
ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
502+
CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
495503
if (parsed_lists_meta_value.Count() == 0) {
496504
return Status::NotFound();
497505
} 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
561569
}
562570
if (s.ok()) {
563571
ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
572+
CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
564573
if (parsed_lists_meta_value.IsStale()) {
565574
return Status::NotFound("Stale");
566575
} else if (parsed_lists_meta_value.Count() == 0) {
@@ -693,6 +702,7 @@ Status Redis::LSet(const Slice& key, int64_t index, const Slice& value) {
693702
}
694703
if (s.ok()) {
695704
ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
705+
CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
696706
if (parsed_lists_meta_value.IsStale()) {
697707
return Status::NotFound("Stale");
698708
} else if (parsed_lists_meta_value.Count() == 0) {
@@ -737,6 +747,7 @@ Status Redis::LTrim(const Slice& key, int64_t start, int64_t stop) {
737747
}
738748
if (s.ok()) {
739749
ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
750+
CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
740751
uint64_t version = parsed_lists_meta_value.Version();
741752
if (parsed_lists_meta_value.IsStale()) {
742753
return Status::NotFound("Stale");
@@ -810,6 +821,7 @@ Status Redis::RPop(const Slice& key, int64_t count, std::vector<std::string>* el
810821
}
811822
if (s.ok()) {
812823
ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
824+
CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
813825
if (parsed_lists_meta_value.IsStale()) {
814826
return Status::NotFound("Stale");
815827
} 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
11181130
}
11191131
if (s.ok()) {
11201132
ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
1133+
11211134
if (parsed_lists_meta_value.IsStale()) {
11221135
return Status::NotFound("Stale");
11231136
} else if (parsed_lists_meta_value.Count() == 0) {
@@ -1158,6 +1171,7 @@ Status Redis::ListsDel(const Slice& key, std::string&& prefetch_meta) {
11581171
}
11591172
if (s.ok()) {
11601173
ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
1174+
CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
11611175
if (parsed_lists_meta_value.IsStale()) {
11621176
return Status::NotFound("Stale");
11631177
} else if (parsed_lists_meta_value.Count() == 0) {
@@ -1195,6 +1209,7 @@ Status Redis::ListsExpireat(const Slice& key, int64_t timestamp_millsec, std::st
11951209
}
11961210
if (s.ok()) {
11971211
ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
1212+
CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
11981213
if (parsed_lists_meta_value.IsStale()) {
11991214
return Status::NotFound("Stale");
12001215
} else if (parsed_lists_meta_value.Count() == 0) {
@@ -1234,6 +1249,7 @@ Status Redis::ListsPersist(const Slice& key, std::string&& prefetch_meta) {
12341249
}
12351250
if (s.ok()) {
12361251
ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
1252+
CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
12371253
if (parsed_lists_meta_value.IsStale()) {
12381254
return Status::NotFound("Stale");
12391255
} 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
12731289
}
12741290
if (s.ok()) {
12751291
ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
1292+
CheckBigKeyAndLog(key.ToString(), parsed_lists_meta_value.Count());
12761293
if (parsed_lists_meta_value.IsStale()) {
12771294
*ttl_millsec = -2;
12781295
return Status::NotFound("Stale");

0 commit comments

Comments
 (0)