RustLogs (RLG): Ìkójọ-kóòdù Àkọsílẹ̀ Ètò Oníṣètò fún Rust

TL;DR. Ṣàwárí RustLogs (RLG), ìwé-ìkàwé ìgbàánú onírúurú fún Rust, pẹ̀lú àwọn ìpele ìgbàánú tó ṣètò, ìgbàánú àsínú, àti ọpọlọpọ àwọn àṣàyàn ìdásí.

Points clés

Ìfípáwọ̀. Nínú ayé ìdàgbàsókè software, logging ń kó ipa pàtàkì nínú yíye ìhùwàsí ètò kọ̀m̀pútà kan, ṣíṣàyẹ̀wò àwọn ìṣòro, àti rídájú pé iṣẹ́ ń lọ láìní ìdádúró.
Ìparí. RustLogs (RLG) jẹ́ ìwé-ìkàwé logging tó lágbára, tó rọrùn fún lílo, tí ó sì ń dín ìdààmú kù nígbà tí a bá ń fi logging kún àwọn ètò Rust.
1. Lílóye Àìdáwọ́dúró fún Ìgbàánú tó Múnádóko. Kí a tó bọ́ sínú àwọn kúlẹ̀kúlẹ̀ RustLogs (RLG), ẹ jẹ́ kí a gba àkókò díẹ̀ láti lóye ìdí tí logging tó múnádóko fi ṣe kókó nínú ìdàgbàsókè software.
2. RustLogs (RLG): Ìwé-ìkàwé Ìgbàánú tó Péye. RustLogs (RLG) jẹ́ ìwé-ìkàwé logging tí ó kún fún àwọn ẹ̀yà iṣẹ́, tí ó sì ní lọ́kàn láti mú kí ìlànà fífi agbára logging kún àwọn ètò Rust rọrùn.

Ìfípáwọ̀

Nínú ayé ìdàgbàsókè software, logging ń kó ipa pàtàkì nínú yíye ìhùwàsí ètò kọ̀m̀pútà kan, ṣíṣàyẹ̀wò àwọn ìṣòro, àti rídájú pé iṣẹ́ ń lọ láìní ìdádúró. Rust, èdè ètò kọ̀m̀pútà (systems programming language) kan tí a mọ̀ fún iṣẹ́ tí ó yára àti ààbò rẹ̀, ń pèsè ọpọlọpọ àwọn ojútùú logging fún àwọn olùgbéejáde. Lára àwọn ìwé-ìkàwé wọ̀nyí ni a ti bí RustLogs (RLG). Ó jẹ́ ìwé-ìkàwé logging tó lágbára, tó sì rọrùn láti lò, tí ó sì ń mú kí ó rọrùn láti fi agbára logging tó múnádóko kún àwọn ètò Rust.

.class="m-10 w-100"

1. Lílóye Àìdáwọ́dúró fún Ìgbàánú tó Múnádóko

Kí a tó bọ́ sínú àwọn kúlẹ̀kúlẹ̀ RustLogs (RLG), ẹ jẹ́ kí a gba àkókò díẹ̀ láti lóye ìdí tí logging tó múnádóko fi ṣe kókó nínú ìdàgbàsókè software. Logging jẹ́ ọ̀nà pàtàkì láti gba ìsọfúnni runtime nípa ìhùwàsí ètò kan, sísan data, àti àwọn ìṣòro tó lè wáyé. Nípa gbígbin àwọn ọ̀rọ̀ log (log statements) sínú codebase lọ́nà tó mọ́gbọ́n dání, àwọn olùgbéejáde lè rí àwọn òye tó níye lórí nípa bí ètò náà ṣe ń ṣiṣẹ́ lọ́wọ́ àti láti tọ́ka sí àwọn àdámọ̀ tàbí àṣìṣe kankan. Àwọn olùgbéejáde lè kó àwọn data pàtàkì jọ lọ́nà tó múnádóko, gẹ́gẹ́ bíi function executions, variable contents, àti àwọn ìsọfúnni àṣìṣe (error notifications), nípa gbígbin àwọn log statements sínú koodu náà pẹ̀lú ọgbọ́n. Ìsọfúnni yìí máa ń níye lórí gan-an nígbà tí a bá ń ṣàtúnṣe àwọn kòkòrò (bugs), nígbà tí a ń mú iṣẹ́ ètò náà sunwọ̀n sí i, tàbí nígbà tí a ń ṣàyẹ̀wò ìhùwàsí tí kò tọ́.

Síbẹ̀síbẹ̀, ṣíṣe ìlànà logging láti ìbẹ̀rẹ̀ pátápátá lè jẹ́ iṣẹ́ tó ń gba àkókò tí ó sì lè ní àṣìṣe nínú. Ó gba láti ronú jinlẹ̀ lórí log levels, formatting, output destinations, àti performance overhead. Èyí ni ibi tí RustLogs (RLG) ti wọlé, ní pípèsè ojútùú logging tó péye tí ó sì rọrùn láti lò, tí a ṣe ní pàtó fún àwọn olùgbéejáde Rust.

.class="m-10 w-100"

2. RustLogs (RLG): Ìwé-ìkàwé Ìgbàánú tó Péye

RustLogs (RLG) jẹ́ ìwé-ìkàwé logging tí ó kún fún àwọn ẹ̀yà iṣẹ́, tí ó sì ní lọ́kàn láti mú kí ìlànà fífi agbára logging kún àwọn ètò Rust rọrùn. Ó ń pèsè API tó mọ́ tó sì rọrùn láti lóye, pẹ̀lú àwọn macro tó lágbára, èyí tí ó ń mú kí ó rọrùn láti ṣepọ̀ logging sínú codebase rẹ. RustLogs (RLG) ń pèsè ọpọlọpọ àwọn log levels. Èyí ń jẹ́ kí o ṣàkóso bí àkọsílẹ̀ rẹ ṣe kún fún kúlẹ̀kúlẹ̀ tó níbámu pẹ̀lú bí ìsọfúnni náà ṣe le tó àti bí ó ṣe ṣe kókó tó.

Ọ̀kan lára àwọn agbára pàtàkì ti RustLogs (RLG) ni ìrọ̀rùn rẹ̀ nípa log formatting àti output destinations. Structured logging ní àtìlẹ́yìn, èyí tí ó ń jẹ́ kí o gba data log ní ìlànà structured bi JSON. Èyí ń mú kí parsing àti analysis rọrùn sí i. Líkún-un sí i, RustLogs (RLG) ń pèsè ìbámu pẹ̀lú oríṣiríṣi àwọn output format, pẹ̀lú àwọn framework logging tó gbajúmọ̀ bíi syslog, Apache Access Log, àti Log4j XML. Ìwúlò yíyàtọ̀ yìí ń rí i dájú pé RustLogs (RLG) lè ṣepọ̀ láìsí ìṣòro pẹ̀lú àwọn amúṣọrọ̀ (infrastructures) àti irinṣẹ́ logging tó wà tẹ́lẹ̀.

.class="m-10 w-100"

3. Bẹ̀rẹ̀ Pẹ̀lú RustLogs (RLG)

Láti bẹ̀rẹ̀ sí ní lo RustLogs (RLG) nínú iṣẹ́ Rust rẹ, o ní láti fi kún un gẹ́gẹ́ bí dependency nínú fáìlì Cargo.toml rẹ. Sọ ẹya RustLogs (RLG) tí o fẹ́ kí o sì jẹ́ kí Cargo bójútó tókù:

[dependencies]
rlg = "0.0.3"

Nígbà tí dependency náà bá ti kún un, o lè bẹ̀rẹ̀ sí ní lo RustLogs (RLG) nínú koodu Rust rẹ. Ìwé-ìkàwé náà ń pèsè API tó rọrùn láti lò fún ṣíṣe àwọn log entry. Àpẹẹrẹ kan nìyí:

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

Láti ṣẹ̀dá log entry tuntun, lo iṣẹ́ Log::new(). Sọ session ID, timestamp, log level, component, log message, àti log format (JSON nínú àpẹẹrẹ yìí). RustLogs (RLG) ń pèsè àwọn log level àti format tí a ti ṣètò tẹ́lẹ̀. Yàn lára àwọn log level bíi ALL, DEBUG, DISABLED, ERROR, FATAL, INFO, NONE, TRACE, VERBOSE, àti WARNING. Fún àwọn format log, yàn lára CLF, JSON, CEF, ELF, W3C, GELF, ApacheAccessLog, Logstash, Log4jXML, àti NDJSON. Èyí ń fún ọ ní ìdarí tó péye lórí ètò logging rẹ.

.class="m-10 w-100"

4. Asynchronous Logging pẹ̀lú RustLogs (RLG)

Ọ̀kan lára àwọn ẹ̀yà iṣẹ́ tó tayọ jùlọ ti RustLogs (RLG) ni àtìlẹ́yìn rẹ̀ fún asynchronous logging. Nínú ìdàgbàsókè software òde-òní, iṣẹ́ dídán (performance) ṣe kókó gan-an, gbígbéṣẹ dídádúró (blocking) fún execution thread àkọ́kọ́ nítorí logging lè fa ìdádúró tí kò pọndandan. RustLogs (RLG) ń yanjú ìṣòro yìí nípa pípèsè àwọn agbára asynchronous logging láìní lówó nínú.

Pẹ̀lú RustLogs (RLG), o lè ṣe àkọsílẹ̀ àwọn log message lọ́nà ti àsínú (asynchronously) nípa lílo method log() lórí log entry kan. Method yìí ń dá Future padà tí ó ń ṣiṣẹ́ nígbà ti logic àkọ́kọ́ ti ètò rẹ ń lọ lọ́wọ́. Èyí ń gba ètò rẹ láàyè láti tẹ̀síwájú láì dúró de logging láti parí. Àpẹẹrẹ ti asynchronous logging pẹ̀lú RustLogs (RLG) nìyí:

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

Nípa lílo asynchronous logging, RustLogs (RLG) ń rí i dájú pé iṣẹ́ dídán ètò rẹ kò dín kù nítorí àwọn iṣẹ́ logging. Èyí wúlò gan-an ní àwọn ìṣẹ̀lẹ̀ high-throughput tàbí nígbà tí a bá ń ṣiṣẹ́ pẹ̀lú iye data log tó pọ̀ gan-an.

.class="m-10 w-100"

5. Config àti Customisation Onírúurú

RustLogs (RLG) ń pèsè ìpele gíga ti ìrọ̀rùn àti àṣàyàn customisation láti bójútó àwọn ohun tí a ń fẹ́ nínú logging tó yàtọ̀ síra. O lè ṣe config fún oríṣiríṣi àwọn àṣàyàn logging, bíi ibi tí log file wà, log levels, àti output formats. Èyí ń jẹ́ kí o ṣètò logging níbàmu pẹ̀lú ohun tí ètò rẹ ń fẹ́.

Nípa ti aiyéfise (default), RustLogs (RLG) ń kọ àwọn log message sí fáìlì kan tí a ń pè ní RLG.log nínú folda lọ́wọ́lọ́wọ́. Síbẹ̀síbẹ̀, o lè yí ibi tí fáìlì náà wà padà nípa ṣíṣètò environment variable LOG_FILE_PATH:

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

Ìrọ̀rùn yìí ń fún ọ láàyè láti darí log output sí àwọn fáìlì tó yàtọ̀ níbàmu pẹ̀lú deployment environment rẹ tàbí logging infrastructure.

Líkún-un sí i, RustLogs (RLG) ń pèsè Config struct kan tí ó ń jẹ́ kí o gba àwọn ètò configuration láti environment variables tàbí padà sí àwọn default value. Èyí ń mú kí o lè kó gbogbo configuration logging jọ sí ibì kan, kí o sì yí padà lọ́nà tó rọrùn láì yí koodu rẹ padà:

use rlg::config::Config;

let config = Config::load();

Pẹ̀lú Config struct yìí, o lè wọlé kí o sì lo àwọn configuration settings tí o ti gbà jálẹ̀ ètò rẹ. Èyí ń rí i dájú pé ìhùwàsí logging rẹ kò yàtọ̀ láti iṣẹ́ kan sí òmíràn tàbí deployment.

.class="m-10 w-100"

6. Macro tó Lágbára fún Logging tó Rọrùn sí i

RustLogs (RLG) ń pèsè àwọn macro tó lágbára tí ó ń mú kí àwọn iṣẹ́ logging tó wọ́pọ̀ rọrùn, tí ó sì ń dín koodu boilerplate kù. Àwọn macro yìí ń pèsè ọ̀nà tó rọrùn láti log àwọn message pẹ̀lú ètò àti configuration tó kéré jù. Àpẹẹrẹ díẹ̀ nìyí lára àwọn macro tó wà nínú RustLogs (RLG):

macro_log!: Ṣẹ̀dá log entry tuntun pẹ̀lú àwọn parameter tí o sọ.

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

macro_info_log!: Ṣẹ̀dá info log pẹ̀lú session ID àti format aiyéfise.

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

macro_warn_log!: Ṣẹ̀dá warning log.

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

macro_error_log!: Ṣẹ̀dá error log pẹ̀lú format aiyéfise.

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

Àwọn macro wọ̀nyí ń mú àwọn ìṣòro ti ṣíṣẹ̀dá log entries kúrò, tó ń jẹ́ kí o gbájúmọ́ ìsọfúnni pàtàkì tí o fẹ́ ṣe àkọsílẹ̀ rẹ̀. Wọ́n ń pèsè àwọn default tó bọ́gbọ́n mu fún session IDs, formats, àti àwọn parameter mìíràn, tí ó ń dín iye koodu tí o ní láti kọ àti láti tọ́jú kù.

.class="m-10 w-100"

7. Ìṣepọ̀ pẹ̀lú àwọn Logging Infrastructure tó Wà Tẹ́lẹ̀

Ọ̀kan lára àwọn ànfàní pàtàkì ti RustLogs (RLG) ni ìbámu rẹ̀ pẹ̀lú oríṣiríṣi àwọn logging infrastructure àti irinṣẹ́. Ìwé-ìkàwé náà ń ṣàtìlẹ́yìn fún ọpọlọpọ àwọn output format, tí ó ń mú kí ó rọrùn láti ṣepọ̀ pẹ̀lú àwọn logging pipeline àti analysis platform tó wà tẹ́lẹ̀.

Fún àpẹẹrẹ, tí o bá ń lo ètò logging aringbungbun (centralised logging system) bíi syslog, RustLogs (RLG) lè kọ àwọn log message lọ́nà tí kò ní ìṣòro nínú format syslog. Tí o bá ń lo àwọn irinṣẹ́ log aggregation bíi Logstash tàbí Graylog, RustLogs lè gbé àwọn log jáde ní format tí ó ní ìbámu pẹ̀lú àwọn ètò wọ̀nyí, fún àpẹẹrẹ JSON tàbí GELF.

Agbára ìṣepọ̀ yìí ń rí i dájú pé o lè lo agbára RustLogs (RLG) láì dí ètò logging rẹ lọ́wọ́ lọ́wọ́ lọ́wọ́. O lè tẹ̀síwájú láti lo logging infrastructure tí o fẹ́ nígbà tí o ń jàǹfààní lára ìrọ̀rùn àti adaptability tí RustLogs (RLG) ń pèsè.

.class="m-10 w-100"

8. Ìbójútó Àṣìṣe àti Agbára Ètò

Àwọn iṣẹ́ logging kò bọ́ lọ́wọ́ àṣìṣe, RustLogs (RLG) sì ń pèsè àwọn ọ̀nà ìbójútó àṣìṣe tó múnádóko láti rí i dájú pé àwọn log rẹ ṣe é gbẹ́kẹ̀lé, kí wọ́n sì wà ní pipe. Ìwé-ìkàwé náà ń dá type Result padà láti method log(), èyí tí ó ń jẹ́ kí o bójútó àwọn àṣìṣe tó lè wáyé lọ́nà tó dára.

Àwọn àṣìṣe tó wọ́pọ̀ tí ó lè wáyé nígbà logging pẹ̀lú àṣìṣe fáìlì I/O, ìṣòro formatting, tàbí àṣìṣe network nígbà tí a bá ń fi àwọn log ránṣẹ́ sí ibi tó jìn. RustLogs (RLG) ń gba àwọn àṣìṣe wọ̀nyí, ó sì ń pèsè ìsọfúnni àṣìṣe tó yéni, tó ń jẹ́ kí o ṣàyẹ̀wò kí o sì bójútó wọn lọ́nà tó yẹ.

Àpẹẹrẹ kan ti ìbójútó àṣìṣe pẹ̀lú RustLogs (RLG) nìyí:

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) ń rí i dájú pé àwọn ìkùnà logging kò farasin. Ó ń fún ọ ní ìsọfúnni tí o ní láti gbé àwọn ìgbésẹ̀ tó tọ́ nípa ṣíṣe ìbójútó àṣìṣe lọ́nà tó múnádóko.

.class="m-10 w-100"

9. Àwọn Ohun tó Jẹ Mọ́ Iṣẹ́ Dídán (Performance)

Nígbà tí ó bá kan logging, iṣẹ́ dídán (performance) jẹ́ ohun kókó tí a ní láti gbé yẹ̀ wò. Logging tó pọ̀ jù tàbí ìlànà logging tí kò múnádóko lè fa fifalẹ̀ (overhead) tí ó sì lè nípa lórí iṣẹ́ gbogbogbò ètò rẹ. RustLogs (RLG) jẹ́ ohun tí a ṣe pẹ̀lú iṣẹ́ dídán ní ọkàn, ní pípèsè oríṣiríṣi àwọn optimisation láti dín ipa logging kù lórí ètò rẹ.

Lákọ̀ọ́kọ́, RustLogs (RLG) ń ṣàtìlẹ́yìn fún asynchronous logging, gẹ́gẹ́ bí a ti sọ tẹ́lẹ̀. RustLogs (RLG) ń lo àwọn iṣẹ́ àsínú I/O, nítorí náà logging kì í dín thread àkọ́kọ́ lọ́wọ́. Èyí ń gba ètò rẹ láàyè láti máa ṣiṣẹ́ lọ́wọ́ nígbà tí logging ń ṣẹlẹ̀ ní abẹ́lẹ̀. Ọ̀nà non-blocking yìí ń dín àkóbá ti iṣẹ́ dídán tí àwọn iṣẹ́ logging ń fà kù.

Líkún-un sí i, RustLogs (RLG) ń lo ìlànà formatting àti output tó múnádóko. Ìwé-ìkàwé náà ń lo buffers tí a ti pèsè tẹ́lẹ̀ (pre-allocated buffers) ó sì ń yẹra fún àwọn allocation iranti (memory allocations) tí kò pọn dandan nígbàkigbà tí ó bá ṣeé ṣe. Optimisation yìí ń dín memory footprint kù, ó sì ń mú kí iṣẹ́ logging dán mọ́ran sí i.

RustLogs (RLG) ń jẹ́ kí o ṣàkóso ìpele kúlẹ̀kúlẹ̀ nínú àwọn log rẹ. O lè yàn láti ṣe àkọsílẹ̀ ìsọfúnni tó ṣe kókó jùlọ nìkan tàbí fi kúlẹ̀kúlẹ̀ kún un fún ṣíṣàyẹ̀wò (debugging). Nípa ṣíṣètò log levels tó yẹ fún oríṣiríṣi àwọn component tàbí module ti ètò rẹ, o lè mú iṣẹ́ dídán sunwọ̀n sí i nípa yíyọ logging tí kò pọndandan kúrò ní àwọn production environment.

.class="m-10 w-100"

Ìparí

RustLogs (RLG) jẹ́ ìwé-ìkàwé logging tó lágbára, tó rọrùn fún lílo, tí ó sì ń dín ìdààmú kù nígbà tí a bá ń fi logging kún àwọn ètò Rust. Àwọn ẹ̀yà iṣẹ́ rẹ̀ tó kún rẹ́rẹ́, pẹ̀lú structured logging, asynchronous operations, àti ìbámu pẹ̀lú àwọn logging infrastructure tó gbajúmọ̀, ń mú kí ó jẹ́ àṣàyàn tó dára fún oríṣiríṣi àwọn ohun tí a ń fẹ́ nínú logging.

API rẹ̀ tó rọrùn láti lóye, àwọn macro tó lágbára, àti ìlànà ìbójútó àṣìṣe tó múnádóko ń jẹ́ kí àwọn olùgbéejáde gba ìsọfúnni runtime tó níye lórí lọ́nà tó yára tí ó sì ṣe é gbẹ́kẹ̀lé. Optimisations lórí iṣẹ́ dídán ti RustLogs àti configuration onírúurú ń mú kí ìwúlò àti adaptability rẹ̀ sunwọ̀n sí i fún àwọn nǹkan tí iṣẹ́ kọ̀ọ̀kan ń fẹ́.

Pẹ̀lú àkọsílẹ̀ tó péye (documentation), àti ìṣepọ̀ tó rọrùn pẹ̀lú Rust ecosystem, RustLogs jẹ́ ojútùú logging tó ṣe é gbẹ́kẹ̀lé tí ó sì múnádóko fún àwọn olùgbéejáde Rust. Nípa lílo àwọn agbára ti RustLogs, àwọn olùgbéejáde lè ní òye tó jinlẹ̀ sí i nípa ìhùwàsí ètò wọn, mú kí ìlànà debugging rọrùn, kí wọ́n sì rí i dájú pé codebase wọn rọrùn láti tọ́jú fún ìgbà pípẹ́.

Bí àwùjọ Rust ṣe ń tẹ̀síwájú láti gbòòrò àti láti dàgbà, RustLogs ń retí láti di irinṣẹ́ pàtàkì nínú ohun ìjà ti olùgbéejáde, tó ń fún wọn ní agbára láti kọ ètò tó múnádóko, tó ní log tó péye, tí ó sì rọrùn láti tọ́jú pẹ̀lú ìrọ̀rùn.

Bẹ̀rẹ̀ Nígbà Yìí Lọ́wọ́ →

Àtúnyẹ̀wò kẹ́yìn 2026-06-23.

Àyẹ̀wò àkọ́kọ́ 2026-07-16.

Tun àpilẹkọ yìí jade

RustLogs (RLG): Ìkójọ-kóòdù Àkọsílẹ̀ Ètò Oníṣètò fún Rust — Sebastien Rousseau

Ṣàwárí RustLogs (RLG), ìwé-ìkàwé ìgbàánú onírúurú fún Rust, pẹ̀lú àwọn ìpele ìgbàánú tó ṣètò, ìgbàánú àsínú, àti ọpọlọpọ àwọn àṣàyàn ìdásí.

A ti fun àpilẹkọ yìí ni iwe-ẹri labẹ Creative Commons Attribution 4.0 International. Atunjade nilo idanimọ si URL akọkọ.

RustLogs (RLG): Ìkójọ-kóòdù Àkọsílẹ̀ Ètò Oníṣètò fún Rust — Sebastien Rousseau

Ṣàwárí RustLogs (RLG), ìwé-ìkàwé ìgbàánú onírúurú fún Rust, pẹ̀lú àwọn ìpele ìgbàánú tó ṣètò, ìgbàánú àsínú, àti ọpọlọpọ àwọn àṣàyàn ìdásí.

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

SEBASTIEN ROUSSEAU FOUNDER · ENGINEER