Go के लिए Zap / Logrus: पूर्ण गाइड उदाहरण सहित

Go में लॉगिंग का परिचय: Zap और Logrus

लॉगिंग किसी भी गंभीर एप्लिकेशन का एक महत्वपूर्ण हिस्सा है। यह प्रोग्राम की स्थिति को ट्रैक करने, त्रुटियों को रिकॉर्ड करने, प्रदर्शन का विश्लेषण करने और प्रोडक्शन एनवायरनमेंट में कोड को डीबग करने में मदद करता है। Go की स्टैंडर्ड लाइब्रेरी में log पैकेज है, लेकिन इसकी सीमाएँ हैं: इसमें लॉगिंग लेवल (बेसिक के अलावा), स्ट्रक्चर्ड आउटपुट या फ्लेक्सिबल फॉर्मेट नहीं हैं। इन समस्याओं को हल करने के लिए दो शक्तिशाली लाइब्रेरी बनाई गईं: Zap (Uber द्वारा) और Logrus (पहले लोकप्रिय लॉगर्स में से एक)।

इस लेख में हम दोनों लाइब्रेरी, उनके तरीकों, उपयोग के उदाहरणों और बेस्ट प्रैक्टिसेज पर विस्तार से चर्चा करेंगे। आप सीखेंगे कि स्ट्रक्चर्ड लॉगिंग कैसे सेट करें, लेवल के साथ कैसे काम करें, कॉन्टेक्स्ट फील्ड कैसे जोड़ें और सामान्य गलतियों से कैसे बचें।

Zap क्या है?

Zap Uber द्वारा बनाई गई एक हाई-परफॉरमेंस स्ट्रक्चर्ड लॉगिंग लाइब्रेरी है। यह स्पीड और न्यूनतम मेमोरी उपयोग पर केंद्रित है। Zap दो मोड में काम करता है: SugaredLogger (आसान, लेकिन थोड़ा धीमा) और Logger (अधिकतम प्रदर्शन)।

Logrus क्या है?

Logrus Go में लॉगिंग के लिए पहली और सबसे लोकप्रिय लाइब्रेरी में से एक है। यह एक सरल API, लेवल सपोर्ट, फॉर्मेटर (JSON, Text) और बाहरी सिस्टम (जैसे Sentry, Slack) के साथ इंटीग्रेशन के लिए हुक (hooks) प्रदान करता है। Logrus सीखने में आसान है, लेकिन प्रदर्शन में Zap से पीछे है।

इंस्टॉलेशन

दोनों लाइब्रेरी को go get के माध्यम से मानक तरीके से इंस्टॉल किया जा सकता है:

// Zap इंस्टॉल करें
go get -u go.uber.org/zap

// Logrus इंस्टॉल करें
go get -u github.com/sirupsen/logrus

इंस्टॉल करने के बाद, आप उन्हें अपने प्रोजेक्ट में इम्पोर्ट कर सकते हैं:

import (
    "go.uber.org/zap"
    "github.com/sirupsen/logrus"
)

कोड उदाहरण के साथ त्वरित शुरुआत

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

package main

import (
    "go.uber.org/zap"
)

func main() {
    // प्रोडक्शन लॉगर बनाएं (उच्च प्रदर्शन)
    logger, _ := zap.NewProduction()
    defer logger.Sync() // बाहर निकलने से पहले बफर को फ्लश करें

    // फील्ड के साथ संदेश लॉग करें
    logger.Info("एप्लिकेशन शुरू हुआ",
        zap.String("version", "1.0.0"),
        zap.Int("port", 8080),
    )

    // सुविधा के लिए SugaredLogger का उपयोग करें
    sugar := logger.Sugar()
    sugar.Infow("उपयोगकर्ता ने लॉगिन किया",
        "user", "ram_sharma",
        "ip", "192.168.1.1",
    )
}

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

package main

import (
    "github.com/sirupsen/logrus"
)

func main() {
    // आउटपुट फॉर्मेट सेट करें (JSON)
    logrus.SetFormatter(&logrus.JSONFormatter{})

    // लॉगिंग लेवल सेट करें
    logrus.SetLevel(logrus.InfoLevel)

    // फील्ड के साथ संदेश लॉग करें
    logrus.WithFields(logrus.Fields{
        "version": "1.0.0",
        "port":    8080,
    }).Info("एप्लिकेशन शुरू हुआ")

    // त्रुटि लॉग करें
    logrus.WithFields(logrus.Fields{
        "user": "ram_sharma",
        "ip":   "192.168.1.1",
    }).Warn("गलत पासवर्ड से लॉगिन का प्रयास")
}

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

1. Zap: NewProduction() / NewDevelopment()

क्या करता है: प्रोडक्शन या डेवलपमेंट एनवायरनमेंट के लिए पूर्व-कॉन्फ़िगर्ड लॉगर बनाता है। प्रोडक्शन लॉगर JSON फॉर्मेट का उपयोग करता है और स्पीड के लिए ऑप्टिमाइज़्ड है। डेवलपमेंट लॉगर रंगीन टेक्स्ट आउटपुट और स्टैक ट्रेस शामिल करता है।

पैरामीटर: कोई नहीं (यह *zap.Logger और एक त्रुटि लौटाता है)।

उदाहरण:

prodLogger, _ := zap.NewProduction()
devLogger, _ := zap.NewDevelopment()

2. Zap: Logger.Info(), Logger.Warn(), Logger.Error()

क्या करता है: निर्दिष्ट लेवल पर संदेश लॉग करता है। ये मेथड फील्ड को अतिरिक्त पैरामीटर के रूप में लेते हैं।

पैरामीटर: स्ट्रिंग संदेश, उसके बाद वैकल्पिक zap.Field पैरामीटर।

उदाहरण:

logger.Info("सर्वर शुरू", zap.String("host", "localhost"), zap.Int("port", 3000))
logger.Warn("डिस्क स्पेस कम", zap.Float64("free_gb", 1.5))
logger.Error("डेटाबेस कनेक्शन विफल", zap.Error(err))

3. Zap: SugaredLogger.Infow(), SugaredLogger.Warnw(), SugaredLogger.Errorw()

क्या करता है: SugaredLogger के साथ की-वैल्यू पेयर का उपयोग करके लॉगिंग का एक सरल तरीका प्रदान करता है।

पैरामीटर: स्ट्रिंग संदेश, उसके बाद वैकल्पिक की-वैल्यू पेयर (जैसे, "key", value)।

उदाहरण:

sugar.Infow("नया ऑर्डर प्राप्त हुआ", "order_id", 12345, "amount", 99.99)
sugar.Errorw("पेमेंट प्रोसेसिंग विफल", "error", err, "order_id", 12345)

4. Logrus: WithFields()

क्या करता है: लॉग संदेश में अतिरिक्त फील्ड जोड़ता है। यह एक नया Entry ऑब्जेक्ट लौटाता है जिस पर आप लॉग मेथड कॉल कर सकते हैं।

पैरामीटर: logrus.Fields टाइप का एक मैप (जो map[string]interface{} है)।

उदाहरण:

logrus.WithFields(logrus.Fields{
    "user": "sita_devi",
    "action": "login",
}).Info("उपयोगकर्ता कार्रवाई लॉग की गई")

5. Logrus: SetLevel()

क्या करता है: वैश्विक लॉगिंग लेवल सेट करता है। इस लेवल से कम महत्व के संदेश लॉग नहीं होंगे।

पैरामीटर: logrus.Level टाइप का एक मान (जैसे, logrus.InfoLevel, logrus.ErrorLevel)।

उदाहरण:

logrus.SetLevel(logrus.WarnLevel) // केवल Warn और Error लॉग करें

6. Logrus: SetFormatter()

क्या करता है: आउटपुट फॉर्मेट सेट करता है। सामान्य फॉर्मेटर में JSONFormatter और TextFormatter शामिल हैं।

पैरामीटर: एक logrus.Formatter इंटरफ़ेस को लागू करने वाला ऑब्जेक्ट।

उदाहरण:

logrus.SetFormatter(&logrus.JSONFormatter{})
// या
logrus.SetFormatter(&logrus.TextFormatter{FullTimestamp: true})

निष्कर्ष

Zap और Logrus दोनों Go में लॉगिंग के लिए शक्तिशाली उपकरण हैं। Zap उच्च प्रदर्शन और न्यूनतम ओवरहेड प्रदान करता है, जो इसे प्रोडक्शन एप्लिकेशन के लिए आदर्श बनाता है। Logrus एक सरल API और व्यापक इंटीग्रेशन विकल्प प्रदान करता है, जो शुरुआती और छोटे प्रोजेक्ट के लिए उपयुक्त है। अपनी आवश्यकताओं के अनुसार चुनें: यदि गति महत्वपूर्ण है, तो Zap चुनें; यदि सादगी और लचीलापन चाहिए, तो Logrus चुनें।