Sa mga aplikasyong malaki-scale C, ang pagtotroso ay isang kritikal na kasangkapan para sa pag-alis, pagsubaybay, at pagpapanatili ng sistemang pangkalusugan. Habang ang mga pangunahing pangungusap o aklatan na katulad ng ay maaaring sapat na para sa mga maliliit na proyekto, ang mga ito ay kadalasang nagkukulang kapag ang pagsasagawa, pag-aangkop, at pag-aasal na pangkaligtasan ay nagiging mga hindi-negotipibong kahilingan. Ang pagbuo ng isang sistema ng pag-iinsip na na na na na na naangkop sa iyong application'sload ay nagbibigay sa iyo ng tiyak na kontrol sa mga antas ng log, output, format, at ang mga sekretang pangkaligtasang artikulo ay nagiging mga hindi-intiploid na mga hakbang at pagdidisenyo ng mga praktikal na mga gawaingruture na pang-produksiyon, at mga gawaing pang-produksiyon, at mga gawaing pang-produkrement na may mga praktikal na pang-produksiyon, at pang-produksiyon, at pang-produksiyon, mga gawaing pang-produksiyon, at pang-produksiyon, at pang-produksiyon, mga

Kung Bakit Kailangang Gumawa ng Isang Kaugaliang Sistema ng Pag - aalis ng Lagpong

Ang mga mekanismo ng pamantayang pagtotroso, tulad ng o ang ⁇ X API, ay kadalasang kulang sa granularidad at pagganap na kinakailangan ng malalaking aplikasyon. Ang isang custom loger ay nag-aalok:

  • ] Optimized performance: Iwasan ang hindi kinakailangang mga allocation at formating kapag napigil ang mga antas ng log.
  • Flexible formating: Ang mga hindi nagbabagong timestamp, sinulid na mga identifier, at module prefix ay nagpapabuti sa pagiging madaling basahin ng log at parsing.
  • Granular control: Entable/disable espesipikong mga antas ng log sa runtime nang hindi muling nag-e-comping.
  • Mga destinasyong pang-Multiple: Isulat sa console, files, network kits, o mga panlabas na sistemang sumusubaybay nang sabay-sabay.
  • Thread safety: Gumamit ng mga plaza o operasyong atomiko upang maiwasan ang interleband output sa mga aplikasyong multi-readed.

Mga Pag - aaral Tungkol sa Disenyo ng Core

Bago isulat ang anumang code, bigyang - kahulugan ang pangunahing mga bahagi ng iyong sistema ng pagtotroso, at ang mga desisyong ito ang humubog sa lahat ng bagay mula sa disenyo ng API hanggang sa pagtakbo nang matagal.

Mga Bilog na Bigas

Ang mga antas ng kalubhaan na nagreresulta sa mga pangangailangan ng aplikasyon., , , , , , at . Gamitin ang upang matiyak ang kaligtasan ng tipo. Ang bawat isa ay dapat magkaroon ng pinakamababang pagsisimula; ang mga mensahe ay hindi pinapansin sa itaas upang mabawasan ang pagpasok sa produksiyon.

Makatuwirang mga Pag - aalis

Tingnan kung saan isusulat ang mga troso.

  • Console – para sa pagpapaunlad at mabilisang pag-atake.
  • File – na may rotasyon at archival upang pangasiwaan ang disk space.
  • [Syslog – para sa sentralisadong pagtotroso sa mga sistemang Unix.
  • – UDP o TCP ⁇ para sa malayong agregasyon (e.g., Graylog, ELK stack).

Ang isang mahusay-na-signed loger ay gumagamit ng isang sincrection na nagpapahintulot sa iyo na magdagdag o makapagtanggal ng mga destinasyon sa oras ng pagtakbo.

Pagmamamarka at mga Kombensiyon

Ang isang karaniwang format ay may timestamp, log level, source file/line, module na pangalan, at mensahe. Structured formats tulad ng JON scippy recombined parsing ngunit i-read up. Para sa pagganap, gumamit ng isang nakapirmeng glovafield deliter (e.g., tubo o tab) at iwasan ang dynamic memory allocation sa mga mainit na landas.

Likas na Kaligtasan

Sa mga aplikasyong multithreaded, ang concurrent na pagsusulat ay maaaring lumikha ng shirded output. Gamitin ang isang (sa mga sistemang pang-executeX) o isang kritikal na seksyon (sa Windows) sa paligid ng aktuwal na I/O operasyon. Para sa mas mataas na pag-uugali, isaalang-alang ang isang lock free queue o bawat quarthing mga coventition liver na pinasisingaw-ulantures paminsan-minsan.

Pag - aalis ng Isang Pangunahing Logger

Magsimula sa isang simpleng pagpapatupad na sumasaklaw sa mga kinakailangan: antas ng troso, timestamp formating, at iba't ibang paggawa ng mensahe sa pamamagitan ng calvargument.

Dahon ng Bilog at Katulong na mga Katuwaan

#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;

Nakapagpapasiglang Mensahe

Ginagamit ng core pagtotroso ang para mabuo ang mensahe at maiwasang magtambak ng allocation sa mainit na daan, pero huwag mag - alala kung gaano katagal mag - uumapaw ang mga ito.

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);
}

Para sa kaginhawahan, bigyang kahulugan ang mga macro na kusang kumukuha sa source file at linya:

#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

Halimbawa:

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;
}

Pagdaragdag ng File output at Rotation

Ang konole output ay kapaki - pakinabang sa panahon ng paggawa, pero kailangan ng mga sistema ng produksiyon ang di - nagbabagong troso.

Pag - eempleo ng File

Pahabain ang loger na may pointer ng file. Maaari mong hard greycode ang isang landas o gawin itong maaaring baguhin. Ang lopx ding ito ang nagpoprotekta sa talaksan.

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
 // ...
}

Mga Estratehiya ng Log Rotation

Upang maiwasang makonsumo ng mga talaksang logo ang lahat ng espasyong disk, ipatupad ang pag-ikot batay sa sukat ng talaksan, petsa, o parehong ito. Isang payak na estratehiya:

  • Tingnan ang kasalukuyang sukat ng talaksan sa pamamagitan ng pagsusuri matapos ang bawat pagsulat (o pana-panahon).
  • Kapag ang talaksan ay lumampas sa isang pasukan (hal., 100 MB), palitan ito ng pangalan ( → , pagkatapos ay i-scream ang mga lumang file) at muling buksan ang isang bago .
  • Maglagay ng pinakamaraming umiikot na file; i - delete ang pinakamatanda.

Halimbawang kalansay:

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");
 }
}

May - Pag - aatubiling Pandarambong Para sa Performance

Ang direksiyong I/O sa mainit na landas ay maaaring harangin ang mga sinulid at pababain ang pagganap. Ang Asynchronous pagtotroso ay nagreresulta sa mensahe na nag-recouples na nag-recouple mula sa disk o network ay sumusulat gamit ang isang producer na calconsumer queue.

Disenyo ng Produser-Consumer

Gumamit ng isang nakakunektang ring linggang o isang kandadong lock free queue (e.g., o isang simpleng kaugnay na talaan na may unx) upang mag - imbak ng mga mensaheng log. Isang dedikadong sinulid ang nag - aalis ng queue.

Mga Pakinabang:

  • Ang mga sinulid na pang-edukasyon ay hindi kailanman naghihintay sa I/O.
  • Ang mga mensaheng naihuhulog ay maaaring hawakan nang maganda (hal.g., lagyan ng inkretong counter).
  • Ang pag - aalis ng sulat ay nakababawas sa pag - ahon ng sistema sa itaas.

Pag - urong ng Implementasyon

#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;
}

Patiunang mga Katangian

Minsang gumana ang pangunahing sistema, isaalang - alang ang mga pagpapainam na ito para sa mas malalaking aplikasyon.

Pag - iikid ng Lagsing (JSON)

Gumamit ng magaang na aklatan ng JONS tulad ng cJSON[ upang makagawa ng mga bagay.

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

Samantalang ang verose, ang format na ito ay walang - tigil na nag - uugnay sa mga kagamitang gaya ng Elasticse at Splunk.

Malayong Paninirahan sa Pamamagitan ng Sislog o Network

Para sa mga sistemang ipinamamahagi, pasulong na troso sa isang gitnang kolektor. function (man page) ay tuwiran ngunit limitado. alternatibo, magpadala ng UDP datagrams sa isang Graylog o Logstash endpoint gamit ang mga hilaw na stage.

Ang Bukál ng Pagkukompromiso

Hayaang i-recombinan ng mga operator ang mga indibidwal na mga forget nang hindi muling nag-eee - recombinan: log level, file path path, at output destinasyon. Parse isang simpleng INIstyle file o gamitin ang mga variables sa kapaligiran. Ang configuration ay maaaring muling ikarga sa pamamagitan ng isang signal (e.g., ).

Pinakamabuting mga Gawain at mga Patibong

Iwasan ang karaniwang mga pagkakamali na nagpapahina sa halaga ng pagtotroso.

Pagganap sa Dulo ng Katayuan

Ang pag - i - log level ay hindi dapat maging botttleneck. Laging suriin ang log level bago mag - format ng argumento. Gamitin agad ang mga macros na sumusuri sa level.

Mga Pagkabahala sa Seguridad

Huwag mag - logo ng sensitibong impormasyon gaya ng password, numero ng credit card, o personal data. Isaalang - alang ang paggamit ng input at ang redacting field sa mga gusali ng produksiyon.

Di - pagkakasuwato sa Kabila ng mga Module

Gumamit ng isang espesyal na module unlapi (e.g., , ) at isang pamantayang timestamp format (angUTC ay pinipili para sa mga sistemang pamamahagi). Isulat ang log format upang mai-parse ito ng mga pangkat ng operasyon.

Pagsasaayos

Ang isang sistema ng pagtotroso sa C ay naglalaan ng kakayahang makibagay at gumawa ng malalaking kagamitan sa pag - aayos ng mga troso. Simula sa isang matibay na disenyo na sumasaklaw sa antas ng troso, lababo, ligtas na sinulid, at formatting, maaari mong unti - unting dagdagan ang mga katangiang gaya ng sanchronous output, paggawa ng mga troso, at pag - abante nang malayo. Ang mga halimbawa sa artikulong ito ay nagsisilbing pundasyong retoryading ang mga ito sa iyong espesipikong kapaligiran, at laging sukatin ang ibabaw ng aklatan.