Rust में Tracing: पूरी गाइड उदाहरणों के साथ

Rust में Tracing क्या है और इसकी आवश्यकता क्यों है?

Tracing लाइब्रेरी Rust में स्ट्रक्चर्ड लॉगिंग और इंस्ट्रूमेंटेशन (ट्रेसिंग) के लिए एक शक्तिशाली फ्रेमवर्क है। सामान्य लॉगर्स के विपरीत, Tracing स्पैन (spans) और इवेंट (events) की अवधारणा प्रदान करता है, जो आपको एसिंक्रोनस ऑपरेशन, डिस्ट्रीब्यूटेड सिस्टम और जटिल नेस्टेड कॉल्स के संदर्भ में कोड के निष्पादन को ट्रैक करने की अनुमति देता है।

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

यह लाइब्रेरी Tokio इकोसिस्टम का हिस्सा है और actix-web, axum, hyper जैसे प्रोजेक्ट्स में सक्रिय रूप से उपयोग की जाती है।

Tracing की स्थापना (Installation)

अपने Rust प्रोजेक्ट में Tracing जोड़ने के लिए, Cargo.toml फ़ाइल खोलें और निम्नलिखित डिपेंडेंसी जोड़ें:

[dependencies]
tracing = "0.1"
tracing-subscriber = "0.3"  # कंसोल पर लॉग आउटपुट के लिए
tracing-appender = "0.2"    # फ़ाइल में लॉग लिखने के लिए (वैकल्पिक)

इसके बाद, लाइब्रेरी को डाउनलोड और कंपाइल करने के लिए cargo build कमांड चलाएँ।

त्वरित शुरुआत: पहला उदाहरण

आइए एक सरल प्रोग्राम लिखें जो Tracing का उपयोग करके एक संदेश लॉग करता है:

use tracing::{info, Level};
use tracing_subscriber::FmtSubscriber;

fn main() {
    // stdout पर लॉग आउटपुट के लिए सब्सक्राइबर इनिशियलाइज़ करें
    let subscriber = FmtSubscriber::builder()
        .with_max_level(Level::INFO)
        .finish();
    tracing::subscriber::set_global_default(subscriber)
        .expect("ग्लोबल subscriber सेट करने में विफल");

    // एक सरल संदेश लॉग करें
    info!("एप्लिकेशन शुरू हो गया है!");

    // ट्रेसिंग के साथ फंक्शन कॉल
    process_data("example.txt");
}

fn process_data(filename: &str) {
    // फंक्शन को ट्रैक करने के लिए एक स्पैन बनाएँ
    let span = tracing::span!(Level::INFO, "process_data", filename = filename);
    let _guard = span.enter(); // स्पैन में प्रवेश करें

    info!("फ़ाइल प्रोसेसिंग शुरू");
    // ... कुछ काम ...
    std::thread::sleep(std::time::Duration::from_millis(100));
    info!("प्रोसेसिंग पूरी हुई");
}

चलाने पर, आप टाइमस्टैम्प, लेवल और स्पैन नामों के साथ एक स्ट्रक्चर्ड आउटपुट देखेंगे।

Tracing के मुख्य तरीके और फंक्शन

नीचे Tracing लाइब्रेरी के 10 प्रमुख फंक्शन और मैक्रोज़ विस्तृत विवरण और उदाहरणों के साथ दिए गए हैं।

1. tracing::span! — स्पैन बनाना

यह क्या करता है: एक नया स्पैन बनाता है — काम की एक तार्किक इकाई जो नेस्टेड हो सकती है। स्पैन का एक नाम, लेवल और फ़ील्ड का सेट होता है।

पैरामीटर:

• Level — लॉगिंग लेवल (ERROR, WARN, INFO, DEBUG, TRACE)
• target (वैकल्पिक) — मॉड्यूल की पहचान करने वाला स्ट्रिंग
• field = value — संदर्भ के लिए मनमाने फ़ील्ड

उदाहरण:

use tracing::Level;

fn handle_request(id: u64) {
    let span = tracing::span!(Level::INFO, "handle_request", request_id = id);
    let _guard = span.enter();
    // स्पैन के अंदर कोड
    tracing::info!("अनुरोध प्रोसेस कर रहे हैं");
}

2. tracing::info! — INFO लेवल पर लॉगिंग

यह क्या करता है: INFO लेवल के साथ एक इवेंट रिकॉर्ड करता है। इवेंट एक एकल संदेश है जो वर्तमान स्पैन से जुड़ा हो सकता है।

पैरामीटर:

• फ़ॉर्मेटिंग स्ट्रिंग (format! की तरह)
• फ़ॉर्मेटिंग के लिए आर्गुमेंट
• field = value के माध्यम से फ़ील्ड

उदाहरण:

let user = "Alice";
let age