बड़े अनुप्रयोगों के लिए सी में एक कस्टम लॉगिंग सिस्टम बनाना

कोर डिजाइन विचार

किसी भी कोड को लिखने से पहले, अपने लॉगिंग सिस्टम के मुख्य घटकों को परिभाषित करें। ये निर्णय एपीआई डिज़ाइन से रनटाइम प्रदर्शन तक सब कुछ आकार देते हैं।

लॉग स्तर

गंभीरता के स्तर को परिभाषित करें जो आवेदन की आवश्यकताओं के लिए मानचित्रित हैं। आम स्तरों में , , ], ], , और शामिल हैं। प्रकार सुरक्षा सुनिश्चित करने के लिए [FLT: 10]]] का प्रयोग करें। प्रत्येक स्तर में न्यूनतम सीमा होनी चाहिए; सीमा के नीचे संदेश को उत्पादन में ओवरहेड को कम करने के लिए अनदेखा किया जाता है।

लॉग गंतव्य

विचार करें कि लॉग कहाँ लिखा जाएगा। विशिष्ट गंतव्य हैं:

• Console – विकास और त्वरित डीबगिंग के लिए।
• File – डिस्क स्थान का प्रबंधन करने के लिए रोटेशन और अभिलेखीय के साथ।
• Syslog - यूनिक्स प्रणालियों पर केंद्रीकृत लॉगिंग के लिए।
• Network] – UDP या TCP सॉकेट दूरस्थ एकत्रीकरण के लिए (जैसे ग्रेलोग, ELK स्टैक)।

एक अच्छी तरह से डिजाइन किए गए लॉगर एक सिंक अमूर्तता का उपयोग करता है जो आपको रनटाइम पर गंतव्यों को जोड़ने या हटाने की अनुमति देता है।

स्वरूपण और कन्वेंशन

स्थिरता को बनाए रखने के लिए एक लॉग प्रारूप पर निर्णय लें। एक विशिष्ट प्रारूप में एक टाइमस्टैम्प, लॉग लेवल, सोर्स फाइल / लाइन, मॉड्यूल नाम और संदेश शामिल है। JSON जैसे संरचित प्रारूप स्वचालित पार्सिंग को सरल बनाते हैं लेकिन ओवरहेड जोड़ते हैं। प्रदर्शन के लिए, एक निश्चित क्षेत्र के सीमक (जैसे, पाइप या टैब) का उपयोग करें और गर्म पथ में गतिशील मेमोरी आवंटन से बचें।

थ्रेड सुरक्षा

बहुधा अनुप्रयोगों में, समवर्ती लिखते हैं कि garbled उत्पादन का उत्पादन कर सकते हैं। वास्तविक I/O ऑपरेशन के आसपास एक महत्वपूर्ण अनुभाग (विंडोज पर) का उपयोग करें। उच्च throughput के लिए, एक लॉक-फ्री कतार या प्रति-थ्रेड लॉगिंग बफर पर विचार करें जो समय-समय पर फ्लश हो।

एक बुनियादी लकड़हारा कार्यान्वयन

एक सरल कार्यान्वयन के साथ शुरू करें जो अनिवार्यता को कवर करता है: लॉग स्तर, टाइमस्टैम्प प्रारूपण और परिवर्तनीय-एर्गमेंट संदेश निर्माण। निम्नलिखित कोड एक नींव प्रदान करता है।

लॉग लेवल एनम और हेल्पर फंक्शन

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <time.h>
#include <pthread.h>

typedef enum {
 LOG_LEVEL_TRACE,
 LOG_LEVEL_DEBUG,
 LOG_LEVEL_INFO,
 LOG_LEVEL_WARN,
 LOG_LEVEL_ERROR,
 LOG_LEVEL_FATAL
} LogLevel;

static const char* level_strings[] = {
 "TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL"
};

static LogLevel g_min_level = LOG_LEVEL_INFO;
static pthread_mutex_t g_log_mutex = PTHREAD_MUTEX_INITIALIZER;

संदेश स्वरूपण

कोर लॉगिंग फंक्शन (FLT:13) का उपयोग करता है ताकि संदेश को सुरक्षित रूप से प्रारूपित किया जा सके। एक स्थिर बफर गर्म पथ में ढेर आवंटन से बचा जाता है, लेकिन बहुत लंबे संदेशों के लिए बफर ओवरफ्लो के बारे में सोचना।

void log_message(LogLevel level, const char* file, int line, const char* func, const char* format, ...) {
 if (level < g_min_level) return;

 time_t now = time(NULL);
 struct tm* tm_info = localtime(&now);
 char time_buf[20];
 strftime(time_buf, sizeof(time_buf), "%Y-%m-%d %H:%M:%S", tm_info);

 pthread_mutex_lock(&g_log_mutex);

 // Write header
 fprintf(stdout, "[%s] [%s] [%s:%d %s] ", time_buf, level_strings[level], file, line, func);

 va_list args;
 va_start(args, format);
 vfprintf(stdout, format, args);
 va_end(args);

 fprintf(stdout, "\n");
 fflush(stdout); // Ensure immediate output for debugging

 pthread_mutex_unlock(&g_log_mutex);
}

सुविधा के लिए, मैक्रो को परिभाषित करें जो स्वचालित रूप से स्रोत फ़ाइल और लाइन को कैप्चर करते हैं:

#define LOG_TRACE(...) log_message(LOG_LEVEL_TRACE, __FILE__, __LINE__, __func__, __VA_ARGS__)
#define LOG_DEBUG(...) log_message(LOG_LEVEL_DEBUG, __FILE__, __LINE__, __func__, __VA_ARGS__)
// ... similar for INFO, WARN, ERROR, FATAL

उपयोग उदाहरण:

int main() {
 LOG_INFO("Application started on port %d", 8080);
 LOG_WARN("Disk usage exceeding %.1f%%", 85.3);
 LOG_ERROR("Failed to open file: %s", "config.dat");
 return 0;
}

फ़ाइल आउटपुट और रोटेशन जोड़ना

कंसोल उत्पादन विकास के दौरान उपयोगी है, लेकिन उत्पादन प्रणालियों को लगातार लॉग की आवश्यकता होती है। एक फ़ाइल सिंक जोड़ें जो लॉग फ़ाइलों के घूर्णन सेट पर लिखता है।

फ़ाइल लॉगिंग

एक फ़ाइल सूचक के साथ लॉगर को विस्तारित करें। आप या तो एक पथ को हार्ड-कोड कर सकते हैं या इसे कॉन्फ़िगर करने योग्य बना सकते हैं। एक ही mutex फ़ाइल लिखने की रक्षा करता है।

static FILE* g_log_file = NULL;

int log_init_file(const char* path) {
 g_log_file = fopen(path, "a");
 return (g_log_file != NULL) ? 0 : -1;
}

void log_message_file(LogLevel level, const char* file, int line, const char* func, const char* format, ...) {
 // Same timestamp and header logic, but write to g_log_file
 // ...
}

लॉग रोटेशन रणनीति

सभी डिस्क स्थान को लेने से लॉग फ़ाइलों को रोकने के लिए, फ़ाइल आकार, तारीख या दोनों के आधार पर घूर्णन को लागू करें।

• प्रत्येक लिखने के बाद (या समय-समय पर) ] की जाँच करके वर्तमान फ़ाइल आकार को ट्रैक करें।
• जब फ़ाइल एक थ्रेसहोल्ड से अधिक हो जाती है (उदाहरण के लिए, 100 MB), इसका नाम बदलकर (] → ], फिर पुरानी फ़ाइलों को संपीड़ित करें) और एक ताजा को फिर से खोल दें।
• अधिकतम संख्या में घुमाए गए फ़ाइलों को रखें; सबसे पुराना हटा दें।

उदाहरण कंकाल:

void log_rotate_if_needed() {
 if (g_log_file && ftell(g_log_file) > MAX_LOG_SIZE) {
 fclose(g_log_file);
 // Rename and compress logic
 g_log_file = fopen(LOG_PATH, "a");
 }
}

प्रदर्शन के लिए अतुल्यकालिक लॉगिंग

प्रत्यक्ष I/O गर्म पथ में धागे को अवरुद्ध कर सकता है और प्रदर्शन को कम कर सकता है। अतुल्यकालिक लॉगिंग डिस्क या नेटवर्क से संदेश स्वरूपण को निर्माता-उपभोक्ता कतार का उपयोग करके लिखता है।

निर्माता-उपभोक्ता पैटर्न

एक सीमित रिंग बफर या लॉक-फ्री कतार (जैसे, या एक साधारण लिंक्ड सूची का उपयोग लॉग संदेशों को स्टोर करने के लिए करें। एक समर्पित धागा कतार को फ्लश करता है।

लाभ:

• आवेदन धागे कभी I/O के लिए इंतजार नहीं करते।
• ड्रॉप्ड संदेश को कृपापूर्वक संभाला जा सकता है (उदाहरण के लिए, एक काउंटर में वृद्धि).
• बैचिंग लिखते हैं कि सिस्टम कॉल ओवरहेड को कम करता है।

कार्यान्वयन स्केच

#define QUEUE_SIZE 8192
static char g_log_queue[QUEUE_SIZE][MAX_LOG_LINE];
static volatile int g_queue_head = 0, g_queue_tail = 0;
static pthread_mutex_t g_queue_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t g_queue_notify = PTHREAD_COND_INITIALIZER;

void push_log(const char* logline) {
 pthread_mutex_lock(&g_queue_mutex);
 // Copy and advance head (ring buffer)
 strncpy(g_log_queue[g_queue_head], logline, MAX_LOG_LINE);
 g_queue_head = (g_queue_head + 1) % QUEUE_SIZE;
 pthread_cond_signal(&g_queue_notify);
 pthread_mutex_unlock(&g_queue_mutex);
}

void* log_flush_thread(void* arg) {
 while (1) {
 pthread_mutex_lock(&g_queue_mutex);
 while (g_queue_head == g_queue_tail)
 pthread_cond_wait(&g_queue_notify, &g_queue_mutex);
 // Dequeue and write to file/console
 char buffer[MAX_LOG_LINE];
 strncpy(buffer, g_log_queue[g_queue_tail], MAX_LOG_LINE);
 g_queue_tail = (g_queue_tail + 1) % QUEUE_SIZE;
 pthread_mutex_unlock(&g_queue_mutex);
 // Perform I/O (protected by the same file mutex)
 fputs(buffer, g_log_file);
 }
 return NULL;
}

उन्नत सुविधाएँ

एक बार जब बुनियादी प्रणाली चालू हो जाती है, तो इन वृद्धिओं को बड़े अनुप्रयोगों के लिए विचार करें।

संरचित लॉगिंग (JSON)

संरचित लॉग स्वचालित विश्लेषण सक्षम करते हैं। ऑब्जेक्ट बनाने के लिए एक हल्के JSON पुस्तकालय जैसे cJSON] का उपयोग करें। उदाहरण प्रारूप:

{"timestamp":"2025-03-20T10:15:30Z","level":"ERROR","module":"auth","message":"Login failed","user":"john"}

जबकि क्रिया, यह प्रारूप सहज रूप से लोचदार खोज और स्प्लंक जैसे उपकरणों के साथ एकीकृत करता है।

रिमोट लॉगिंग के माध्यम से Syslog या नेटवर्क

वितरित प्रणालियों के लिए, एक केंद्रीय कलेक्टर को आगे लॉग करता है। POSIX फ़ंक्शन (]मैन पेज ) सीधी लेकिन सीमित है। वैकल्पिक रूप से, UDP डेटाग्राम को ग्रेलॉग या लॉगस्टैश एंडपॉइंट में भेज दें।

विन्यास फ़ाइल

ऑपरेटरों को लॉगिंग पैरामीटर को बिना किसी रिकॉम्पिलिंग के ट्वीक करने की अनुमति दें: लॉग स्तर, फ़ाइल पथ, रोटेशन का आकार और आउटपुट गंतव्य। एक सरल INI-शैली फ़ाइल पार्स करें या पर्यावरण चर का उपयोग करें। कॉन्फ़िगरेशन को एक संकेत (जैसे, ]] के माध्यम से पुनः लोड किया जा सकता है।

सर्वश्रेष्ठ अभ्यास और पिटफॉल

आम गलतियों से बचें जो लॉगिंग के मूल्य को कम करते हैं।

प्रदर्शन ओवरहेड

लॉगिंग एक बछड़े नहीं होना चाहिए। हमेशा तर्क स्वरूपण से पहले लॉग स्तर की जांच करें। उस स्तर का मूल्यांकन करने वाले मैक्रोज़ का उपयोग करें। से बचने के लिए महत्वपूर्ण पथ में; बजाय स्टैक बफर का उपयोग करें।

सुरक्षा चिंताएं

कभी भी पासवर्ड, क्रेडिट कार्ड नंबर, या व्यक्तिगत डेटा जैसी संवेदनशील जानकारी लॉग नहीं करते। उपयोगकर्ता इनपुट को साइट्रेट करें और उत्पादन निर्माण में फ़ील्ड को रिडीकेट करें। इसके अलावा, लॉग फ़ाइलों को अनधिकृत एक्सेस से सुरक्षित रखें।

संगति के पार मॉड्यूल

एक कंपनी को व्यापक लॉगिंग सम्मेलन स्थापित करें। अद्वितीय मॉड्यूल उपसर्ग (जैसे, [[FLT: 29]]], [[FLT: 30]]]) और एक मानक टाइमस्टैम्प प्रारूप (UTC को वितरित प्रणालियों के लिए प्राथमिकता दी जाती है) का उपयोग करें। लॉग प्रारूप को दस्तावेज़ करें ताकि ऑपरेशन टीमों को इसे विश्वसनीय रूप से पार कर सकें।

निष्कर्ष

C में एक कस्टम लॉगिंग सिस्टम बड़े पैमाने पर अनुप्रयोगों के लिए लचीलापन और प्रदर्शन की आवश्यकता प्रदान करता है। एक ठोस डिजाइन से शुरू होता है जिसमें लॉग स्तर, सिंक, थ्रेड सेफ्टी और प्रारूपण शामिल होते हैं, आप धीरे-धीरे सिंक्रोनस आउटपुट, संरचित लॉग और रिमोट अग्रेषण जैसी उन्नत सुविधाओं को जोड़ सकते हैं। इस लेख में उदाहरण एक नींव के रूप में काम करते हैं - उन्हें अपने विशिष्ट वातावरण में ले जाते हैं, और हमेशा ओवरहेड को मापते हैं। सावधानीपूर्वक कार्यान्वयन के साथ, लॉगिंग एक प्रदर्शन नाली के बजाय एक शक्तिशाली संपत्ति बन जाती है। आगे पढ़ने के लिए, pthreads मैन पेज ] पर और सी मानक पुस्तकालय प्रलेखन ]]]]]] पर।