Logger क्लास
Ruby Logger क्लास आपको एक डिफ़ॉल्ट आउटपुट फॉर्मेट और गंभीरता के विभिन्न स्तरों के साथ लॉग जनरेट करने का एक तरीका देती है।
यहाँ लॉग बनाने का तरीका है:
logger = Logger.new("my_log.txt")
यह लॉगिंग मैसेजेस को my_log.txt में लिखेगा।
यदि आप प्रोग्राम चल रहे टर्मिनल पर मैसेजेस प्रदर्शित करना चाहते हैं, तो आप STDOUT पर लॉग कर सकते हैं।
इस तरह:
logger = Logger.new(STDOUT)
लॉगिंग मैसेजेस के अलग-अलग स्तर हो सकते हैं, यह इस बात पर निर्भर करता है कि वे कितने महत्वपूर्ण हैं।
स्तर हैं:
- DEBUG
- INFO
- WARN
- ERROR
- FATAL
- UNKNOWN
हर स्तर में एक संबंधित इंस्टेंस मेथड होता है।
तो अगर आप "info" लॉग करना चाहते हैं।
यह करें:
logger.info("मैं RubyGuide के बारे में लॉगिंग पढ़ रहा हूँ!")
वास्तविक लॉग एंट्री इस तरह दिखती है:
# I, [2019-08-08T19:22:00.152079 #642] INFO -- : मैं RubyGuide के बारे में लॉगिंग पढ़ रहा हूँ!
ये अलग-अलग स्तर होने से आपको अपनी लॉग फाइल को फ़िल्टर करने में मदद मिलती है, ताकि आप जो खोज रहे हैं उसे तेजी से ढूंढ सकें!
यह आपको यह देखने में भी मदद करता है कि आप समय के साथ कितने एरर और चेतावनी मैसेजेस जनरेट करते हैं।
बहुत बढ़िया!
अपने लॉग्स को कैसे फॉर्मेट करें
अपने Ruby लॉग्स के लिए डिफ़ॉल्ट आउटपुट फॉर्मेट का उपयोग करना बहुत अच्छा है क्योंकि टूल्स इसके आसपास बनाए जा सकते हैं और अधिक लोग समझ सकते हैं कि यह कैसे काम करता है।
यहाँ फिर से एक लॉग लाइन है:
# I, [2019-08-08T19:22:00.152079 #642] INFO -- : test
इसके कुछ घटक हैं:
- "I" गंभीरता स्तर के पहले अक्षर को दर्शाता है
- ब्रैकेट्स के अंदर, आपको टाइमस्टैम्प और उस प्रोसेस की प्रोसेस आईडी (PID) मिलती है जिसने यह लॉग मैसेज जनरेट किया
- INFO गंभीरता स्तर का पूरा नाम है
- कोलन के बाद, हमारे पास वह वास्तविक मैसेज है जिसे लॉग किया गया था
लेकिन यह फॉर्मेट हर किसी के लिए आदर्श नहीं हो सकता।
इसलिए Ruby आपको इसे बदलने की अनुमति देता है!
यहाँ कैसे:
logger.formatter = proc { |severity, datetime, progname, msg| "#{severity}, #{datetime}, #{msg}\n" }
परिणामस्वरूप, आपको यह आउटपुट मिलता है:
DEBUG, 2019-08-08 19:39:01 +0200, testing
आप इसका उपयोग अतिरिक्त जानकारी जोड़ने के लिए कर सकते हैं जो आपके और आपकी टीम के लिए उपयोगी हो सकती है।
अपने लॉग साइज को कैसे सीमित करें
लॉग्स वास्तव में बड़ी फाइलें बन सकती हैं जब तक कि आप उनके आकार पर नज़र नहीं रखते।
यदि आप लॉग्स के कारण डिस्क स्पेस से बाहर निकलते हैं, तो आपके सिस्टम में सभी प्रकार की अजीब चीज़ें होने लगती हैं।
एक समाधान है!
आप अपने लॉग्स के आकार को सीमित कर सकते हैं।
यहाँ कैसे:
MEGABYTE = 1024 ** 2
ONE_HUNDRED_MEGABYTES = MEGABYTE * 100
logger = Logger.new("my_log.txt", 1, ONE_HUNDRED_MEGABYTES)
पहला पैरामीटर वह है जहां लॉग मैसेजेस सेव करने हैं।
दूसरा पैरामीटर है कि आप कितनी लॉग फाइलें रखना चाहते हैं (लॉग रोटेशन), और अंतिम पैरामीटर अधिकतम फाइल आकार है।
लॉग पढ़ना और फ़िल्टरिंग
ठीक है, आपको अपने लॉग्स मिल गए।
आप उन्हें कैसे पढ़ते हैं और जो आपको चाहिए वह ढूंढते हैं?
लॉग्स प्लेन-टेक्स्ट फाइलें हैं, इसलिए आप किसी भी टेक्स्ट-प्रोसेसिंग टूल्स का उपयोग कर सकते हैं जो आप पसंद करते हैं।
उदाहरण के लिए:
Grep।
यह एक कमांड-लाइन टूल है जिसका उपयोग आप टेक्स्ट फाइलों को फ़िल्टर करने के लिए कर सकते हैं।
यहाँ कैसे:
grep INFO my_log.txt
यह आपको हर लाइन देता है जिसे "INFO" के रूप में लॉग किया गया है।
आप grep का उपयोग करके अपने लॉग्स के अंदर किसी भी अन्य टेक्स्ट को खोज सकते हैं, बस "INFO" को आप जो खोज रहे हैं उससे बदलें।
एक और यूनिक्स टूल जिसका आप उपयोग कर सकते हैं वह है less (-R विकल्प के साथ)।
यह आपको केवल अपने कीबोर्ड का उपयोग करके लॉग्स के माध्यम से स्क्रॉल करने की अनुमति देता है और इसमें एक खोज फ़ंक्शन है।
आप भी उपयोग कर सकते हैं...
लॉग मैनेजमेंट और खोज के लिए विशिष्ट टूल्स।
जैसे Discourse का logster gem।
सारांश
आपने Ruby में लॉगिंग के बारे में सीखा, यह क्या है, यह कैसे काम करता है, और इसका उपयोग कैसे करें।
अब इसे आज़माने की आपकी बारी है।
पढ़ने के लिए धन्यवाद!
