RustLogs (RLG): Laburaren Structured Logging don Rust

TL;DR. Gano RustLogs (RLG), ɗakin karatu mai sassauci na logging don Rust tare da tsarin log da aka tsara, logging na asynchronous, da zaɓuɓɓuka masu yawa na keɓantawa.

Points clés

Gabatarwa. A duniyar haɓaka software, logging yana taka muhimmiyar rawa wajen fahimtar yadda application yake aiki, gano matsaloli, da kuma tabbatar da ingantaccen aiki.
Kammalawa. RustLogs (RLG) wani ɗakin karatu ne na logging mai ƙarfi, mai sassauci, da sauƙin amfani wanda ke sauƙaƙa tsarin shigar da logging a cikin applications na Rust.
1. Fahimtar Bukatar Ingantaccen Logging. Kafin mu shiga cikin takamaiman bayani na RustLogs (RLG), bari mu ɗauki ɗan lokaci don fahimtar dalilin da yasa ingantaccen logging ke da mahimmanci a haɓaka software.
2. RustLogs (RLG): Cikakken Ɗakin Karatu na Logging. RustLogs (RLG) wani ɗakin karatu ne na logging mai cike da fasalulluka wanda ke da nufin sauƙaƙawa da daidaita tsarin ƙara damar logging a cikin applications na Rust.

Gabatarwa

A duniyar haɓaka software, logging yana taka muhimmiyar rawa wajen fahimtar yadda application yake aiki, gano matsaloli, da kuma tabbatar da ingantaccen aiki. Rust, yaren programming na tsarin da aka sani don ingancinsa da amincinsa, yana ba wa masu haɓakawa zaɓuɓɓuka da yawa na logging. A cikin waɗannan ɗakunan karatu ne aka haifi RustLogs (RLG). Yana da ɗakin karatu mai ƙarfi da sassauci wanda ke sauƙaƙa ƙara ingantaccen ƙarfin logging ga applications na Rust.

.class="m-10 w-100"

1. Fahimtar Bukatar Ingantaccen Logging

Kafin mu shiga cikin takamaiman bayani na RustLogs (RLG), bari mu ɗauki ɗan lokaci don fahimtar dalilin da yasa ingantaccen logging ke da mahimmanci a haɓaka software. Logging wata dabara ce mai mahimmanci don kama bayanan runtime game da yadda application yake aiki, kwararar bayanai, da matsalolin da ka iya tasowa. Ta hanyar sanya maganganun log ta hanyar dabara a cikin codebase, masu haɓakawa za su iya samun fahimta mai mahimmanci game da ayyukan cikin gida na application ɗin kuma su gano duk wani abu da bai daidaita ba ko kurakurai. Masu haɓakawa za su iya tattara mahimman bayanai yadda ya kamata, kamar aiwatar da ayyuka (function executions), abubuwan da ke cikin variable, da sanarwar kuskure, ta hanyar saka maganganun log a cikin code. Wannan bayanin ya zama mai kima sosai lokacin magance matsalolin bugs, haɓaka aiki, ko binciken halayen da ba a zata ba.

Koyaya, aiwatar da aikin logging daga farko na iya zama aiki mai ɗaukar lokaci kuma mai saurin kuskure. Yana buƙatar yin la'akari da hankali game da matakan log (log levels), tsara fasali (formatting), wuraren da ake aika sakamako (output destinations), da kuma nauyin aiki a kan tsarin (performance overhead). Wannan shine inda RustLogs (RLG) ke shigowa, yana ba da cikakkiyar hanyar logging mai sauƙin amfani wacce aka tsara ta musamman don masu haɓaka Rust.

.class="m-10 w-100"

2. RustLogs (RLG): Cikakken Ɗakin Karatu na Logging

RustLogs (RLG) wani ɗakin karatu ne na logging mai cike da fasalulluka wanda ke da nufin sauƙaƙawa da daidaita tsarin ƙara damar logging a cikin applications na Rust. Yana ba da API mai tsabta da sauƙin fahimta, tare da tarin manyan macros, wanda ke sa haɗa logging a cikin codebase ɗinku ya zama mai sauƙi. RustLogs (RLG) yana ba da matakan log (log levels) masu yawa. Wannan yana ba ku damar sarrafa yadda logs ɗinku ke da cikakken bayani dangane da tsanani da mahimmancin bayanin.

Ɗaya daga cikin mahimman ƙarfin RustLogs (RLG) shine sassaucin sa dangane da tsarin log (log formatting) da wuraren da ake aika sakamako (output destinations). Ana tallafawa structured logging, wanda ke ba ku damar kama bayanan log a cikin tsari mai kyau kamar JSON. Wannan yana sa parsing da nazari su fi sauƙi. Bugu da ƙari, RustLogs (RLG) yana samar da dacewa tare da tsarin fitarwa daban-daban, gami da shahararrun tsarin logging kamar syslog, Apache Access Log, da Log4j XML. Wannan juzu'i yana tabbatar da cewa RustLogs (RLG) na iya haɗuwa ba tare da matsala ba tare da abubuwan more rayuwa na logging da kayan aikin da ake dasu.

.class="m-10 w-100"

3. Farawa da RustLogs (RLG)

Don fara amfani da RustLogs (RLG) a cikin aikin ku na Rust, kuna buƙatar ƙara shi azaman dependency a cikin fayil ɗin ku na Cargo.toml. Taimaka wajen bayyana sigar RustLogs (RLG) da kuke buƙata kuma ku bar Cargo ya kula da sauran:

[dependencies]
rlg = "0.0.3"

Da zarar an ƙara dependency ɗin, zaku iya fara amfani da RustLogs (RLG) a cikin code ɗinku na Rust. Ɗakin karatun yana ba da API mai sauƙi da sauƙin fahimta don ƙirƙirar bayanan log. Ga misali na asali:

use rlg::log::Log;
use rlg::log_format::LogFormat;
use rlg::log_level::LogLevel;

let log_entry = Log::new(
    "session_id",
    "timestamp",
    &LogLevel::INFO,
    "component",
    "This is a log message",
    &LogFormat::JSON,
);

Don ƙirƙirar sabon shigarwar log, yi amfani da aikin Log::new(). Saka session ID, timestamp, matakin log (log level), component, saƙon log, da tsarin log (JSON a cikin wannan misalin). RustLogs (RLG) yana ba da matakan log da tsare-tsare da aka riga aka bayyana. Zaɓi daga matakan log kamar ALL, DEBUG, DISABLED, ERROR, FATAL, INFO, NONE, TRACE, VERBOSE, da WARNING. Don tsarin log, zaɓi daga CLF, JSON, CEF, ELF, W3C, GELF, ApacheAccessLog, Logstash, Log4jXML, da NDJSON. Wannan yana ba ku iko na musamman akan tsarin logging ɗinku.

.class="m-10 w-100"

4. Asynchronous Logging tare da RustLogs (RLG)

Ɗayan fitattun fasalulluka na RustLogs (RLG) shine goyon bayansa ga asynchronous logging. A cikin haɓaka software na zamani, ingancin aiki (performance) yana da matukar muhimmiyar rawa, kuma dakatar da babban thread na aiwatarwa (main execution thread) don dalilai na logging na iya kawo latency da bai kamata ba. RustLogs (RLG) yana magance wannan matsalar ta hanyar samar da damar asynchronous logging kai tsaye daga farko.

Tare da RustLogs (RLG), zaku iya log ɗin saƙonni asynchronously ta amfani da hanyar log() akan shigarwar log. Wannan hanyar tana dawo da Future wanda ke gudana yayin babban logic na application ɗinku. Wannan yana bawa application ɗinku damar ci gaba ba tare da jiran logging ya gama ba. Ga misalin asynchronous logging tare da RustLogs (RLG):

use rlg::log::Log;
use rlg::log_format::LogFormat;
use rlg::log_level::LogLevel;

async fn log_async() {
    let log_entry = Log::new(
        "session_id",
        "timestamp",
        &LogLevel::INFO,
        "component",
        "This is an async log message",
        &LogFormat::JSON,
    );

    match log_entry.log().await {
        Ok(_) => println!("Log message written successfully"),
        Err(e) => eprintln!("Error writing log message: {}", e),
    }
}

Ta hanyar amfani da asynchronous logging, RustLogs (RLG) yana tabbatar da cewa ba a lalata aikin application ɗinku ta hanyar ayyukan logging ba. Wannan yana da amfani musamman a cikin yanayin high-throughput ko lokacin da ake ma'amala da manyan bayanai na log.

.class="m-10 w-100"

5. Sassaucin Tsari da Keɓancewa

RustLogs (RLG) yana ba da babban mataki na sassauci da zaɓuɓɓukan keɓancewa don biyan buƙatun logging daban-daban. Kuna iya saita zaɓuɓɓukan logging daban-daban, kamar wurin fayil ɗin log (log file location), matakan log, da tsarin fitarwa (output formats). Wannan yana ba ku damar saita logging dangane da bukatun application ɗinku.

Ta tsohuwa (by default), RustLogs (RLG) yana log ɗin saƙonni zuwa fayil mai suna RLG.log a cikin directory na yanzu. Koyaya, zaku iya keɓance hanyar fayil ɗin log (log file path) cikin sauƙi ta hanyar saita environment variable na LOG_FILE_PATH:

std::env::set_var("LOG_FILE_PATH", "/path/to/custom/log/file.log");

Wannan sassaucin yana ba ku damar tura sakamakon log zuwa fayiloli daban-daban dangane da yanayin tura aiki (deployment environment) ko kayan aikin logging.

Haka kuma, RustLogs (RLG) yana ba da Config struct wanda ke ba ku damar loda saitunan tsari daga environment variables ko komawa ga tsoffin ƙima (default values). Wannan yana ba ku damar mayar da hankali kan tsarin logging ɗinku a wuri ɗaya kuma ku gyara shi cikin sauƙi ba tare da canza code ɗinku ba:

use rlg::config::Config;

let config = Config::load();

Tare da Config struct, zaku iya shiga da amfani da saitunan tsarin da aka loda a duk cikin application ɗinku. Wannan yana tabbatar da daidaiton halayen logging a cikin gudanarwa ko tura aiki daban-daban.

.class="m-10 w-100"

6. Manyan Macros don Sauƙaƙan Logging

RustLogs (RLG) yana ba da tarin manyan macros waɗanda ke sauƙaƙe ayyukan logging na yau da kullun da rage boilerplate code. Waɗannan macros suna ba da hanya mai dacewa don log ɗin saƙonni tare da ƙarancin saiti da tsari. Ga ƴan misalai na macros ɗin da ke akwai a cikin RustLogs (RLG):

macro_log!: Yana ƙirƙirar sabon shigarwar log tare da takamaiman sigogi.

let log = macro_log!(session_id, time, level, component, description, format);

macro_info_log!: Yana ƙirƙirar info log tare da tsohuwar (default) session ID da tsari.

let log = macro_info_log!(time, component, description);

macro_warn_log!: Yana ƙirƙirar warning log.

let log = macro_warn_log!(time, component, description);

macro_error_log!: Yana ƙirƙirar error log tare da tsohon (default) tsari.

let log = macro_error_log!(time, component, description);

Waɗannan macros suna ɓoye rikitattun abubuwa na ƙirƙirar bayanan log, suna ba ku damar mai da hankali kan mahimman bayanan da kuke son log ɗinsu. Suna ba da tsoffin ƙima (sensible defaults) don session IDs, formats, da sauran sigogi, suna rage yawan code ɗin da kuke buƙatar rubutawa da kiyayewa.

.class="m-10 w-100"

7. Haɗin gwiwa tare da Kayan Aikin Logging da Ake dasu

Ɗaya daga cikin mahimman fa'idodin RustLogs (RLG) shine dacewarsa da kayan aikin logging daban-daban. Ɗakin karatun yana tallafawa tsarin fitarwa da yawa, wanda ke sa sauƙin haɗawa da pipelines na logging da dandamalin nazari da ake dasu.

Misali, idan kuna amfani da tsarin logging na tsakiya (centralised logging system) kamar syslog, RustLogs (RLG) na iya rubuta saƙonnin log ba tare da matsala ba a tsarin syslog. Idan kuna amfani da kayan aikin tara log (log aggregation tools) kamar Logstash ko Graylog, RustLogs na iya fitar da logs a cikin tsarin da ya dace da waɗannan tsarin. Misali, JSON ko GELF.

Wannan damar haɗin gwiwar tana tabbatar da cewa zaku iya amfani da ikon RustLogs (RLG) ba tare da tarwatsa tsarin logging ɗinku na yanzu ba. Kuna iya ci gaba da amfani da kayan aikin logging da kuka fi so yayin da kuke amfana daga sauƙin amfani da sassaucin da RustLogs (RLG) ke bayarwa.

.class="m-10 w-100"

8. Sarrafa Kuskure da Juriya

Ayyukan logging ba su kuɓuta daga kurakurai ba, kuma RustLogs (RLG) yana ba da ingantaccen tsarin sarrafa kuskure (error handling) don tabbatar da aminci da mutuncin logs ɗinku. Ɗakin karatun yana dawo da nau'in Result daga hanyar log(), yana ba ku damar magance kurakuran da ka iya tasowa cikin sauƙi.

Kurakurai na yau da kullun da zasu iya faruwa yayin logging sun haɗa da kurakuran fayil na I/O, matsalolin tsara fasali (formatting), ko kurakurai masu alaƙa da hanyar sadarwa (network-related errors) lokacin aika logs zuwa wurare masu nisa. RustLogs (RLG) yana kama waɗannan kurakuran kuma yana ba da saƙonnin kuskure masu amfani, yana ba ku damar bincikar su da sarrafa su yadda ya kamata.

Ga misali na sarrafa kuskure tare da RustLogs (RLG):

use rlg::log::Log;
use rlg::log_format::LogFormat;
use rlg::log_level::LogLevel;

async fn log_with_error_handling() {
    let log_entry = Log::new(
        "session_id",
        "timestamp",
        &LogLevel::INFO,
        "component",
        "This is a log message",
        &LogFormat::JSON,
    );

    match log_entry.log().await {
        Ok(_) => println!("Log message written successfully"),
        Err(e) => eprintln!("Error writing log message: {}", e),
    }
}

RustLogs (RLG) yana tabbatar da cewa gazawar logging ba ta wuce ba tare da an sani ba. Yana ba ku bayanan da kuke buƙata don ɗaukar matakan gyara ta hanyar sarrafa kurakurai yadda ya kamata.

.class="m-10 w-100"

9. Abubuwan La'akari da Aiki (Performance)

Lokacin da yazo ga logging, ingancin aiki (performance) abu ne mai mahimmanci don la'akari. Yawan logging ko rashin ingantaccen logging na iya kawo babban nauyi (overhead) da tasiri ga gabaɗayan aikin application ɗinku. An tsara RustLogs (RLG) tare da la'akari da aiki, yana ba da haɓakawa (optimisations) da yawa don rage tasirin logging akan tsarin ku.

Da farko, RustLogs (RLG) yana tallafawa asynchronous logging, kamar yadda aka ambata a baya. RustLogs (RLG) yana amfani da ayyukan asynchronous I/O, don haka logging baya dakatar da babban thread (main thread). Wannan yana ba application ɗinku damar ci gaba da aiki yayin da logging ke faruwa a bango. Wannan tsari na rashin dakatarwa (non-blocking approach) yana rage asarar ingancin aiki da ayyukan logging ke haifarwa.

Bugu da ƙari, RustLogs (RLG) yana amfani da ingantaccen tsari na formatting da fitarwa. Ɗakin karatun yana amfani da pre-allocated buffers kuma yana guje wa rabon ƙwaƙwalwar ajiya (memory allocations) mara mahimmanci duk lokacin da zai yiwu. Wannan haɓakawa yana rage sawun ƙwaƙwalwar ajiya (memory footprint) kuma yana inganta gabaɗayan ingancin logging.

RustLogs (RLG) yana ba ku damar sarrafa matakin cikakken bayani a cikin logs ɗinku. Kuna iya zaɓar yin log ɗin mahimman bayanai kawai ko haɗa da ƙarin cikukkun bayanai don dalilai na debugging. Ta hanyar saita matakan log masu dacewa don sassa daban-daban ko modules na application ɗinku, zaku iya haɓaka aiki ta hanyar cire logging marasa mahimmanci a cikin production environments.

Kammalawa

RustLogs (RLG) wani ɗakin karatu ne na logging mai ƙarfi, mai sassauci, da sauƙin amfani wanda ke sauƙaƙa tsarin shigar da logging a cikin applications na Rust. Babban rukunin fasalulluka, gami da structured logging, ayyukan asynchronous, da dacewa tare da shahararrun abubuwan more rayuwa na logging, ya sa ya zama zaɓi mai fa'ida ga buƙatun logging daban-daban.

API mai sauƙin fahimta na ɗakin karatun, manyan macros, da ingantaccen tsarin sarrafa kuskure suna ba wa masu haɓakawa damar kama bayanan runtime masu mahimmanci cikin inganci da aminci. Haɓaka aikin RustLogs da zaɓuɓɓukan tsari masu sassauci suna ƙara haɓaka amfaninsa da daidaitawa ga buƙatun aiki daban-daban.

Ukipata cikakkun takaddun bayani (documentation), da haɗin gwiwa mara kyau tare da tsarin Rust (Rust ecosystem), RustLogs ya tsaya a matsayin ingantaccen kuma amintaccen tsarin logging don masu haɓaka Rust. Ta hanyar amfani da damar RustLogs, masu haɓakawa za su iya samun zurfin fahimta game da halayen applications ɗinsu, daidaita hanyoyin debugging, da tabbatar da dorewar codebase ɗinsu na dogon lokaci.

Yayin da al'ummar Rust ke ci gaba da girma da haɓaka, RustLogs yana da nufin zama kayan aiki mai mahimmanci a cikin kayan aikin mai haɓakawa, yana ba su ikon gina ingantattun applications, masu kyawun logging, da sauƙin kiyayewa cikin sauƙi.

Fara Yanzu →

An duba na ƙarshe a 2026-06-23.

Bita ta ƙarshe 2026-07-16.

Sake buga wannan labari

RustLogs (RLG): Laburaren Structured Logging don Rust — Sebastien Rousseau

Gano RustLogs (RLG), ɗakin karatu mai sassauci na logging don Rust tare da tsarin log da aka tsara, logging na asynchronous, da zaɓuɓɓuka masu yawa na keɓantawa.

An lasisin wannan labari a karkashin Creative Commons Attribution 4.0 International. Sake bugawa na bukatar nuna asalin URL na asali.

RustLogs (RLG): Laburaren Structured Logging don Rust — Sebastien Rousseau

Gano RustLogs (RLG), ɗakin karatu mai sassauci na logging don Rust tare da tsarin log da aka tsara, logging na asynchronous, da zaɓuɓɓuka masu yawa na keɓantawa.

Originally published at https://sebastienrousseau.com/ha/2024-03-08-rustlogs-advanced-logging-library-for-rust-applications/ by Sebastien Rousseau.
Licensed under CC-BY-4.0.

SEBASTIEN ROUSSEAU FOUNDER · ENGINEER