feat(monitoring): add GC stats to CS charts

This commit introduces a chunkserver-side feature to display
Garbage Collector(GC) deletions per minute in the CGI chart of
the chunkserver(CS).

Apply formatting to function" to chartsdata_refresh function.

Signed-off-by: GigaCronos <jorge.cabrera@leil.io>

fa

Author: GigaCronos

src/cgi/sfs.cgi.in

@@ -3235,6 +3235,7 @@ if "CC" in sectionset:
             (21, 'create', 'number of chunk creations per minute'),
             (22, 'delete', 'number of chunk deletions per minute'),
             (27, 'tests', 'number of chunk tests per minute'),
+            (31, 'gcpurge', 'number of chunk purged by GC per minute'),
         )
         servers = []
 

src/chunkserver/chartsdata.cc

@@ -75,8 +75,9 @@
 #define CHARTS_CHUNKIOJOBS 28
 #define CHARTS_CHUNKOPJOBS 29
 #define CHARTS_MEMORY 30
+#define CHARTS_GC_PURGE 31
 
-#define CHARTS_NUMBER 31
+#define CHARTS_NUMBER 32
 
 const unsigned long kLinuxMaxrssSize = 1024UL;
 
@@ -113,6 +114,7 @@ const unsigned long kLinuxMaxrssSize = 1024UL;
 	{"chunkiojobs"      ,CHARTS_MODE_MAX,0,CHARTS_SCALE_NONE ,   1, 1}, \
 	{"chunkopjobs"      ,CHARTS_MODE_MAX,0,CHARTS_SCALE_NONE ,   1, 1}, \
 	{"memory"           ,CHARTS_MODE_MAX,0,CHARTS_SCALE_NONE ,   1, 1}, \
+	{"gcpurge"          ,CHARTS_MODE_ADD,0,CHARTS_SCALE_NONE ,   1, 1}, \
 	{NULL               ,0              ,0,0                 ,   0, 0}  \
 };
 
@@ -165,7 +167,7 @@ void chartsdata_refresh(void) {
 	uint64_t bytesIn, bytesOut, totalBytesRead, totalBytesWrite;
 	uint32_t opsRead, opsWrite, totalOpsRead, totalOpsWrite, replications = 0;
 	uint32_t opsCreate, opsDelete, opsUpdateVersion, opsDuplicate, opsTruncate;
-	uint32_t opsDupTrunc, opsTest;
+	uint32_t opsDupTrunc, opsTest, opsGCPurge;
 	uint32_t maxChunkServerJobsCount, maxMasterJobsCount;
 
 	// Timer runs only when the process is executing.
@@ -177,12 +179,10 @@ void chartsdata_refresh(void) {
 
 	uint32_t userTimeMicroSeconds, procTimeMicroSeconds;
 
-	for (auto i = 0; i < CHARTS_NUMBER; ++i) {
-		data[i] = 0;
-	}
+	for (auto i = 0; i < CHARTS_NUMBER; ++i) { data[i] = 0; }
 
-	setitimer(ITIMER_VIRTUAL, &it_set, &userTime); // user time
-	setitimer(ITIMER_PROF, &it_set, &procTime);    // user time + system time
+	setitimer(ITIMER_VIRTUAL, &it_set, &userTime);  // user time
+	setitimer(ITIMER_PROF, &it_set, &procTime);     // user time + system time
 
 	// on fucken linux timers can go backward !!!
 	if (userTime.it_value.tv_sec <= 999) {
@@ -223,18 +223,16 @@ void chartsdata_refresh(void) {
 	data[CHARTS_CSCONNIN] = 0;
 	data[CHARTS_CSCONNOUT] = 0;
 
-	networkStats(&bytesIn, &bytesOut, &opsRead, &opsWrite,
-	             &maxChunkServerJobsCount);
+	networkStats(&bytesIn, &bytesOut, &opsRead, &opsWrite, &maxChunkServerJobsCount);
 	data[CHARTS_CSSERVIN] = bytesIn;
 	data[CHARTS_CSSERVOUT] = bytesOut;
 	data[CHARTS_CHUNKIOJOBS] = maxChunkServerJobsCount;
 	data[CHARTS_HLOPR] = opsRead;
 	data[CHARTS_HLOPW] = opsWrite;
 
-	HddStats::stats(HddStats::statsReport(
-	    &bytesIn, &bytesOut, &opsRead, &opsWrite, &totalBytesRead,
-	    &totalBytesWrite, &totalOpsRead, &totalOpsWrite,
-	    data + CHARTS_TOTAL_RTIME, data + CHARTS_TOTAL_WTIME));
+	HddStats::stats(HddStats::statsReport(&bytesIn, &bytesOut, &opsRead, &opsWrite, &totalBytesRead,
+	                                      &totalBytesWrite, &totalOpsRead, &totalOpsWrite,
+	                                      data + CHARTS_TOTAL_RTIME, data + CHARTS_TOTAL_WTIME));
 	data[CHARTS_OVERHEAD_BYTESR] = bytesIn;
 	data[CHARTS_OVERHEAD_BYTESW] = bytesOut;
 	data[CHARTS_OVERHEAD_LLOPR] = opsRead;
@@ -245,16 +243,16 @@ void chartsdata_refresh(void) {
 	data[CHARTS_TOTAL_LLOPW] = totalOpsWrite;
 	data[CHARTS_REPL] = replications + gReplicator.getStats();
 
-	HddStats::operationStats(&opsCreate, &opsDelete, &opsUpdateVersion,
-	                         &opsDuplicate, &opsTruncate, &opsDupTrunc,
-	                         &opsTest);
+	HddStats::operationStats(&opsCreate, &opsDelete, &opsUpdateVersion, &opsDuplicate, &opsTruncate,
+	                         &opsDupTrunc, &opsTest, &opsGCPurge);
 	data[CHARTS_CREATE] = opsCreate;
 	data[CHARTS_DELETE] = opsDelete;
 	data[CHARTS_VERSION] = opsUpdateVersion;
 	data[CHARTS_DUPLICATE] = opsDuplicate;
 	data[CHARTS_TRUNCATE] = opsTruncate;
 	data[CHARTS_DUPTRUNC] = opsDupTrunc;
 	data[CHARTS_TEST] = opsTest;
+	data[CHARTS_GC_PURGE] = opsGCPurge;
 
 	charts_add(data, eventloop_time() - SECONDS_IN_ONE_MINUTE);
 }

src/chunkserver/chunkserver-common/chunk_trash_manager_impl.cc

@@ -25,6 +25,7 @@
 #include "chunkserver-common/chunk_trash_manager_impl.h"
 #include "config/cfg.h"
 #include "errors/saunafs_error_codes.h"
+#include "hdd_stats.h"
 #include "slogger/slogger.h"
 
 namespace fs = std::filesystem;
@@ -161,6 +162,7 @@ void ChunkTrashManagerImpl::removeTrashFiles(
 	for (const auto &[diskPath, fileEntries] : filesToRemove) {
 		for (const auto &fileEntry : fileEntries) {
 			if (removeFileFromTrash(fileEntry.second) != SAUNAFS_STATUS_OK) { continue; }
+			HddStats::gStatsOperationsGCPurge++;
 			getTrashIndex().remove(fileEntry.first, fileEntry.second, diskPath);
 		}
 	}

src/chunkserver/chunkserver-common/hdd_stats.cc

@@ -19,6 +19,7 @@
 #include "common/platform.h"
 
 #include "chunkserver-common/hdd_stats.h"
+#include <cstdint>
 
 #include "chunkserver-common/disk_interface.h"
 #include "devtools/TracePrinter.h"
@@ -83,10 +84,9 @@ void stats(statsReport report) {
 	*report.totalWriteTime = gStatsTotalTimeWrite.exchange(0);
 }
 
-void operationStats(uint32_t *opsCreate, uint32_t *opsDelete,
-                    uint32_t *opsUpdateVersion, uint32_t *opsDuplicate,
-                    uint32_t *opsTruncate, uint32_t *opsDupTrunc,
-                    uint32_t *opsTest) {
+void operationStats(uint32_t *opsCreate, uint32_t *opsDelete, uint32_t *opsUpdateVersion,
+                    uint32_t *opsDuplicate, uint32_t *opsTruncate, uint32_t *opsDupTrunc,
+                    uint32_t *opsTest, uint32_t *opsGCPurge) {
 	TRACETHIS();
 	*opsCreate = gStatsOperationsCreate.exchange(0);
 	*opsDelete = gStatsOperationsDelete.exchange(0);
@@ -95,6 +95,7 @@ void operationStats(uint32_t *opsCreate, uint32_t *opsDelete,
 	*opsDuplicate = gStatsOperationsDuplicate.exchange(0);
 	*opsTruncate = gStatsOperationsTruncate.exchange(0);
 	*opsDupTrunc = gStatsOperationsDupTrunc.exchange(0);
+	*opsGCPurge = gStatsOperationsGCPurge.exchange(0);
 }
 
 void overheadRead(uint32_t size) {

src/chunkserver/chunkserver-common/hdd_stats.h

@@ -56,6 +56,8 @@ inline std::atomic<uint32_t> gStatsOperationsDuplicate(0);
 inline std::atomic<uint32_t> gStatsOperationsTruncate(0);
 inline std::atomic<uint32_t> gStatsOperationsDupTrunc(0);
 
+inline std::atomic<uint32_t> gStatsOperationsGCPurge(0);
+
 struct statsReport {
 	statsReport(uint64_t *overBytesRead, uint64_t *overBytesWrite,
 	            uint32_t *overOpsRead, uint32_t *overOpsWrite,
@@ -99,7 +101,7 @@ void stats(statsReport report);
 void operationStats(uint32_t *opsCreate, uint32_t *opsDelete,
                     uint32_t *opsUpdateVersion, uint32_t *opsDuplicate,
                     uint32_t *opsTruncate, uint32_t *opsDupTrunc,
-                    uint32_t *opsTest);
+                    uint32_t *opsTest, uint32_t *opsGCPurge);
 
 void overheadRead(uint32_t size);
 void overheadWrite(uint32_t size);