Rust अनुप्रयोगों में लॉगिंग: कॉन्फ़िगरेशन के सर्वोत्तम अभ्यास

शुरुआती लोगों के लिए ऑनलाइन Python प्रशिक्षक

Python आसानी से सीखें बिना सिद्धांत के बोझ के। स्वचालित जांच के साथ व्यावहारिक कार्य हल करें और ब्राउज़र में सीधे कोड लिखें।

पाठ्यक्रम शुरू करें

```html

परिचय: Rust अनुप्रयोगों के लिए लॉगिंग क्यों महत्वपूर्ण है

लॉगिंग केवल फ़ाइल में घटनाओं को रिकॉर्ड करना नहीं है। उत्पादन वातावरण में, गुणवत्तापूर्ण लॉग आपको त्रुटियों का तुरंत निदान करने, प्रदर्शन को ट्रैक करने और सिस्टम व्यवहार का विश्लेषण करने में सक्षम बनाते हैं। Rust, एक सिस्टम प्रोग्रामिंग भाषा होने के नाते, इस कार्य के लिए लचीले और उच्च-प्रदर्शन वाले उपकरण प्रदान करता है। इस लेख में, हम Rust में लॉगिंग की सर्वोत्तम प्रथाओं पर चर्चा करेंगे: क्रेट चुनने से लेकर संरचित लॉग और रोटेशन सेट करने तक।

1. मूल बातें: `log` और `env_logger` क्रेट

Rust का इकोसिस्टम एक मॉड्यूलर दृष्टिकोण प्रदान करता है। log क्रेट एक एब्स्ट्रैक्शन (फ़ेसाड) प्रदान करता है, और एक विशिष्ट कार्यान्वयन (बैकएंड) एक अलग क्रेट द्वारा जोड़ा जाता है, जैसे env_logger या pretty_env_logger।

स्थापना और कॉन्फ़िगरेशन

Cargo.toml में निर्भरताएँ जोड़ें:

[dependencies]log = "0.4"env_logger = "0.10"

मूल उदाहरण

use log::{info, warn, error};

fn main() {    env_logger::init();

    info!("एप्लिकेशन शुरू हुआ");    let user_id = 42;    warn!("उपयोगकर्ता {} कैश में नहीं मिला", user_id);    error!("डेटाबेस कनेक्शन त्रुटि: {:?}", "timeout");}

महत्वपूर्ण: डिफ़ॉल्ट रूप से, लॉग तब तक प्रदर्शित नहीं होते जब तक आप RUST_LOG पर्यावरण चर सेट नहीं करते। प्रोग्राम को इस प्रकार चलाएँ:

RUST_LOG=info cargo run

लॉगिंग स्तर

log क्रेट पाँच मानक स्तरों का समर्थन करता है (उच्चतम प्राथमिकता से निम्नतम तक):

error — गंभीर त्रुटियाँ जिनमें तत्काल हस्तक्षेप की आवश्यकता है।
warn — संभावित समस्याओं के बारे में चेतावनी।
info — निष्पादन प्रगति के बारे में सामान्य जानकारी।
debug — डेवलपर्स के लिए डीबग जानकारी।
trace — अत्यधिक विस्तृत घटनाएँ (अक्सर लूप में उपयोग की जाती हैं)।

मॉड्यूल द्वारा फ़िल्टरिंग: RUST_LOG=my_crate=debug,other_crate=info.

2. उन्नत लॉगिंग: `tracing` क्रेट

जटिल अनुप्रयोगों (वेब सर्वर, माइक्रोसर्विसेज) के लिए tracing क्रेट का उपयोग करने की अनुशंसा की जाती है। यह span (समय अंतराल) की अवधारणा और संदर्भ के साथ संरचित लॉगिंग प्रदान करता है।

`tracing` की स्थापना

[dependencies]tracing = "0.1"tracing-subscriber = "0.3"

span के साथ उदाहरण

use tracing::{info, instrument, span, Level};use tracing_subscriber;

fn main() {    tracing_subscriber::fmt::init();

    let parent_span = span!(Level::INFO, "अनुरोध_प्रसंस्करण", request_id = 123);    let _guard = parent_span.enter();    process_data();}

#[instrument]fn process_data() {    info!("डेटा प्रसंस्करण शुरू");    std::thread::sleep(std::time::Duration::from_millis(50));    info!("डेटा प्रसंस्करण पूर्ण");}

#[instrument] विशेषता स्वचालित रूप से फ़ंक्शन के लिए एक span बनाती है और निष्पादन समय रिकॉर्ड करती है। आउटपुट में नेस्टेड टाइमस्टैम्प होंगे, जो प्रोफाइलिंग के लिए अपरिहार्य हैं।

3. संरचित लॉग (JSON) और रोटेशन

उत्पादन वातावरण में, लॉग अक्सर केंद्रीय रूप से एकत्र किए जाते हैं (ELK, Loki, Grafana)। इसके लिए लॉग को JSON प्रारूप में आउटपुट करना सुविधाजनक है।

`tracing-subscriber` के साथ JSON आउटपुट

use tracing_subscriber::fmt::format::Json;use tracing_subscriber::prelude::*;

fn main() {    let format = Json::new()        .with_timer(tracing_subscriber::fmt::time::UtcTime::rfc3339())        .with_target(true)        .with_level(true);

    tracing_subscriber::fmt()        .event_format(format)        .init();

    tracing::info!("सर्वर पोर्ट 8080 पर शुरू हुआ");}

अब लॉग इस तरह दिखेंगे: