रूबी में लॉग के साथ कार्य करना

लॉगिंग उन प्राथमिक कार्यों में से एक है जिसे एक एप्लिकेशन आमतौर पर संबोधित करता है। लॉग का उपयोग तब किया जाता है जब आपको आवश्यकता होती है, उदाहरण के लिए,

• देखें कि आपके ऐप्स के अंदर क्या हो रहा है,
• उन पर नज़र रखें, या
• कुछ विशिष्ट डेटा के लिए मीट्रिक एकत्र करें।

एक नई प्रोग्रामिंग भाषा सीखते समय, लॉग जानकारी के लिए पहली स्पष्ट पसंद मूल तंत्र है। यह आमतौर पर आसान, प्रलेखित और पूरे समुदाय में अच्छी तरह से फैला हुआ होता है।

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

इस लेख में, हम रूबी और रेल के लिए लॉगिंग के उपलब्ध विकल्पों के बारे में जानेंगे, बिल्ट-इन से लेकर प्रिय तृतीय-पक्ष सामुदायिक ढांचे तक। चलो चलें!

रूबी के अंतर्निर्मित विकल्प

रूबी लॉगिंग को संभालने के लिए दो अंतर्निहित विकल्पों के साथ आता है:प्रिंटिंग कमांड (विशेष रूप से कमांड-लाइन परिदृश्यों के लिए डिज़ाइन किया गया) और लॉगर क्लास।

आइए उन्हें थोड़ा एक्सप्लोर करें।

कंसोल पर प्रिंट करना

रूबी के पास कंसोल पर टेक्स्ट प्रिंट करने के चार सामान्य तरीके हैं:puts , print , p , और pp ।

puts विधि आपके द्वारा पास की गई किसी भी चीज़ को प्रिंट करती है, उसके बाद एक नई लाइन:

2.7.0 :001 > puts "Hey, I'm a log!"
Hey, I'm a log!
 => nil

print विधि puts . के समान है , हालांकि यह हमेशा to_s . का उपयोग करके तर्कों को स्ट्रिंग में परिवर्तित करता है विधि।

अंत में, p और pp मेथड्स दोनों उस कच्ची वस्तु को प्रिंट करेंगे जो आप उन्हें बिना रूपांतरण किए पास कर रहे हैं; अंतर केवल इतना है कि बाद वाला आउटपुट को अधिक इंडेंटेड तरीके से प्रारूपित करता है, जबकि पूर्व नहीं करता है।

एप्लिकेशन लॉग

सर्वर पर चल रहे एप्लिकेशन के लिए, कंसोल पर प्रिंट करने का कोई मतलब नहीं है।

इसके बजाय, हम Logger . का उपयोग करते हैं वर्ग, जो बहुत अधिक लचीला है।

यहां बताया गया है कि आप इसका उपयोग "डीबग" लॉग प्रिंट करने के लिए कैसे कर सकते हैं:

require "logger"
logger = Logger.new(STDOUT)
logger.debug("I'm a debug log")

हम लॉग को फ़ाइल में संग्रहीत करने के लिए इसे कॉन्फ़िगर भी कर सकते हैं, या यदि हम चाहें तो STDOUT को प्रिंट करने के बजाय उन्हें लॉग एग्रीगेटर को भेज सकते हैं।

यदि आप सोच रहे हैं, "डीबग" एक लॉग स्तर है। लॉग स्तर आपको सिस्टम को बताते हैं "यह लॉग संदेश एक निश्चित प्रकार की घटना से संबंधित है।" छह अंतर्निहित लॉग स्तर हैं:घातक, त्रुटि, चेतावनी, जानकारी, डीबग और अज्ञात।

logger.debug("I'm a debug log")
logger.info("I'm an info log")
logger.warn("I'm a warn log")
logger.error("I'm an error log: error message")
logger.fatal("I'm a fatal log")

जब हम लॉग आउटपुट को देखते हैं, तो हम देखते हैं कि लॉग स्तर, प्रक्रिया आईडी और टाइमस्टैम्प प्रत्येक पंक्ति में जोड़ दिए गए हैं:

एक और बढ़िया विशेषता आपके Logger . को सेट करने की क्षमता है एक विशिष्ट स्तर पर वस्तु:

logger.level = Logger::WARN

जब आप ऐसा करते हैं, Logger केवल चेतावनी . के बराबर या उच्चतर लॉग को ही हैंडल करेगा महत्व में। यह उत्पादन में बहुत उपयोगी है, जहां हम आकार या सुरक्षा कारणों से "डीबग" लॉग को सहेजना नहीं चाहते हैं।

यह आउटपुट होना चाहिए:

अपने लॉग को कस्टमाइज़ करना

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

logger.datetime_format = "%Y-%m-%d %H:%M"

यहां आउटपुट का एक उदाहरण दिया गया है:

W, [2020-07-28 10:50#87786]  WARN -- : I'm a warn log

date_time प्रारूप मानक विनिर्देश का पालन करता है, इसलिए ऐसे परिवर्तन करते समय इसका उल्लेख करना सुनिश्चित करें।

कभी-कभी, हालांकि, आपको अपने लॉग के प्रारूप को पूरी तरह से संशोधित करने की आवश्यकता हो सकती है। इस उद्देश्य के लिए, रूबी फ़ॉर्मेटर वर्ग प्रदान करता है। यह डेवलपर्स को उस डिफ़ॉल्ट टेम्पलेट को अधिलेखित करने की अनुमति देकर काम करता है जो Logger लॉग प्रिंट करने के लिए उपयोग करता है।

कल्पना करें कि आपका ऐप एक केंद्रीकृत लॉग विश्लेषण टूल का उपयोग करता है और आपके सभी लॉग को name=value में प्रिंट करने की आवश्यकता है प्रारूप। यह नया फॉर्मेटर कोड होगा:

logger.formatter = proc do |severity, datetime, progname, msg|
    date_format = datetime.strftime("%Y-%m-%d %H:%M:%S")
    "date=[#{date_format}] severity=#{severity.ljust(5)} pid=##{Process.pid} message='#{msg}'\n"
end

यहां, हम एक proc . का उपयोग कर रहे हैं सभी लॉग को इंटरसेप्ट करने के लिए और डिफ़ॉल्ट तरीके को बदलने के लिए वे वांछित एक पर मुद्रित होते हैं। अब, हमारे पास निम्नलिखित परिणाम हैं:

कोड की कुछ पंक्तियों के साथ, आपके सभी ऐप लॉग अब टूल द्वारा अनुक्रमित किए जा सकते हैं।

JSON में लॉग इन करना

Formatter . की शक्ति के साथ हाथ में, अपने लॉग को आप जो भी आउटपुट प्रकार चाहते हैं, उसे अनुकूलित करना आसान है। उदाहरण के लिए, हम अपने लॉग को उस प्रारूप में आउटपुट करने के लिए JSON मॉड्यूल का उपयोग कर सकते हैं।

require "json"
logger.formatter = proc do |severity, datetime, progname, msg|
    date_format = datetime.strftime("%Y-%m-%d %H:%M:%S")
    JSON.dump(date: "#{date_format}", severity:"#{severity.ljust(5)}", pid:"##{Process.pid}", message: msg) + "\n"
end

और, यहाँ परिणामी लॉग हैं:

फ़ाइल में प्रवेश करना

जैसा कि पहले देखा गया, Logger कंस्ट्रक्टर, पहले तर्क के रूप में, वह स्थान प्राप्त करता है जहाँ लॉग को संग्रहीत किया जाना चाहिए।

यदि आप अपने लॉग को किसी फ़ाइल में सहेजना चाहते हैं, तो बस इतना कहें:

require 'logger'
logger = Logger.new('my_logs.log')

यह एक नई फ़ाइल बनाएगा my_logs.log उसी फ़ोल्डर में जहां इस कोड वाली आपकी रूबी फ़ाइल स्थित है:

हालाँकि, वर्ग कस्टम विकल्पों के एक समूह की भी अनुमति देता है, जैसे कि अवधारण नीति कॉन्फ़िगरेशन। निम्नलिखित उदाहरण लें:

# Keep data for the current week.
Logger.new('my_weekly_logs.log', 'weekly')
# Keep data for today and the past 2 months.
Logger.new('my_latest_2_months_logs.log', 2, 'monthly')
# Restarts the log over when it exceeds 26GB in size.
Logger.new('my_custom_logs.log', 0, 20 * 1024 * 1024 * 1024)

दूसरे परम के रूप में, Logger इस परिभाषा को स्वीकार करता है कि उसे कितनी बार लॉग रखना चाहिए या उन्हें मिटा देना चाहिए।

पहली वस्तु में लट्ठों को केवल एक सप्ताह के लिए रखा जाएगा। दूसरा उन्हें दो महीने की अवधि के लिए संग्रहीत करेगा, जबकि नवीनतम तीसरे पैरामीटर के आधार पर फ़ाइल के आकार का विश्लेषण करेगा (उदाहरण के लिए, जब भी यह 20GB तक पहुंच जाएगा, तो इसे छोड़ दिया जाएगा)।

रूबी ऑन रेल्स में लॉग इन करना

Logger . के अधिकांश लाभ हमने अब तक देखा है कि सभी को रेल ऐप के साथ इस्तेमाल किया जा सकता है। Logger . का रेल संस्करण रूबी के मूल वर्ग का एक साधारण विस्तार है।

इसके अलावा, रेल एक अच्छी सुविधा भी जोड़ता है जिससे देव अपने लॉग को कई लॉगर्स पर प्रसारित कर सकते हैं। इस प्रकार, यदि आप एक से अधिक लॉगिंग लाइब्रेरी के साथ काम करना चाहते हैं, तो आप रेल logger के भीतर ऐसा कर सकते हैं :

custom_logger = Logger.new(STDOUT)
Rails.logger.extend(ActiveSupport::Logger.broadcast(custom_logger))

यह तब भी उपयोगी हो सकता है जब आपको अपने लॉग्स को जाने वाले स्थानों के बारे में कुछ बुद्धिमत्ता की आवश्यकता हो। आपके ऐप के कुछ हिस्सों को अलग-अलग स्थानों या अलग-अलग प्रारूपों में लॉग की आवश्यकता हो सकती है।

तृतीय-पक्ष लॉगिंग फ्रेमवर्क चुनना

अगर रूबी का बिल्ट-इन लॉगर ठीक वैसा नहीं करता जैसा आपको चाहिए, तो आपके पास विकल्प हैं।

जब किसी तृतीय-पक्ष लॉगिंग ढांचे को चुनने की बात आती है तो बहुत सारे विकल्प होते हैं। इनमें से सबसे लोकप्रिय लॉगरेज है। आइए इसे देखें!

लॉगरेज के साथ पहला चरण

रेल ऐप्स के लिए लॉगरेज बनाया गया था। यदि आप वेनिला रूबी के साथ काम कर रहे हैं, तो यह एक अच्छा विकल्प नहीं हो सकता है।

इसे स्थापित करने के लिए, बस निम्नलिखित रत्न जोड़ें:

bundle add lograge

फिर, config/initializers/lograge.rb . पर एक नई कॉन्फ़िग फ़ाइल बनाएँ निम्नलिखित कोड के साथ:

Rails.application.configure do
    config.lograge.enabled = true
    config.lograge.custom_options = lambda do |event|
        { time: event.time }
    end
end

यह कॉन्फिगरेशन लॉगरेज को सक्षम बनाता है और उस समय को परिभाषित करता है जब एक लॉग, जिसे फ्रेमवर्क के लिए एक घटना माना जाता है, को प्रिंट करना होता है।

जब आप रेल ऐप शुरू करते हैं और पहले एंडपॉइंट तक पहुंचते हैं, तो लॉगरेज अनुरोध सारांश प्रिंट करेगा। क्रमशः लॉगरेज सेटअप से पहले और बाद में लॉग की तुलना करने पर, परिणाम कुछ इस तरह दिखाई देते हैं:

फिर से, लॉगरेज चांदी की गोली नहीं है; यह वास्तव में एक बहुत ही सुविचारित ढांचा है। इसलिए, आपको शायद इसे बिल्ट-इन Logger . के साथ उपयोग करने की आवश्यकता होगी (या आपकी पसंद के अन्य ढांचे)।

रैपिंग अप

अंत में, यह स्पष्ट हो जाता है कि लॉगिंग न केवल आपकी परियोजनाओं का एक महत्वपूर्ण हिस्सा है बल्कि इसे बहुत कम करके आंका गया है। आपके द्वारा उपयोग किए जा रहे टूल को बेहतर ढंग से समझने के लिए, चाहे वे स्थानीय हों, आपको बेहतर परिणाम प्राप्त करने में भी मदद मिलेगी।

एक नया ढांचा अपनाने के लिए हमेशा बहुत सारे परीक्षण करना सुनिश्चित करें। कभी-कभी आपका प्लेटफ़ॉर्म पहले से ही बेहतरीन बिल्ट-इन विकल्पों के साथ आता है। यदि ऐसा नहीं है, तो निर्धारित करें कि क्या यह पहले से मौजूद ढांचे के साथ एकीकृत अन्य फ़्रेमवर्क के उपयोग की अनुमति देता है।

शुभकामनाएँ!